Des résultats plus clairs pour les agents IA : Laravel PAO, un framework web PHP libre et open source, offre des résultats optimisés pour l'IA lorsque certains outils PHP sont exécutés par un agent IA
Laravel a lancé Laravel PAO, un système de sortie optimisé pour les agents PHP conçu pour redéfinir la manière dont les agents IA interagissent avec les outils de développement PHP courants. Lorsque des outils tels que PHPUnit, Pest, Paratest, PHPStan, Rector ou Laravel Artisan sont invoqués par un agent IA, Laravel PAO fournit une sortie JSON structurée ou rationalisée. Cette approche remplace la sortie console typiquement « décorée », réduisant ainsi le bruit et améliorant la clarté pour le traitement automatique.
Laravel est un framework web PHP libre et open source destiné à la création d'applications web. Il a été créé par Taylor Otwell et est destiné au développement d'applications web suivant le modèle architectural modèle-vue-contrôleur (MVC) et basé sur Symfony. Parmi les fonctionnalités de Laravel, on trouve un système de paquets modulaires avec un gestionnaire de dépendances dédié, différentes méthodes d'accès aux bases de données relationnelles, des utilitaires facilitant le déploiement et la maintenance des applications, ainsi qu'une orientation vers le « syntactic sugar ».
Récemment, Laravel a lancé Laravel PAO, un système de sortie optimisé pour les agents PHP conçu pour redéfinir la manière dont les agents IA interagissent avec les outils de développement PHP courants. Lorsque des outils tels que PHPUnit, Pest, Paratest, PHPStan, Rector ou Laravel Artisan sont invoqués par un agent IA, Laravel PAO fournit une sortie JSON structurée ou rationalisée. Cette approche remplace la sortie console typiquement « décorée », réduisant ainsi le bruit et améliorant la clarté pour le traitement automatique.
À la suite de cette version, toutes les nouvelles applications Laravel incluront PAO par défaut en tant que dépendance de développement. Pour les frameworks de test tels que PHPUnit, Pest et Paratest, PAO fournit des résumés JSON compacts. Ceux-ci incluent le nombre de tests, les durées, les détails des échecs ou des erreurs, ainsi que des segments supplémentaires tels que la couverture de code ou le profilage, présentés sans le formatage standard du terminal.
De plus, pour l'analyse statique avec PHPStan, PAO normalise la sortie en JSON, en mettant l'accent sur le nombre total d'erreurs et les détails par fichier pertinents pour les corrections automatisées. La sortie de Rector est également adaptée, avec un rapport structuré des fichiers modifiés, des différences de code et des rectors appliqués. La sortie de la commande Artisan est débarrassée des éléments décoratifs mais conserve le contenu informatif dans son format standard. Il est à noter que les workflows des développeurs locaux ne sont pas affectés, car PAO ne s'active que lorsqu'un agent compatible est détecté.
Voici l'annonce de Laravel PAO :
Présentation de Laravel PAO : une sortie plus épurée pour les agents IA
Les développeurs PHP et Laravel effectuent toute la journée la même boucle de rétroaction : tester, corriger, analyser, refactoriser, puis tester à nouveau. Les outils de cette boucle produisent une sortie conçue pour les terminaux humains : couleurs ANSI, lignes de points et tableaux décorés. Cette sortie convient lorsque vous la lisez, mais elle devient encombrante lorsqu’un agent la traite.
Pour un agent, ce même résultat peut masquer les éléments importants : l'assertion qui échoue, le chemin d'accès au fichier, le numéro de ligne, l'identifiant PHPStan, le diff Rector.
Laravel PAO (PHP agent-optimized output) résout ce problème. Il détecte quand des outils PHP pris en charge sont exécutés par un agent IA, tel que Claude Code, Cursor, Devin, Gemini CLI ou d'autres. Pour les outils de test et d'analyse, Laravel PAO renvoie un JSON compact et structuré. Pour les commandes Artisan, il nettoie la sortie de console décorée afin que les agents reçoivent les mêmes informations avec moins de bruit.
À partir d'aujourd'hui, les nouvelles applications Laravel incluent PAO comme dépendance de développement par défaut.
Ce qui change avec Laravel PAO
Prenons une grande suite de tests PHPUnit. Sans Laravel PAO, un agent reçoit des centaines de caractères de sortie de progression avant de voir si la suite a réussi ou échoué :
PHPUnit 12.5.14 by Sebastian Bergmann and contributors.............................................................. 61 / 1002 ( 6%)............................................................. 122 / 1002 ( 12%)............................. 1002 / 1002 (100%)Time: 00:00.321, Memory: 46.50 MBOK (1002 tests, 1002 assertions)
Avec Laravel PAO, l'agent obtient plutôt ceci :
{"tool":"phpunit","result":"passed","tests":1002,"passed":1002,"duration_ms":321}
Cette différence peut sembler minime dans un article, mais elle revêt une grande importance lors d'une session de l'agent. La sortie reste concise, quel que soit le nombre de tests réussis.
Les échecs deviennent également plus utiles. Au lieu de demander à l'agent de fouiller dans une sortie de terminal formatée, PAO lui fournit les détails dont il a besoin pour continuer à travailler :
{ "tool": "phpunit", "result": "failed", "tests": 2, "passed": 1, "failed": 1, "failures": [ { "test": "Tests\\Feature\\ExampleTest::it_returns_a_successful_response", "file": "tests/Feature/ExampleTest.php", "line": 17, "message": "Failed asserting that 500 is identical to 200." } ]}
L'agent sait ce qui a échoué, où cela s'est produit et quel message il doit analyser ensuite.
PAO prend en charge les outils que vous utilisez déjà
Laravel PAO prend actuellement en charge les sorties de PHPUnit, Pest, Paratest, PHPStan, Rector et Laravel Artisan.
Pour PHPUnit, Pest et Paratest, PAO génère des rapports de résultats concis : nombres, durées, échecs, erreurs, tests ignorés, avertissements, notifications et dépréciations. Les sorties supplémentaires utiles, telles que les résumés de couverture ou de profilage, sont nettoyées et incluses sans le bruit de fond du terminal.
La sortie PHPStan est normalisée en JSON et se concentre sur le nombre total d'erreurs ainsi que sur les détails par fichier dont les agents ont besoin pour les corriger :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| {
"tool": "phpstan",
"result": "failed",
"errors": 2,
"error_details": {
"app/Http/Controllers/Controller.php": [
{
"line": 9,
"message": "Method Controller::index() should return int but returns string.",
"identifier": "return.type"
}
]
}
} |
La sortie Rector est également simplifiée pour les agents, car elle conserve les fichiers modifiés, les différences et les rectors appliqués dans un format structuré.
L'objectif n'est pas d'inventer un nouveau workflow. Il s'agit de rendre le workflow que les développeurs Laravel utilisent déjà plus facile à suivre pour les agents.
Une sortie Artisan plus claire
Pour les commandes Artisan, le résultat n’est pas au format JSON. Il s’agit de la même sortie de commande, mais sans les éléments décoratifs.
Les commandes telles que about, db:show et migrate:status incluent souvent des tableaux décorés, des séparateurs par points, des couleurs et des espacements. Ces détails rendent la sortie agréable pour les humains, mais les agents n’en ont pas besoin.
Par exemple, une sortie comme celle-ci :
1
2
3
4
5
| Environment ................................................................
Application Name ................................................... Laravel
Laravel Version ..................................................... 13.3.0
PHP Version .......................................................... 8.5.4
Debug Mode ......................................................... ENABLED |
devient
1
2
3
4
5
| Environment ..
Application Name .. Laravel
Laravel Version .. 13.3.0
PHP Version .. 8.5.4
Debug Mode .. ENABLED |
Mêmes informations, moins de tokens à traiter pour l’agent.
Votre terminal reste le même
Ce point est important : Laravel PAO ne modifie pas l'expérience du terminal pour vous ou votre équipe.
Lorsque vous exécutez phpunit, pest, phpstan, rector ou artisan directement dans votre terminal, la sortie reste la même. PAO ne s'active que lorsqu'un agent est détecté. Cela offre à Laravel de meilleurs paramètres par défaut pour le développement assisté par IA sans nuire au flux de travail humain.
Comment fonctionne PAO en coulisses
Laravel PAO n'introduit pas de nouveau binaire et ne vous demande pas d'exécuter une commande différente. Il démarre via le chargement automatique de fichiers de Composer, ce qui lui permet de s'exécuter tôt dans le processus PHP :
1
2
3
4
5
6
7
| {
"autoload": {
"files": [
"src/Autoload.php"
]
}
} |
Ce fichier de chargement automatique se ferme immédiatement, sauf si le processus en cours s'exécute dans un environnement d'agent
1
2
3
4
5
| $agent = AgentDetector::detect();
if (! $agent->isAgent) {
return;
} |
À partir de là, PAO examine la commande en cours d'exécution et sélectionne le pilote correspondant
1
2
3
4
5
| $starter = match (basename($argv[0] ?? '')) {
'pest' => new Drivers\Pest\Starter,
'phpunit' => new Drivers\Phpunit\Starter,
// ...
}; |
Pour les exécuteurs de tests, PAO évite de récupérer la sortie du terminal. PHPUnit, Paratest et Pest disposent déjà du résultat réel en interne. Pour PHPUnit, PAO injecte l'option --no-output de PHPUnit. Pour Pest et Paratest, PAO désactive l'affichage de la progression et laisse l'exécuteur fonctionner normalement.
À l'arrêt, PAO capture le résultat du test directement à partir de la façade de résultats de PHPUnit et construit le JSON à partir des données de résultat réelles :
$result = PHPUnit\TestRunner\TestResult\Facade::result();
Pour Paratest, PAO utilise un exécuteur wrapper afin que les résultats des workers parallèles puissent être fusionnés avant que la réponse finale ne soit écrite.
À partir de là, PAO extrait les champs qui intéressent les agents :
1
2
3
4
5
6
7
| $result = [
'result' => $testResult->wasSuccessful() ? 'passed' : 'failed',
'tests' => $testResult->numberOfTestsRun(),
'assertions' => $testResult->numberOfAssertions(),
// ...
]; |
Cela permet à PAO d'obtenir les nombres réels, les assertions, la durée, les échecs, les erreurs, les avertissements, les dépréciations et les emplacements des fichiers sans avoir à procéder à une ingénierie inverse du texte formaté.
Pour PHPStan et Rector, PAO s'appuie sur les modes JSON propres à ces outils plutôt que d'analyser leur sortie lisible par l'homme :
1
2
| $_SERVER['argv'][] = '--error-format=json';
$_SERVER['argv'][] = '--no-progress'; |
PAO normalise ensuite ces réponses en les transformant en champs dont les agents ont le plus besoin. Les détails des erreurs PHPStan sont également limités par défaut, avec une indication de passer l'option -v lorsque la liste complète est nécessaire.
À la fin d'une commande de test, d'analyse ou de refactorisation, PAO écrit un seul objet JSON vers la sortie standard. Toute sortie supplémentaire utile, telle que les informations de couverture ou de profilage, est nettoyée et incluse sans la décoration du terminal qui l'entoure.
Artisan emprunte une voie différente. Dans les applications Laravel, le fournisseur de services de PAO est détecté automatiquement. Lorsqu'un agent est détecté, il lie l'OutputStyle de la console Laravel à l'implémentation de PAO et désactive la décoration de la console Symfony dès le lancement des commandes :
1
2
3
4
5
| $this->app->bind(OutputStyle::class, PaoOutputStyle::class);
$events->listen(CommandStarting::class, function (CommandStarting $event): void {
$event->output->setDecorated(false);
}); |
Vos commandes Artisan continuent d'utiliser les mêmes API de console, tandis que PAO nettoie la sortie à la limite.
Disponible par défaut pour offrir de meilleures valeurs par défaut aux agents IA
Les nouvelles applications Laravel incluent désormais automatiquement Laravel PAO ; il n'y a donc aucun fichier de configuration à publier et aucune installation n'est requise.
Si vous souhaitez ajouter PAO à une application Laravel existante ou à un projet PHP autonome, installez-le avec Composer :
composer require laravel/pao --dev
PAO fonctionne avec Laravel 12 et versions ultérieures ainsi qu'avec PHP 8.3 et versions ultérieures, et peut également être utilisé dans des projets PHP non-Laravel qui utilisent des outils pris en charge via l'autochargeur de Composer.
Laravel a toujours accordé une grande importance aux détails qui facilitent le développement : des pages d'erreur claires, des sorties de console explicites, des paramètres par défaut bien pensés et des outils qui vous aident à rester dans le flux.
À mesure que les agents s'intègrent à ce flux de travail, ils ont besoin du même niveau d'attention. Laravel PAO rend le terminal agréable à l'œil pour les humains et facilite la compréhension, la synthèse et l'exécution des sorties de commande par les agents.
Sources : Annonce de Laravel PAO, Laravel PAO sur GitHub
Et vous ?
Pensez-vous que cette annonce est crédible ou pertinente ?
Quel est votre avis sur le sujet ?
Voir aussi :
Laravel injecte désormais des publicités directement dans le contexte de votre agent IA pour orienter les développeurs vers son offre cloud commerciale, après avoir levé 57 millions de dollars en capital-risque
Laravel 11 est maintenant disponible s'accompagnant de Laravel Reverb. Le framework web pour PHP introduit une structure d'application minimale et utilise SQLite par défaut
L'état de PHP en 2024 : démographie, EDI, frameworks, adoption de l'IA, quelles sont les grandes tendances qui caractérisent l'écosystème ?
Laravel PAO fournit une sortie optimisée pour l'IA lorsque certains outils PHP sont exécutés par un agent IA
Répondre avec citation
Partager