PHP code example of thumanics / laravel-boost

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

    

thumanics / laravel-boost example snippets

declare(strict_types=1);

namespace Laravel\Boost\Mcp\Tools;

use Illuminate\Contracts\JsonSchema\JsonSchema;
use Illuminate\JsonSchema\Types\Type;
use Laravel\Mcp\Request;
use Laravel\Mcp\Response;
use Laravel\Mcp\Server\Tool;
use Laravel\Mcp\Server\Tools\Annotations\IsReadOnly;

#[IsReadOnly] // Ajouter si l'outil ne modifie aucun etat
class MonOutil extends Tool
{
    protected string $description = 'Description claire de ce que fait l\'outil';

    /**
     * @return array<string, Type>
     */
    public function schema(JsonSchema $schema): array
    {
        return [
            'param_requis' => $schema
                ->string()
                ->description('Description du parametre')
                ->

public function __construct(protected Roster $roster)
{
    //
}

protected function discoverTools(): array
{
    return $this->filterPrimitives([
        // ... outils existants ...
        MonOutil::class,  // <-- Ajouter ici
    ], 'tools');
}

declare(strict_types=1);

use Laravel\Boost\Mcp\Tools\MonOutil;
use Laravel\Mcp\Request;

test('it returns expected data', function (): void {
    $tool = new MonOutil;
    $response = $tool->handle(new Request(['param_requis' => 'valeur']));

    expect($response)
        ->isToolResult()
        ->toolHasNoError()
        ->toolJsonContentToMatchArray(['resultat' => 'valeur_attendue']);
});

test('it returns error when param is invalid', function (): void {
    $tool = new MonOutil;
    $response = $tool->handle(new Request(['param_requis' => 'invalide']));

    expect($response)
        ->isToolResult()
        ->toolHasError();
});

'mcp' => [
    'tools' => [
        'exclude' => [MonOutil::class],  // Exclure
        '

declare(strict_types=1);

namespace Laravel\Boost\Install\Agents;

use Laravel\Boost\Contracts\SupportsGuidelines;
use Laravel\Boost\Contracts\SupportsMcp;
use Laravel\Boost\Contracts\SupportsSkills;
use Laravel\Boost\Install\Enums\McpInstallationStrategy;
use Laravel\Boost\Install\Enums\Platform;

class MonAgent extends Agent implements SupportsGuidelines, SupportsMcp, SupportsSkills
{
    public function name(): string
    {
        return 'mon_agent';  // Identifiant snake_case unique
    }

    public function displayName(): string
    {
        return 'Mon Agent';  // Nom affiche a l'utilisateur
    }

    public function systemDetectionConfig(Platform $platform): array
    {
        return match ($platform) {
            Platform::Darwin, Platform::Linux => [
                'command' => 'command -v monagent',
            ],
            Platform::Windows => [
                'command' => 'where monagent 2>nul',
            ],
        };
    }

    public function projectDetectionConfig(): array
    {
        return [
            'paths' => ['.monagent'],
            'files' => ['MONAGENT.md'],
        ];
    }

    public function mcpInstallationStrategy(): McpInstallationStrategy
    {
        return McpInstallationStrategy::FILE;
        // Alternatives : McpInstallationStrategy::SHELL, McpInstallationStrategy::NONE
    }

    public function mcpConfigPath(): string
    {
        return '.monagent/mcp.json';
    }

    public function guidelinesPath(): string
    {
        return config('boost.agents.mon_agent.guidelines_path', 'MONAGENT.md');
    }

    public function skillsPath(): string
    {
        return config('boost.agents.mon_agent.skills_path', '.monagent/skills');
    }
}

private array $agents = [
    // ... agents existants ...
    'mon_agent' => MonAgent::class,  // <-- Ajouter ici
];

declare(strict_types=1);

use Laravel\Boost\Install\Agents\MonAgent;
use Laravel\Boost\Install\Detection\DetectionStrategyFactory;

test('MonAgent returns correct name', function (): void {
    $factory = Mockery::mock(DetectionStrategyFactory::class);
    $agent = new MonAgent($factory);

    expect($agent->name())->toBe('mon_agent')
        ->and($agent->displayName())->toBe('Mon Agent');
});

test('MonAgent returns relative php path by default', function (): void {
    config(['boost.executable_paths.php' => null]);
    $factory = Mockery::mock(DetectionStrategyFactory::class);
    $agent = new MonAgent($factory);

    expect($agent->getPhpPath())->toBe('php');
});

declare(strict_types=1);

namespace Laravel\Boost\Mcp\Prompts\MonPrompt;

use Laravel\Boost\Concerns\RendersBladeGuidelines;
use Laravel\Mcp\Response;
use Laravel\Mcp\Server\Prompt;

class MonPrompt extends Prompt
{
    use RendersBladeGuidelines;

    protected string $name = 'mon-prompt';

    protected string $title = 'mon_prompt';

    protected string $description = 'Description de ce que fait ce prompt et quand l\'utiliser.';

    public function handle(): Response
    {
        $content = $this->renderBladeFile(__DIR__.'/mon-prompt.blade.php');

        return Response::text($content);
    }
}

protected function discoverPrompts(): array
{
    $availablePrompts = [
        LaravelCodeSimplifier::class,
        UpgradeLivewireV4::class,
        MonPrompt::class,  // <-- Ajouter ici
        ...$this->discoverThirdPartyPrimitives(Prompt::class),
    ];

    return $this->filterPrimitives($availablePrompts, 'prompts');
}

declare(strict_types=1);

use Laravel\Boost\Mcp\Prompts\MonPrompt\MonPrompt;

beforeEach(function (): void {
    $this->prompt = new MonPrompt;
});

test('it has correct name', function (): void {
    expect($this->prompt->name())->toBe('mon-prompt');
});

test('it has a description', function (): void {
    expect($this->prompt->description())->not->toBeEmpty();
});

test('it returns valid response', function (): void {
    $response = $this->prompt->handle();

    expect($response)
        ->isToolResult()
        ->toolHasNoError()
        ->toolTextContains('Instructions pour Mon Prompt');
});

declare(strict_types=1);

namespace Laravel\Boost\Mcp\Resources;

use Laravel\Mcp\Response;
use Laravel\Mcp\Server\Resource;

class MonResource extends Resource
{
    protected string $description = 'Description de la ressource et de son contenu.';

    protected string $uri = 'file://instructions/mon-resource.md';

    protected string $mimeType = 'text/markdown';

    public function handle(): Response
    {
        // Option A : Contenu direct
        return Response::json(['data' => 'valeur']);

        // Option B : Via ToolExecutor (deleguer a un outil existant)
        // $response = $this->toolExecutor->execute(MonOutil::class);
        // return $response;

        // Option C : Via template Blade (utiliser le trait RendersBladeGuidelines)
        // $content = $this->renderBladeFile(__DIR__.'/mon-resource.blade.php');
        // return Response::text($content);
    }
}

protected function discoverResources(): array
{
    $availableResources = [
        Resources\ApplicationInfo::class,
        Resources\MonResource::class,  // <-- Ajouter ici
        ...$this->discoverThirdPartyPrimitives(Resource::class),
    ];

    return $this->filterPrimitives($availableResources, 'resources');
}

declare(strict_types=1);

namespace Laravel\Boost\Console;

use Illuminate\Console\Command;
use Symfony\Component\Console\Attribute\AsCommand;

#[AsCommand('boost:ma-commande', 'Description courte de la commande')]
class MaCommand extends Command
{
    public function handle(): int
    {
        // Logique de la commande...

        $this->info('Commande executee avec succes.');

        return self::SUCCESS;
        // OU self::FAILURE en cas d'erreur
    }
}

#[AsCommand('boost:ma-commande', 'Description')]
class MaCommand extends Command
{
    protected $signature = 'boost:ma-commande
        {--option-a : Description de l\'option A}
        {argument : Description de l\'argument}';

    public function handle(MonService $service): int
    {
        $optionA = $this->option('option-a');
        $arg = $this->argument('argument');

        // ...

        return self::SUCCESS;
    }
}

protected function registerCommands(): void
{
    if ($this->app->runningInConsole()) {
        $this->commands([
            Console\StartCommand::class,
            Console\InstallCommand::class,
            Console\UpdateCommand::class,
            Console\ExecuteToolCommand::class,
            Console\AddSkillCommand::class,
            Console\MaCommand::class,  // <-- Ajouter ici
        ]);
    }
}

declare(strict_types=1);

test('boost:ma-commande executes successfully', function (): void {
    $this->artisan('boost:ma-commande')
        ->assertSuccessful();
});

test('boost:ma-commande with options', function (): void {
    $this->artisan('boost:ma-commande', ['--option-a' => true])
        ->assertSuccessful()
        ->expectsOutput('Resultat attendu');
});

declare(strict_types=1);

namespace Laravel\Boost\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class MonMiddleware
{
    public function handle(Request $request, Closure $next): Response
    {
        /** @var Response $response */
        $response = $next($request);

        // Modifier la reponse apres traitement...

        return $response;
    }
}

// Dans une methode dediee ou directement dans boot()
$this->app->booted(function () use ($router): void {
    $router->pushMiddlewareToGroup('web', MonMiddleware::class);
});

declare(strict_types=1);

namespace Laravel\Boost\Services;

class MonService
{
    public function maMethode(): string
    {
        // Logique...
    }
}

$this->app->singleton(MonService::class, fn (): MonService => new MonService);

.ai/
  mon-package/
    core.blade.php              # Guidelines de base (toutes versions)
    1/
      core.blade.php            # Guidelines specifiques a la v1
    2/
      core.blade.php            # Guidelines specifiques a la v2
      skill/
        mon-skill/
          SKILL.blade.php       # Skill associe a la v2
          SKILL.md              # Documentation du skill

blade
@php
/** @var \Laravel\Boost\Install\GuidelineAssist $assist */
@endphp
# Mon Package

- Description du package et son role dans l'application.
- Conventions importantes a suivre.

@if($assist->hasPackage(\Laravel\Roster\Enums\Packages::SOME_PACKAGE))
## Integration avec Some Package

- Instructions specifiques quand les deux packages sont utilises ensemble.
@endif

bash
php artisan boost:install --guidelines

src/Mcp/Prompts/
  MonPrompt/
    MonPrompt.php                # Classe du prompt
    mon-prompt.blade.php         # Contenu du prompt (template Blade)

bash
php artisan boost:install --skills

bash
php >= 8.2
composer

bash
# 1. Corriger le style de code + analyse statique + refactoring
composer lint

# 2. Lancer tous les tests (Unit, Feature, Arch)
composer test

# 3. OU tout en une commande
composer check

composer.json          # Identite, dependances, autoload, scripts
config/boost.php       # Configuration publiable
src/                   # Code source PHP
.ai/                   # Templates de guidelines Blade
LICENSE.md             # Licence

bash
mv config/boost.php config/ai-tools.php

diff
- $this->mergeConfigFrom(__DIR__.'/../config/boost.php', 'boost');
+ $this->mergeConfigFrom(__DIR__.'/../config/ai-tools.php', 'ai-tools');

- ], 'boost-config');
+ ], 'ai-tools-config');

bash
# Trouver toutes les occurrences
grep -rn "config('boost\." src/ .ai/ --

diff
# src/BoostServiceProvider.php (ou nouveau nom)
- Mcp::local('laravel-boost', Boost::class);
+ Mcp::local('acme-ai-tools', AiToolsServer::class);

# src/Console/StartCommand.php
- Artisan::call('mcp:start laravel-boost');
+ Artisan::call('mcp:start acme-ai-tools');

# src/Mcp/Boost.php (ou nouveau nom)
- protected string $name = 'Laravel Boost';
+ protected string $name = 'Acme AI Tools';

diff
# src/BoostServiceProvider.php
- Route::post('/_boost/browser-logs', ...)->name('boost.browser-logs');
+ Route::post('/_ai-tools/browser-logs', ...)->name('ai-tools.browser-logs');

# src/Services/BrowserLogger.php
- route('boost.browser-logs')
+ route('ai-tools.browser-logs')
- '/_boost/browser-logs'
+ '/_ai-tools/browser-logs'

diff
# src/BoostServiceProvider.php
- $bladeCompiler->directive('boostJs', ...);
+ $bladeCompiler->directive('aiToolsJs', ...);

bash
# 1. Verifier qu'aucune reference a l'ancien nom ne subsiste
grep -rn "laravel/boost" . ---load

# 3. Lancer les tests
composer check