> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Laravels neues Ökosystem zur Code-Analyse – surveyor / ranger / roster

> Vorstellung der drei Pakete (surveyor, ranger, roster), aus denen sich das von Laravel veröffentlichte Ökosystem für statische Analyse zusammensetzt. Erläutert wird das neue Toolset, das Paket- und Tool-Autoren kennen sollten – von der PHP-Code-Analyse bis zur Paketerkennung.

<Info>
  Dieser Artikel basiert auf den READMEs und dem Quellcode der GitHub-Repositories. Alle drei Pakete befinden sich in einer Beta-Phase vor dem offiziellen Release (Stand: April 2026).
</Info>

<Warning>
  surveyor, ranger und roster sind alle **im Beta-Release**. Vor der Version 1.0.0 kann sich die API ändern. Wägen Sie den Einsatz in der Produktion sorgfältig ab.
</Warning>

## Aktueller Release-Stand (April 2026)

| Paket              | Aktuelles Release | Hinweis                                                                                                                                  |
| ------------------ | ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
| `laravel/roster`   | `v0.5.1`          | in der `composer.json` von `laravel/boost` wird `^0.5.0` verlangt; im `BoostServiceProvider` wird `Roster::scan(base_path())` ausgeführt |
| `laravel/ranger`   | `v0.1.12`         | die `composer.json` hängt von `laravel/surveyor:^0.1.0` ab                                                                               |
| `laravel/surveyor` | `v0.1.9`          | Low-Level-Basis, die von `ranger` als Analyse-Fundament genutzt wird                                                                     |

## Überblick

Anfang 2026 hat Laravel drei Pakete rund um Code-Analyse veröffentlicht. Sie lassen sich einzeln nutzen, bilden aber miteinander verbunden ein **Code-Analyse-Ökosystem**.

```mermaid theme={null}
graph TD
    A["laravel/roster<br>Paketerkennung"] --> B["laravel/ranger<br>High-Level-Introspektion"]
    B --> C["laravel/surveyor<br>Low-Level-Engine für statische Analyse"]
    D["Boost<br>KI-Entwicklungs-Assistenz"] --> A
    E["Tool- und Paketentwickler"] --> A
    E --> B
    E --> C
```

| Paket              | Rolle                                        | Installation                            |
| ------------------ | -------------------------------------------- | --------------------------------------- |
| `laravel/surveyor` | Engine zur statischen PHP-Code-Analyse       | `composer require laravel/surveyor`     |
| `laravel/ranger`   | Introspektion der gesamten Laravel-Anwendung | `composer require laravel/ranger`       |
| `laravel/roster`   | Erkennung von Paketen des Ökosystems         | `composer require laravel/roster --dev` |

Sehen wir uns die Pakete der Reihe nach im Detail an.

***

## laravel/surveyor – Engine für statische Analyse

[laravel/surveyor](https://github.com/laravel/surveyor) ist ein Tool zur statischen Analyse, das PHP-Dateien parst und detaillierte Metainformationen zu Klassen, Methoden, Properties, Rückgabetypen usw. in strukturierter Form bereitstellt. Es ist darauf ausgelegt, diese Informationen so zu extrahieren, dass andere Tools und Pakete sie weiterverarbeiten können.

### Installation

```bash theme={null}
composer require laravel/surveyor
```

### Grundlegende Verwendung

#### Eine Datei analysieren

```php theme={null}
use Laravel\Surveyor\Analyzer\Analyzer;

$analyzer = app(Analyzer::class);

// Analyse per Dateipfad
$result = $analyzer->analyze('/path/to/your/File.php');

// Zugriff auf den analysierten Scope
$scope = $result->analyzed();

// Zugriff auf das Ergebnis der Klasse
$classResult = $result->result();
```

#### Eine Klasse direkt analysieren

```php theme={null}
$result = $analyzer->analyzeClass(\App\Models\User::class);
$classResult = $result->result();
```

### Informationen im ClassResult

```php theme={null}
$classResult = $analyzer->analyzeClass(App\Models\User::class)->result();

// Klasseninformationen
$name = $classResult->name();            // 'App\Models\User'
$namespace = $classResult->namespace();  // 'App\Models'
$filePath = $classResult->filePath();

// Vererbungsbeziehungen
$extends = $classResult->extends();
$implements = $classResult->implements();

// Methoden-Informationen
$method = $classResult->getMethod('store');
$returnType = $method->returnType();
$parameters = $method->parameters();
$rules = $method->validationRules(); // auch Validierungsregeln abrufbar

// Property-Informationen
$property = $classResult->getProperty('email');
$type = $property->type;
$visibility = $property->visibility; // 'public', 'protected', 'private'

// Liste öffentlicher Methoden und Properties
$publicMethods = $classResult->publicMethods();
$publicProperties = $classResult->publicProperties();
```

### Typsystem

Surveyor bringt ein reichhaltiges Typsystem mit, mit dem sich PHP-Typen strukturiert handhaben lassen.

```php theme={null}
use Laravel\Surveyor\Types\Type;

// Verschiedene Typen erzeugen
$stringType = Type::string();
$intType = Type::int();
$boolType = Type::bool();
$nullType = Type::null();

// Union-Typ (z. B. string|null)
$unionType = Type::union(Type::string(), Type::null());

// Typprüfung
use Laravel\Surveyor\Types\StringType;

if (Type::is($returnType, StringType::class)) {
    // Verarbeitung für String-Typen
}
```

### Cache-Konfiguration

Analyseergebnisse lassen sich cachen, um die Performance wiederholter Läufe zu verbessern.

```php theme={null}
use Laravel\Surveyor\Analyzer\AnalyzedCache;

// Disk-Cache aktivieren
AnalyzedCache::enableDiskCache(storage_path('surveyor-cache'));

// Cache leeren
AnalyzedCache::clear();
```

Die Konfiguration ist auch über Umgebungsvariablen möglich.

```env theme={null}
SURVEYOR_CACHE_ENABLED=true
SURVEYOR_CACHE_DIR=/path/to/cache
```

### Analyse von Eloquent-Modellen

Surveyor versucht, eine Verbindung zur Datenbank aufzubauen, um Eloquent-Modelle gesondert zu analysieren. Auch Modell-Relationen, Attribute, Accessoren und Casts werden erkannt.

```php theme={null}
$result = $analyzer->analyzeClass(App\Models\User::class)->result();

// Datenbankattribute werden automatisch erkannt
$emailProperty = $result->getProperty('email');

// Relationsmethoden erkennen
$method = $result->getMethod('posts');
if ($method->isModelRelation()) {
    // Diese Methode ist eine Relation
}
```

<Info>
  Da Surveyor bei der Analyse von Eloquent-Modellen versucht, sich mit der Datenbank zu verbinden, handelt es sich nicht um eine rein statische Analyse. Performance und Speicherverbrauch werden aktuell verbessert; Beiträge sind willkommen.
</Info>

***

## laravel/ranger – High-Level-Introspektion

[laravel/ranger](https://github.com/laravel/ranger) ist eine High-Level-Bibliothek, die surveyor kapselt, eine Laravel-Anwendung als Ganzes durchläuft und Informationen zu Routen, Modellen, Enums, Broadcast-Events, Umgebungsvariablen, Inertia-Komponenten u. a. sammelt.

### Installation

```bash theme={null}
composer require laravel/ranger
```

### Grundlegende Verwendung

Sie beschreiben in Callback-Form, was passieren soll, wenn eine Komponente entdeckt wird.

```php theme={null}
use Laravel\Ranger\Ranger;
use Laravel\Ranger\Components;
use Illuminate\Support\Collection;

$ranger = app(Ranger::class);

// Wird für jede gefundene Route aufgerufen
$ranger->onRoute(function (Components\Route $route) {
    echo $route->uri();
});

// Wird für jedes gefundene Modell aufgerufen
$ranger->onModel(function (Components\Model $model) {
    foreach ($model->getAttributes() as $name => $type) {
        // Verarbeitung von Attributnamen und Typ
    }
});

// Wird für jedes gefundene Enum aufgerufen
$ranger->onEnum(function (Components\Enum $enum) {
    //
});

// Wird für jedes gefundene Broadcast-Event aufgerufen
$ranger->onBroadcastEvent(function (Components\BroadcastEvent $event) {
    //
});

// Wird einmal aufgerufen, nachdem alle Routen gesammelt wurden
$ranger->onRoutes(function (Collection $routes) {
    //
});

// Wird einmal aufgerufen, nachdem alle Modelle gesammelt wurden
$ranger->onModels(function (Collection $models) {
    //
});

// Läuft die gesamte Anwendung durch und ruft die Callbacks aus
$ranger->walk();
```

### Von Ranger gesammelte Komponenten

| Collector                | Beschreibung                                                                                       |
| ------------------------ | -------------------------------------------------------------------------------------------------- |
| **Routes**               | alle registrierten Routen (URI, Parameter, HTTP-Methode, Controller, Validierungsregeln, Response) |
| **Models**               | Eloquent-Modelle inkl. Attributen, Typen und Relationen                                            |
| **Enums**                | PHP-Backed-Enums (Enums mit Integer- oder String-Werten) und deren Cases/Werte                     |
| **BroadcastEvents**      | Events, die `ShouldBroadcast` implementieren, samt Payload                                         |
| **BroadcastChannels**    | registrierte Broadcast-Channels                                                                    |
| **EnvironmentVariables** | in der `.env`-Datei definierte Umgebungsvariablen                                                  |
| **Inertia Shared Data**  | global geteilte Inertia.js-Props                                                                   |
| **Inertia Components**   | Inertia.js-Page-Komponenten und die erwarteten Props                                               |

***

## laravel/roster – Tool zur Paketerkennung

[laravel/roster](https://github.com/laravel/roster) ist ein Tool, das erkennt, welche Pakete des Laravel-Ökosystems in einem Projekt installiert sind. Paket- und Tool-Autoren können damit einfach Informationen wie „Nutzt dieses Projekt Inertia?" oder „Welche Livewire-Version?" abrufen.

### Installation

```bash theme={null}
composer require laravel/roster --dev
```

### Grundlegende Verwendung

```php theme={null}
use Laravel\Roster\Roster;
use Laravel\Roster\Packages;

// Ein Verzeichnis scannen und Roster erhalten
$roster = Roster::scan($directory);

// Liste der installierten Pakete
$roster->packages();

// Nur Produktivpakete
$roster->packages()->production();

// Nur Entwicklungspakete
$roster->packages()->dev();

// Prüfen, ob ein bestimmtes Paket vorhanden ist
$roster->uses(Packages::INERTIA);        // bool
$roster->uses(Packages::LIVEWIRE);       // bool

// Mit Versionsbedingung prüfen
$roster->usesVersion(Packages::INERTIA, '2.0.0', '>=');   // Ist Inertia >= 2.0.0?
$roster->usesVersion(Packages::LIVEWIRE, '3.0.0', '>=');  // Ist Livewire >= 3.0.0?

// JavaScript-Paketmanager erkennen
$packageManager = $roster->nodePackageManager(); // 'npm', 'yarn', 'bun' o. Ä.
```

***

## Reale Anwendungsfälle

### Tool zur Generierung von KI-Guidelines (Boost)

[Laravel Boost](https://github.com/laravel/boost) nutzt roster, um die installierte Paketkonstellation zu erfassen und die Generierung von Guidelines und Skills für KI-Agenten (GitHub Copilot, Claude usw.) automatisch anzupassen. Auf Basis von Informationen wie „Nutzt dieses Projekt Inertia?" oder „Ist Livewire installiert?" werden passende Guideline-Dateien ausgewählt und dem KI-Agenten bereitgestellt.

```mermaid theme={null}
sequenceDiagram
    participant Boost as Laravel Boost
    participant Roster as laravel/roster
    participant AI as KI-Agent
    Boost->>Roster: Roster::scan(base_path())
    Roster->>Boost: packages() [Inertia, Livewire, Pint...]
    Boost->>Boost: Guidelines pro Paket auswählen
    Boost->>AI: Inertia-Guidelines, Livewire-Guidelines ...
```

### Einen Kompatibilitätsprüfer für Pakete bauen

Wenn Sie ein Paket entwickeln, dessen Verhalten von den im Nutzerprojekt installierten Paketen abhängt, ist roster äußerst hilfreich.

```php theme={null}
use Laravel\Roster\Roster;
use Laravel\Roster\Packages;

$roster = Roster::scan(base_path());

if ($roster->uses(Packages::INERTIA)) {
    // Verarbeitung für Inertia
    if ($roster->usesVersion(Packages::INERTIA, '2.0.0', '>=')) {
        // Verarbeitung für Inertia v2 oder höher
    }
}

if ($roster->uses(Packages::LIVEWIRE)) {
    // Verarbeitung für Livewire
}

// Installationsbefehl je nach JavaScript-Paketmanager anpassen
$pm = $roster->nodePackageManager();
echo "Run: {$pm} install your-package";
```

### Automatische Generierung von Anwendungsdokumentation

Mit ranger lässt sich ein Tool bauen, das Routen, Modelle und Enums einer Laravel-Anwendung automatisch einsammelt und daraus Dokumentation erzeugt.

```php theme={null}
use Laravel\Ranger\Ranger;
use Laravel\Ranger\Components;

$ranger = app(Ranger::class);
$docs = [];

$ranger->onRoute(function (Components\Route $route) use (&$docs) {
    $docs['routes'][] = [
        'uri' => $route->uri(),
        // auch Validierungsregeln und Response-Typen der Route abrufbar
    ];
});

$ranger->onModel(function (Components\Model $model) use (&$docs) {
    $docs['models'][] = [
        'attributes' => $model->getAttributes(),
    ];
});

$ranger->walk();

// In $docs sind nun die Strukturinformationen der gesamten Anwendung gesammelt
```

***

## Fazit

surveyor, ranger und roster bilden im Laravel-Ökosystem eine neue Grundlage für **programmatische Code-Analyse**.

```mermaid theme={null}
graph LR
    A["surveyor<br>PHP-Dateien parsen<br>Klassen, Methoden, Typen extrahieren"] --> B["ranger<br>Laravel-App als Ganzes durchlaufen<br>Routen, Modelle, Enums sammeln"]
    B --> C["roster<br>Installierte Pakete erkennen<br>Version und Art prüfen"]
```

Diese Pakete richten sich primär an Paket- und Tool-Autoren; Endnutzer verwenden sie nicht direkt. Sie werden jedoch aktiv innerhalb offizieller Laravel-Tools wie Laravel Boost genutzt, sodass ein weiterer Ausbau des Ökosystems zu erwarten ist.

<Columns cols={3}>
  <Card title="laravel/surveyor" icon="github" href="https://github.com/laravel/surveyor">
    Engine für statische PHP-Code-Analyse
  </Card>

  <Card title="laravel/ranger" icon="github" href="https://github.com/laravel/ranger">
    High-Level-Introspektions-Bibliothek
  </Card>

  <Card title="laravel/roster" icon="github" href="https://github.com/laravel/roster">
    Tool zur Paketerkennung
  </Card>
</Columns>


## Related topics

- [laravel/agent-skills – Offizielle KI-Agent-Skills-Sammlung von Laravel](/de/blog/agent-skills-introduction.md)
- [Erste Analyse: Laravel Passkeys (passkeys-server + @laravel/passkeys)](/de/blog/passkeys-introduction.md)
- [Übersicht der neuen Features in Laravel 13](/de/blog/laravel-13-new-features.md)
- [Laravel und KI-Entwicklung](/de/ai.md)
- [Versionskompatibilität von Paketen verwalten](/de/advanced/package-versioning.md)