Benutzereingabe
$ARGUMENTS
Sie MÜSSEN die Benutzereingabe berücksichtigen, bevor Sie fortfahren (falls nicht leer).
Prüfungen vor der Ausführung
Nach Erweiterungs-Hooks suchen (vor der Implementierung):
- Prüfen, ob
.specify/extensions.ymlim Projektstammverzeichnis vorhanden ist. - Wenn es vorhanden ist, lesen und nach Einträgen unter dem Schlüssel
hooks.before_implementsuchen - Wenn das YAML nicht geparst werden kann oder ungültig ist, nicht stillschweigend überspringen: Dem Benutzer mitteilen, dass
.specify/extensions.ymlnicht gelesen werden konnte (den Parser-Fehler einschließen) und dass keine Hooks überprüft wurden, einschließlich aller dort registrierten obligatorischen Hooks (optional: false), dann normal fortfahren - Hooks herausfiltern, bei denen
enabledexplizit auffalsegesetzt ist. Hooks ohne einenabled-Feld als standardmäßig aktiviert behandeln. - Für jeden verbleibenden Hook nicht versuchen,
condition-Ausdrücke des Hooks zu interpretieren oder auszuwerten:- Wenn der Hook kein
condition-Feld hat oder es null/leer ist, den Hook als ausführbar behandeln - Wenn der Hook eine nicht-leere
conditiondefiniert, den Hook überspringen und die Auswertung der Bedingung der HookExecutor-Implementierung überlassen
- Wenn der Hook kein
- Beim Erstellen von Befehlsaufrufen aus Hook-Befehlsnamen Punkte (
.) durch Bindestriche (-) ersetzen. Beispiel:speckit.git.commit→/speckit-git-commit. - Für jeden ausführbaren Hook basierend auf seinem
optional-Flag Folgendes ausgeben:- Optionaler Hook (
optional: true):## Erweiterungs-Hooks **Optionaler Pre-Hook**: {extension} Befehl: `/{command}` Beschreibung: {description} Prompt: {prompt} Zur Ausführung: `/{command}` - Obligatorischer Hook (
optional: false):
Nach dem Ausgeben des obigen Blocks MÜSSEN Sie den Hook tatsächlich aufrufen und warten, bis er beendet ist, bevor Sie fortfahren. Führen Sie ihn genauso aus, wie Sie den Befehl selbst in diesem Agenten/Session ausführen würden (der Aufruf kann von der oben gezeigten wörtlichen## Erweiterungs-Hooks **Automatischer Pre-Hook**: {extension} Ausführung: `/{command}` EXECUTE_COMMAND: {command} Warten Sie auf das Ergebnis des Hook-Befehls, bevor Sie mit der Gliederung fortfahren.{command}-ID abweichen, z. B. führt ein Skills-Modus-Agent ihn als/skill:speckit-...oder$speckit-...aus). Das bloße Ausgeben des Blocks führt den Hook nicht aus.
- Optionaler Hook (
- Wenn keine Hooks registriert sind oder
.specify/extensions.ymlnicht existiert, stillschweigend überspringen
Gliederung
-
Führen Sie
.specify/scripts/bash/check-prerequisites.sh --json --require-tasks --include-tasksaus dem Repository-Stammverzeichnis aus und parsen Sie die Liste FEATURE_DIR und AVAILABLE_DOCS. Alle Pfade müssen absolut sein. Bei einfachen Anführungszeichen in Argumenten wie "I'm Groot" die Escape-Syntax verwenden: z. B. 'I'''m Groot' (oder doppelte Anführungszeichen wenn möglich: "I'm Groot"). -
Checklisten-Status prüfen (falls FEATURE_DIR/checklists/ existiert):
-
Checklisten-Markierungen als schreibgeschützte Sperre behandeln: Kontrollkästchen-Status scannen, Status melden und bei Bedarf vor dem Fortfahren fragen; Checklisten-Dateien oder -Markierungen NICHT ändern
-
checklists/requirements.mdist die integrierte Spezifikationsqualitäts-Checkliste, die von/speckit-specifyund/speckit-clarifyverwaltet wird; benutzerdefinierte Checklisten, die von/speckit-checklistgeneriert werden, sind vom Reviewer verwaltete Qualitätsanforderungs-Review-Artefakte -
Bei benutzerdefinierten Checklisten bedeutet
[x], dass der Reviewer das Anforderungsqualitätskriterium als erfüllt beurteilt hat; es bedeutet NICHT, dass die Implementierungsarbeit abgeschlossen ist -
Alle Checklisten-Dateien im Verzeichnis
checklists/scannen -
Für jede Checkliste zählen:
- Gesamte Elemente: Alle Zeilen, die auf
- [ ]oder- [X]oder- [x]passen - Überprüfte Elemente: Zeilen, die auf
- [X]oder- [x]passen - Nicht überprüfte Elemente: Zeilen, die auf
- [ ]passen
- Gesamte Elemente: Alle Zeilen, die auf
-
Eine Statustabelle erstellen:
| Checkliste | Gesamt | Überprüft | Nicht überprüft | Status | |------------|--------|-----------|-----------------|--------| | ux.md | 12 | 12 | 0 | ✓ BESTANDEN | | test.md | 8 | 5 | 3 | ✗ NICHT BESTANDEN | | security.md | 6 | 6 | 0 | ✓ BESTANDEN | -
Gesamtstatus berechnen:
- BESTANDEN: Alle Checklisten haben 0 nicht überprüfte Elemente
- NICHT BESTANDEN: Eine oder mehrere Checklisten haben nicht überprüfte Elemente
-
Wenn eine Checkliste nicht überprüfte Elemente hat:
- Die Tabelle mit den Anzahlen nicht überprüfter Elemente anzeigen
- STOPPEN und fragen: "Einige Checklisten haben nicht überprüfte Elemente. Möchten Sie trotzdem mit der Implementierung fortfahren? (ja/nein)"
- Auf Benutzerantwort warten, bevor fortgefahren wird
- Wenn der Benutzer "nein" oder "warte" oder "stopp" sagt, Ausführung anhalten
- Wenn der Benutzer "ja" oder "fortfahren" oder "weiter" sagt, mit Schritt 3 fortfahren
-
Wenn alle Checklisten überprüft sind:
- Die Tabelle anzeigen, die zeigt, dass alle Checklisten bestanden sind
- Automatisch mit Schritt 3 fortfahren
-
-
Implementierungskontext laden und analysieren:
- ERFORDERLICH: tasks.md für die vollständige Aufgabenliste und den Ausführungsplan lesen
- ERFORDERLICH: plan.md für Tech-Stack, Architektur und Dateistruktur lesen
- FALLS VORHANDEN: data-model.md für Entitäten und Beziehungen lesen
- FALLS VORHANDEN: contracts/ für API-Spezifikationen und Testanforderungen lesen
- FALLS VORHANDEN: research.md für technische Entscheidungen und Einschränkungen lesen
- FALLS VORHANDEN: .specify/memory/constitution.md für Governance-Einschränkungen lesen
- FALLS VORHANDEN: quickstart.md für Integrationsszenarien lesen
-
Projekt-Setup-Überprüfung:
- ERFORDERLICH: Ignorier-Dateien basierend auf dem tatsächlichen Projekt-Setup erstellen/überprüfen:
Erkennungs- und Erstellungslogik:
-
Prüfen, ob der folgende Befehl erfolgreich ist, um festzustellen, ob das Repository ein Git-Repo ist (gegebenenfalls .gitignore erstellen/überprüfen):
git rev-parse --git-dir 2>/dev/null -
Prüfen, ob Dockerfile* existiert oder Docker in plan.md erwähnt wird → .dockerignore erstellen/überprüfen
-
Prüfen, ob .eslintrc* existiert → .eslintignore erstellen/überprüfen
-
Prüfen, ob eslint.config.* existiert → sicherstellen, dass die
ignores-Einträge der Konfiguration die erforderlichen Muster abdecken -
Prüfen, ob .prettierrc* existiert → .prettierignore erstellen/überprüfen
-
Prüfen, ob .npmrc oder package.json existiert → .npmignore erstellen/überprüfen (bei Veröffentlichung)
-
Prüfen, ob Terraform-Dateien (*.tf) existieren → .terraformignore erstellen/überprüfen
-
Prüfen, ob .helmignore benötigt wird (Helm-Charts vorhanden) → .helmignore erstellen/überprüfen
Wenn die Ignorier-Datei bereits existiert: Überprüfen, ob sie wesentliche Muster enthält, fehlende kritische Muster nur anhängen Wenn die Ignorier-Datei fehlt: Mit vollständigem Mustersatz für die erkannte Technologie erstellen
Allgemeine Muster nach Technologie (aus plan.md Tech-Stack):
- Node.js/JavaScript/TypeScript:
node_modules/,dist/,build/,*.log,.env* - Python:
__pycache__/,*.pyc,.venv/,venv/,dist/,*.egg-info/ - Java:
target/,*.class,*.jar,.gradle/,build/ - C#/.NET:
bin/,obj/,*.user,*.suo,packages/ - Go:
*.exe,*.test,vendor/,*.out - Ruby:
.bundle/,log/,tmp/,*.gem,vendor/bundle/ - PHP:
vendor/,*.log,*.cache,*.env - Rust:
target/,debug/,release/,*.rs.bk,*.rlib,*.prof*,.idea/,*.log,.env* - Kotlin:
build/,out/,.gradle/,.idea/,*.class,*.jar,*.iml,*.log,.env* - C++:
build/,bin/,obj/,out/,*.o,*.so,*.a,*.exe,*.dll,.idea/,*.log,.env* - C:
build/,bin/,obj/,out/,*.o,*.a,*.so,*.exe,*.dll,autom4te.cache/,config.status,config.log,.idea/,*.log,.env* - Swift:
.build/,DerivedData/,*.swiftpm/,Packages/ - R:
.Rproj.user/,.Rhistory,.RData,.Ruserdata,*.Rproj,packrat/,renv/ - Universal:
.DS_Store,Thumbs.db,*.tmp,*.swp,.vscode/,.idea/
Tool-spezifische Muster:
- Docker:
node_modules/,.git/,Dockerfile*,.dockerignore,*.log*,.env*,coverage/ - ESLint:
node_modules/,dist/,build/,coverage/,*.min.js - Prettier:
node_modules/,dist/,build/,coverage/,package-lock.json,yarn.lock,pnpm-lock.yaml - Terraform:
.terraform/,*.tfstate*,*.tfvars,.terraform.lock.hcl - Kubernetes/k8s:
*.secret.yaml,secrets/,.kube/,kubeconfig*,*.key,*.crt
-
Struktur von tasks.md parsen und extrahieren:
- Aufgabenphasen: Setup, Tests, Kern, Integration, Optimierung
- Aufgabenabhängigkeiten: Sequenzielle vs. parallele Ausführungsregeln
- Aufgabendetails: ID, Beschreibung, Dateipfade, parallele Markierungen [P]
- Ausführungsablauf: Reihenfolge und Abhängigkeitsanforderungen
-
Implementierung gemäß dem Aufgabenplan ausführen:
- Phasenweise Ausführung: Jede Phase abschließen, bevor zur nächsten übergegangen wird
- Abhängigkeiten beachten: Sequenzielle Aufgaben in Reihenfolge ausführen, parallele Aufgaben [P] können zusammen ausgeführt werden
- TDD-Ansatz befolgen: Testaufgaben vor ihren entsprechenden Implementierungsaufgaben ausführen
- Dateibasierte Koordination: Aufgaben, die dieselben Dateien betreffen, müssen sequenziell ausgeführt werden
- Validierungsprüfpunkte: Den Abschluss jeder Phase überprüfen, bevor fortgefahren wird
-
Implementierungsausführungsregeln:
- Zuerst Setup: Projektstruktur, Abhängigkeiten, Konfiguration initialisieren
- Tests vor Code: Wenn Sie Tests für Verträge, Entitäten und Integrationsszenarien schreiben müssen
- Kernentwicklung: Modelle, Dienste, CLI-Befehle, Endpunkte implementieren
- Integrationsarbeit: Datenbankverbindungen, Middleware, Protokollierung, externe Dienste
- Optimierung und Validierung: Unit-Tests, Leistungsoptimierung, Dokumentation
-
Fortschrittsverfolgung und Fehlerbehandlung:
- Fortschritt nach jeder abgeschlossenen Aufgabe melden
- Ausführung anhalten, wenn eine nicht-parallele Aufgabe fehlschlägt
- Bei parallelen Aufgaben [P] mit erfolgreichen Aufgaben fortfahren, fehlgeschlagene melden
- Klare Fehlermeldungen mit Kontext zum Debuggen bereitstellen
- Nächste Schritte vorschlagen, wenn die Implementierung nicht fortgesetzt werden kann
- WICHTIG Für abgeschlossene Aufgaben die Aufgabe in der Aufgabendatei als [X] markieren.
-
Abschlussvalidierung:
- Überprüfen, ob alle erforderlichen Aufgaben abgeschlossen sind
- Prüfen, ob die implementierten Funktionen der ursprünglichen Spezifikation entsprechen
- Validieren, dass Tests bestanden werden und die Abdeckung den Anforderungen entspricht
- Bestätigen, dass die Implementierung dem technischen Plan folgt
Hinweis: Dieser Befehl setzt eine vollständige Aufgabenaufschlüsselung in tasks.md voraus. Wenn Aufgaben unvollständig oder fehlend sind, empfehlen wir, zuerst /speckit-tasks auszuführen, um die Aufgabenliste neu zu generieren.
Obligatorische Post-Execution-Hooks
Sie MÜSSEN diesen Abschnitt abschließen, bevor Sie dem Benutzer den Abschluss melden.
Prüfen, ob .specify/extensions.yml im Projektstammverzeichnis vorhanden ist.
- Wenn es nicht vorhanden ist oder keine Hooks unter
hooks.after_implementregistriert sind, zum Abschlussbericht springen. - Wenn es vorhanden ist, lesen und nach Einträgen unter dem Schlüssel
hooks.after_implementsuchen. - Wenn das YAML nicht geparst werden kann oder ungültig ist, nicht stillschweigend überspringen: Dem Benutzer mitteilen, dass
.specify/extensions.ymlnicht gelesen werden konnte (den Parser-Fehler einschließen) und dass keine Hooks überprüft wurden, einschließlich aller dort registrierten obligatorischen Hooks (optional: false), dann zum Abschlussbericht fortfahren. - Hooks herausfiltern, bei denen
enabledexplizit auffalsegesetzt ist. Hooks ohne einenabled-Feld als standardmäßig aktiviert behandeln. - Für jeden verbleibenden Hook nicht versuchen,
condition-Ausdrücke des Hooks zu interpretieren oder auszuwerten:- Wenn der Hook kein
condition-Feld hat oder es null/leer ist, den Hook als ausführbar behandeln - Wenn der Hook eine nicht-leere
conditiondefiniert, den Hook überspringen und die Auswertung der Bedingung der HookExecutor-Implementierung überlassen
- Wenn der Hook kein
- Beim Erstellen von Befehlsaufrufen aus Hook-Befehlsnamen Punkte (
.) durch Bindestriche (-) ersetzen. Beispiel:speckit.git.commit→/speckit-git-commit. - Für jeden ausführbaren Hook basierend auf seinem
optional-Flag Folgendes ausgeben:- Obligatorischer Hook (
optional: false) — Sie MÜSSENEXECUTE_COMMAND:für jeden obligatorischen Hook ausgeben:
Nach dem Ausgeben des obigen Blocks MÜSSEN Sie den Hook tatsächlich aufrufen und warten, bis er beendet ist, bevor Sie fortfahren. Führen Sie ihn genauso aus, wie Sie den Befehl selbst in diesem Agenten/Session ausführen würden (der Aufruf kann von der oben gezeigten wörtlichen## Erweiterungs-Hooks **Automatischer Hook**: {extension} Ausführung: `/{command}` EXECUTE_COMMAND: {command}{command}-ID abweichen, z. B. führt ein Skills-Modus-Agent ihn als/skill:speckit-...oder$speckit-...aus). Das bloße Ausgeben des Blocks führt den Hook nicht aus. - Optionaler Hook (
optional: true):## Erweiterungs-Hooks **Optionaler Hook**: {extension} Befehl: `/{command}` Beschreibung: {description} Prompt: {prompt} Zur Ausführung: `/{command}`
- Obligatorischer Hook (
Abschlussbericht
Melden Sie den endgültigen Status mit einer Zusammenfassung der abgeschlossenen Arbeiten.
Erledigt, wenn
- Alle Aufgaben in tasks.md abgeschlossen und als
[X]markiert - Implementierung gegen Spezifikation, Plan und Testabdeckung validiert
- Erweiterungs-Hooks gemäß den Regeln in Obligatorische Post-Execution-Hooks ausgeführt oder übersprungen
- Abschluss dem Benutzer mit einer Zusammenfassung der abgeschlossenen Arbeiten gemeldet