Communitygithub.com

tangjuyo/reels-blocker

Führt den Implementierungsplan aus, indem alle in tasks.md definierten Aufgaben verarbeitet und ausgeführt werden.

Was ist reels-blocker?

Dieses Skill, tangjuyo/reels-blocker, automatisiert die vollständige Ausführung eines Implementierungsplans, der in einer `tasks.md`-Datei definiert ist. Es ist darauf ausgelegt, Entwicklungs-Workflows zu rationalisieren, indem es Aufgaben sequenziell oder parallel basierend auf Abhängigkeiten ausführt, Projektkonfigurationen überprüft und Code-Generierungs- sowie Testaufgaben gemäß einer TDD-Strategie orchestriert. Das Skill führt vor und nach der Implementierung eine Reihe von Überprüfungen durch, darunter die Auswertung optionaler oder obligatorischer Erweiterungs-Hooks (z. B. für Git-Commits oder Linting), die über eine `.specify/extensions.yml`-Datei konfiguriert werden. Es validiert Checklisten in einem `checklists/`-Verzeichnis und stoppt die Ausführung, wenn unerledigte Punkte vorhanden sind, sofern der Benutzer nicht explizit fortfährt. Anschließend analysiert es mehrere Planungsdateien (`tasks.md`, `plan.md`, `data-model.md` usw.), um die Aufgaben, Phasen, Abhängigkeiten und die technische Architektur zu verstehen. Die Kernausführung ist phasenbasiert: Setup, Tests, Kernentwicklung, Integration und Optimierung, wobei jede Phase Validierungsprüfungen umfasst. Das Skill erstellt eigenständig Ignore-Dateien (`.gitignore`, `.dockerignore`, `.eslintignore` usw.) basierend auf dem erkannten Tech-Stack und stellt sicher, dass das Projekt ordnungsgemäß konfiguriert ist. Während der Ausführung verfolgt es den Fortschritt, meldet abgeschlossene Aufgaben, markiert sie in der Aufgabenliste und behandelt Fehler, indem es bei fehlgeschlagenen nicht-parallelen Aufgaben anhält. Nach der Ausführung führt das Skill obligatorische Hooks aus (z. B. zum Committen von Änderungen), bevor es Zusammenfassungen der abgeschlossenen Arbeiten meldet. Es eignet sich ideal für KI-Codierungsagenten wie Claude Code, Cursor oder Codex, die einen disziplinierten Ansatz für die Code-Generierung basierend auf strukturierten Aufgabenlisten und Spezifikationen benötigen. Das Skill stellt sicher, dass die Implementierung die geplanten Anforderungen und technischen Richtlinien erfüllt, wodurch der manuelle Koordinationsaufwand reduziert wird.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/tangjuyo/reels-blocker/tree/HEAD/.claude/skills/speckit-implement

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

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.yml im Projektstammverzeichnis vorhanden ist.
  • Wenn es vorhanden ist, lesen und nach Einträgen unter dem Schlüssel hooks.before_implement suchen
  • Wenn das YAML nicht geparst werden kann oder ungültig ist, nicht stillschweigend überspringen: Dem Benutzer mitteilen, dass .specify/extensions.yml nicht 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 enabled explizit auf false gesetzt ist. Hooks ohne ein enabled-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 condition definiert, den Hook überspringen und die Auswertung der Bedingung der HookExecutor-Implementierung überlassen
  • 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):
      ## 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.
      
      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 {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.
  • Wenn keine Hooks registriert sind oder .specify/extensions.yml nicht existiert, stillschweigend überspringen

Gliederung

  1. Führen Sie .specify/scripts/bash/check-prerequisites.sh --json --require-tasks --include-tasks aus 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").

  2. 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.md ist die integrierte Spezifikationsqualitäts-Checkliste, die von /speckit-specify und /speckit-clarify verwaltet wird; benutzerdefinierte Checklisten, die von /speckit-checklist generiert 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
    • 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
  3. 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
  4. 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
  5. 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
  6. 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
  7. 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
  8. 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.
  9. 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_implement registriert sind, zum Abschlussbericht springen.
  • Wenn es vorhanden ist, lesen und nach Einträgen unter dem Schlüssel hooks.after_implement suchen.
  • Wenn das YAML nicht geparst werden kann oder ungültig ist, nicht stillschweigend überspringen: Dem Benutzer mitteilen, dass .specify/extensions.yml nicht 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 enabled explizit auf false gesetzt ist. Hooks ohne ein enabled-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 condition definiert, den Hook überspringen und die Auswertung der Bedingung der HookExecutor-Implementierung überlassen
  • 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ÜSSEN EXECUTE_COMMAND: für jeden obligatorischen Hook ausgeben:
      ## Erweiterungs-Hooks
      
      **Automatischer Hook**: {extension}
      Ausführung: `/{command}`
      EXECUTE_COMMAND: {command}
      
      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 {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}`
      

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

Individual skills in this repo

This repo contains 9 individual skills — each has its own dedicated page.

Verwandte Skills