agile-context-engineering 0.2.2 → 0.5.0

package/commands/ace/research-technical-solution.md

@@ -1,147 +0,0 @@
----
-name: ace:research-technical-solution
-description: COMPREHENSIVE Technical Solution Design for a Story — Architecture, Patterns, Algorithms, Sequence Diagrams, and Implementation Plan
-argument-hint: "story=<file-path|github-url>"
-allowed-tools:
-  - Read
-  - Bash
-  - Write
-  - Edit
-  - AskUserQuestion
-  - Glob
-  - Grep
-  - Agent
----
-
-```xml
-<command>
-
-    <execution-time>
-        <runs-after>
-            <trigger>After /ace:plan-story — once story requirements (pass 1-2) are complete</trigger>
-            <trigger>After /ace:research-integration-solution — integration analysis (pass 4) MUST exist</trigger>
-            <trigger>Optionally after /ace:research-external-solution — external analysis (pass 3) if applicable</trigger>
-        </runs-after>
-        <use-when>
-            <condition>Story requirements, wiki references, and integration analysis are available (passes 1-4 complete)</condition>
-            <condition>Need to design a concrete technical solution for the story</condition>
-            <condition>Want a detailed implementation blueprint with class diagrams, sequence diagrams, algorithms, and file structure</condition>
-            <condition>Need a comprehensive technical design to guide AI agents implementing the story</condition>
-        </use-when>
-    </execution-time>
-
-    <input>
-        <flags>
-        </flags>
-
-        <parameters>
-            <required>
-                <param name="story" type="file | github-url">
-                    Story source — can be either:
-                    - **File path**: Path to a markdown file containing the story (from plan-story command)
-                    - **GitHub URL or issue number**: GitHub story reference
-                    Must be a valid, accessible file or GitHub issue.
-                    Contains the user story, acceptance criteria, and Relevant Wiki references
-                    that define what to design a technical solution for.
-
-                    **All context is extracted from the story document:**
-                    - Feature file (from story description/metadata)
-                    - Story requirements (User Story, Description, AC)
-                    - Wiki references (from Relevant Wiki section — pass 2)
-                    - External analysis (auto-detected in story directory — OPTIONAL)
-                    - Integration analysis (auto-detected in story directory — MANDATORY)
-
-                    If not valid, stop and prompt the user.
-                </param>
-            </required>
-
-            <optional>
-                <!-- No optional parameters.
-                     All context is extracted from the story document and story directory:
-                     - Feature file (from story description/metadata)
-                     - Story requirements (User Story, Description, AC)
-                     - Wiki references (from Relevant Wiki section — pass 2)
-                     - External analysis (auto-detected in story directory)
-                     - Integration analysis (auto-detected in story directory)
-                -->
-            </optional>
-        </parameters>
-    </input>
-
-    <execution-context>
-        <research-technical-workflow>@~/.claude/agile-context-engineering/workflows/research-technical-solution.xml</research-technical-workflow>
-        <technical-solution-template>@~/.claude/agile-context-engineering/templates/product/story-technical-solution.xml</technical-solution-template>
-        <ui-formatting>@~/.claude/agile-context-engineering/utils/ui-formatting.md</ui-formatting>
-    </execution-context>
-
-    <output>
-        <objective>
-            Use business requirements, integration analysis, and optionally external/industry-standard
-            analysis to create a CONCRETE TECHNICAL SOLUTION DESIGN for the story, following Clean
-            Architecture principles, SOLID patterns, OOP best practices, considering external analysis
-            for approach, algorithms and formulas (when most efficient and performant), while following
-            the integration analysis so that we don't break our already complex codebase.
-
-            **CRITICAL**: The technical solution MUST include detailed sequence diagrams for EVERY
-            scenario in the Acceptance Criteria, showing the complete flow of data and control
-            through all architectural layers.
-
-            The analysis covers:
-            - Complete component and boundary architecture
-            - Design patterns and technical decisions
-            - Full class diagrams and interfaces (one per file!)
-            - Data models and structures
-            - Algorithms and business logic
-            - Event flow and entry points
-            - MANDATORY sequence diagrams for ALL AC scenarios
-            - Complete file structure tree
-            - DI container configuration
-            - Testing strategy (unit, integration, e2e)
-            - Implementation order and dependencies
-
-            **Output**: The entire technical solution is written INTO the story document
-            (appended as the Technical Solution section) AND updated in the GitHub issue.
-            No separate output file is created.
-        </objective>
-
-        <artifacts>
-            Written directly into the story file and GitHub issue — pass 5 of the story specification pipeline.
-            See story.xml: &lt;section name="technical-solution" pass="5" template="story-technical-solution.xml"&gt;
-        </artifacts>
-    </output>
-
-    <process>
-        For this command use the `ace-technical-application-architect` agent
-        that's specialized in application architecture and is intimate with the codebase.
-
-        Execute the research-technical-solution workflow from
-        `@~/.claude/agile-context-engineering/workflows/research-technical-solution.xml` end-to-end.
-        Preserve all workflow gates (validation, approvals, commits).
-    </process>
-
-    <example-usage>
-        ```
-        # Example with file path story
-        /ace:research-technical-solution \
-          story=.ace/artifacts/product/e1-auth/f3-oauth/s1-buttons/s1-buttons.md
-
-        # Example with GitHub story
-        /ace:research-technical-solution \
-          story=https://github.com/owner/repo/issues/83
-
-        # Example with just issue number (uses current repo)
-        /ace:research-technical-solution \
-          story=83
-        ```
-    </example-usage>
-
-    <next-steps>
-        **After this command:**
-        - The story is now fully refined (pass 5 complete) — ready for implementation
-        - `/ace:execute-story story=...` — Execute the story implementation
-        - `/ace:refine-story story=...` — Re-refine if scope changes
-        - `/ace:help` — Check project initialization status
-    </next-steps>
-
-</command>
-```

package/commands/ace/review-story.md

@@ -1,109 +0,0 @@
----
-name: ace:review-story
-description: Standalone code review — performs 3-level artifact verification, anti-pattern detection, coding standards enforcement, and tech debt discovery against a story's implementation
-argument-hint: "story=<file-path|github-url>"
-allowed-tools:
-  - Read
-  - Bash
-  - Glob
-  - Grep
----
-
-```xml
-<command>
-
-    <execution-time>
-        <runs-after>
-            <trigger>After /ace:execute-story — to re-run code review after manual changes</trigger>
-            <trigger>Anytime — to review a story implementation standalone</trigger>
-        </runs-after>
-        <use-when>
-            <condition>A story has been implemented and needs code review</condition>
-            <condition>Re-checking after manual changes post-execution</condition>
-            <condition>Verifying stories implemented outside ACE</condition>
-            <condition>Pre-merge quality gate</condition>
-        </use-when>
-    </execution-time>
-
-    <input>
-        <flags>
-        </flags>
-
-        <parameters>
-            <required>
-                <param name="story" type="file | github-url">
-                    Story source — can be either:
-                    - **File path**: Path to a fully-planned story markdown file
-                      (must have AC + Technical Solution sections)
-                    - **GitHub URL or issue number**: GitHub story reference
-                    Must be a valid, accessible file or GitHub issue.
-                    The story MUST have Acceptance Criteria and Technical Solution.
-                </param>
-            </required>
-        </parameters>
-    </input>
-
-    <execution-context>
-        <review-story-workflow>@~/.claude/agile-context-engineering/workflows/review-story.xml</review-story-workflow>
-        <story-template>@~/.claude/agile-context-engineering/templates/product/story.xml</story-template>
-        <ui-formatting>@~/.claude/agile-context-engineering/utils/ui-formatting.md</ui-formatting>
-    </execution-context>
-
-    <output>
-        <objective>
-            Review a story's implementation directly (the session IS the reviewer):
-            1. Load story context (AC, Technical Solution, Out of Scope)
-            2. Identify changed/created files related to the story
-            3. Run 3-level artifact verification (EXISTS → SUBSTANTIVE → WIRED)
-            4. Detect anti-patterns (dead code, stubs, TODOs, hardcoded values)
-            5. Enforce coding standards (mandatory, blocker-level)
-            6. Check AC coverage (all Gherkin scenarios implemented)
-            7. Discover pre-existing tech debt in touched files
-            8. Report results with structured format
-        </objective>
-
-        <artifacts>
-            No files modified — this command is read-only.
-            Outputs a structured review report to the conversation.
-        </artifacts>
-    </output>
-
-    <process>
-        For this command use the `ace-code-reviewer` agent
-        that's specialized in code review.
-
-        Execute the review-story workflow from
-        `@~/.claude/agile-context-engineering/workflows/review-story.xml` end-to-end.
-
-        **CRITICAL REQUIREMENTS:**
-        - Story MUST have Acceptance Criteria — STOP if missing
-        - Story MUST have Technical Solution — STOP if missing
-        - This is a READ-ONLY command — do NOT modify any code
-        - Coding standards violations are BLOCKERS, not warnings
-        - Dead code and backwards-compatible shims must be flagged for DELETION
-    </process>
-
-    <example-usage>
-        ```
-        # Review a story from a file path
-        /ace:review-story \
-          story=.ace/artifacts/product/e1-auth/f3-oauth/s1-buttons/s1-buttons.md
-
-        # Review from a GitHub issue
-        /ace:review-story \
-          story=https://github.com/owner/repo/issues/95
-
-        # With just an issue number
-        /ace:review-story story=#95
-        ```
-    </example-usage>
-
-    <next-steps>
-        **After this command:**
-        - `/ace:execute-story story=...` — Re-execute to fix reported issues
-        - `/ace:review-story story=...` — Re-run review after fixes
-        - `/ace:help` — Check project status
-    </next-steps>
-
-</command>
-```

package/commands/ace/update.md

@@ -1,54 +0,0 @@
----
-name: ace:update
-description: Update ACE to latest version
-argument-hint: ""
-allowed-tools:
-  - Bash
-  - AskUserQuestion
----
-
-```xml
-<command>
-
-    <execution-time>
-        <runs-after>
-            <trigger>When statusline shows the update indicator</trigger>
-            <trigger>When user wants to check for or install ACE updates</trigger>
-        </runs-after>
-    </execution-time>
-
-    <input>
-        <parameters>
-            <required></required>
-            <optional></optional>
-        </parameters>
-    </input>
-
-    <execution-context>
-        <update-workflow>@~/.claude/agile-context-engineering/workflows/update.xml</update-workflow>
-        <ui-formatting>@~/.claude/agile-context-engineering/utils/ui-formatting.md</ui-formatting>
-    </execution-context>
-
-    <output>
-        <objective>
-            Check for ACE updates, install if available.
-            Automatically detects local vs global installation and Claude vs Crush runtime.
-        </objective>
-    </output>
-
-    <process>
-        Execute the update workflow from
-        `@~/.claude/agile-context-engineering/workflows/update.xml` end-to-end.
-
-        The workflow handles all logic including:
-        1. Installation detection (local/global, Claude/Crush)
-        2. Latest version checking via npm
-        3. Version comparison
-        4. Clean install warning display
-        5. User confirmation
-        6. Update execution
-        7. Cache clearing and restart reminder
-    </process>
-
-</command>
-```