agile-context-engineering 0.1.0 → 0.2.1

package/commands/ace-plan-project.md

@@ -1,205 +0,0 @@
-# /ace:plan-project - Plan Your Project
-
-Collaboratively plan your project by defining epics, features, and high-level architecture.
-
-## Usage
-
-```
-/ace:plan-project [project-description]
-```
-
-### Arguments
-
-- `project-description` - Optional: A brief description of what you want to build
-
-## Behavior
-
-This command guides you through a structured project planning session that produces:
-- Defined epics (large bodies of work)
-- Features within each epic
-- Initial technical architecture considerations
-- Prioritized backlog ready for sprint planning
-
-## Instructions for Claude
-
-<ace-plan-project>
-
-### Prerequisites Check
-
-1. Verify ACE is initialized by checking for `.ace/config.json`
-2. If not initialized, prompt user to run `/ace:init` first
-3. Read current PROJECT.md and BACKLOG.md if they exist
-
-### Phase 1: Project Understanding
-
-Start by understanding the project. Ask these questions conversationally (not all at once):
-
-1. **What are you building?**
-   - Get a clear understanding of the product/feature
-   - Clarify the target users
-   - Understand the core problem being solved
-
-2. **What does success look like?**
-   - Define measurable outcomes
-   - Identify key milestones
-
-3. **What are the constraints?**
-   - Timeline expectations
-   - Technical constraints (existing stack, integrations)
-   - Team/resource constraints
-
-### Phase 2: Epic Discovery
-
-Based on the project understanding, collaboratively identify epics.
-
-**Guide the user through epic discovery:**
-
-```
-An epic is a large body of work that:
-- Takes multiple sprints to complete
-- Delivers significant user value when done
-- Can be broken into 3-8 features
-
-Let's identify the major epics for your project.
-```
-
-For each epic, capture:
-- **ID**: E1, E2, E3...
-- **Name**: Clear, descriptive name
-- **Description**: What this epic delivers
-- **User Value**: Why this matters to users
-- **Dependencies**: Other epics this depends on
-
-Create epic files in `.ace/backlog/`:
-
-```markdown
-<!-- .ace/backlog/E1-epic-name.md -->
-# E1: Epic Name
-
-## Description
-<What this epic delivers>
-
-## User Value
-<Why this matters to users>
-
-## Dependencies
-<Other epics this depends on, if any>
-
-## Features
-<!-- Added by /ace:plan-epic -->
-| ID | Feature | Status |
-|----|---------|--------|
-| - | - | - |
-
-## Acceptance Criteria
-- [ ] <Criteria 1>
-- [ ] <Criteria 2>
-
-## Status
-- **State:** Draft
-- **Priority:** <High/Medium/Low>
-- **Created:** <timestamp>
-```
-
-### Phase 3: Feature Identification
-
-For each epic, identify high-level features (don't go deep yet):
-
-```
-A feature is a piece of deliverable functionality that:
-- Can be completed in 1-2 sprints
-- Provides standalone value
-- Can be demonstrated to users
-```
-
-Capture features briefly:
-- **ID**: E1-F1, E1-F2...
-- **Name**: Feature name
-- **Epic**: Parent epic
-- **Brief description**: One line
-
-### Phase 4: Priority & Sequencing
-
-Help the user prioritize:
-
-1. **Identify MVP epics** - What's the minimum to launch?
-2. **Sequence epics** - What order makes sense?
-3. **Identify risks** - What's most uncertain?
-
-Create a prioritized view in BACKLOG.md.
-
-### Phase 5: Update Project Files
-
-Update the following files with gathered information:
-
-**PROJECT.md** - Add/update:
-- Vision section
-- Goals section
-- Success criteria
-
-**BACKLOG.md** - Add:
-- All epics in priority order
-- Features identified for each epic
-
-**STATE.md** - Add:
-- Any decisions made during planning
-- Context notes for future sessions
-
-### Phase 6: GitHub Integration (if enabled)
-
-If GitHub is enabled in config:
-
-1. Create epic issues with `ace:epic` label:
-```bash
-gh issue create --title "E1: Epic Name" --body "..." --label "ace:epic"
-```
-
-2. Create a project board or milestone (ask user preference)
-
-### Output Summary
-
-After planning, output:
-
-```
-✓ Project planning complete!
-
-Epics Created:
-  E1: <Epic Name> - <status>
-  E2: <Epic Name> - <status>
-  ...
-
-Features Identified: <count>
-
-Updated Files:
-  - PROJECT.md
-  - BACKLOG.md
-  - STATE.md
-  - .ace/backlog/E1-*.md
-  - .ace/backlog/E2-*.md
-
-Recommended Next Steps:
-  1. Review and refine PROJECT.md
-  2. Run /ace:plan-epic E1 to detail your first epic
-  3. Run /ace:plan-feature to break features into stories
-```
-
-### Planning Principles
-
-Throughout the planning session, apply these principles:
-
-1. **Start broad, narrow later** - Don't over-detail early
-2. **User value focus** - Every epic should deliver user value
-3. **Vertical slices** - Prefer end-to-end features over horizontal layers
-4. **Dependencies minimize** - Reduce coupling between epics
-5. **Risk early** - Tackle uncertain/risky work first
-6. **Keep it agile** - Plans will change, that's okay
-
-### Conversation Style
-
-- Be collaborative, not prescriptive
-- Ask clarifying questions
-- Offer suggestions but let user decide
-- Summarize understanding before moving to next phase
-- Keep the energy high - planning should be exciting!
-
-</ace-plan-project>

package/commands/ace-plan-story.md

@@ -1,97 +0,0 @@
-# /ace:plan-story - Plan a Story
-
-Create a new user story with detailed acceptance criteria and technical breakdown.
-
-## Usage
-
-```
-/ace:plan-story <feature-id> "<story-title>"
-/ace:plan-story E1-F1 "User can log in with email"
-```
-
-### Arguments
-
-- `feature-id` - The parent feature identifier
-- `story-title` - Title for the new story
-
-## Behavior
-
-This command creates a new story with:
-- User story format (As a... I want... So that...)
-- Detailed acceptance criteria
-- Technical implementation notes
-- Task breakdown for execution
-
-## Instructions for Claude
-
-<ace-plan-story>
-
-### Prerequisites
-
-1. Verify ACE is initialized
-2. Verify parent feature exists
-3. Determine next story ID
-
-### Planning Flow
-
-1. **Gather Story Details**
-   - Who is the user?
-   - What do they want to accomplish?
-   - What benefit does this provide?
-
-2. **Define Acceptance Criteria**
-   - Given/When/Then format preferred
-   - Should be testable
-   - Cover happy path and edge cases
-
-3. **Technical Breakdown**
-   - Identify files that need changes
-   - Note any new dependencies
-   - Consider testing approach
-
-4. **Create Story File**
-
-```markdown
-# E1-F1-S1: Story Title
-
-## User Story
-
-As a [type of user],
-I want [goal/desire],
-So that [benefit/value].
-
-## Acceptance Criteria
-
-- [ ] Given [context], when [action], then [outcome]
-- [ ] Given [context], when [action], then [outcome]
-- [ ] Edge case: [description]
-
-## Technical Notes
-
-### Files to Modify
-- `path/to/file.ts` - [what changes]
-
-### New Dependencies
-- None
-
-### Testing Approach
-- Unit tests for [components]
-- Integration test for [flow]
-
-## Tasks
-
-<!-- Added by /ace:refine-story -->
-
-## Metadata
-
-- **Status:** Draft
-- **Points:** [1-8]
-- **Sprint:** None
-- **Created:** <timestamp>
-```
-
-5. **GitHub Integration** (if enabled)
-   - Create issue with story template
-   - Link to parent feature issue
-
-</ace-plan-story>

package/commands/ace-refine-story.md

@@ -1,90 +0,0 @@
-# /ace:refine-story - Refine a Story for Execution
-
-Prepare a story for execution by creating detailed implementation tasks.
-
-## Usage
-
-```
-/ace:refine-story <story-id>
-/ace:refine-story E1-F1-S1
-```
-
-### Arguments
-
-- `story-id` - The story identifier to refine
-
-## Behavior
-
-This command prepares a story for execution by:
-- Researching the codebase to understand implementation
-- Breaking the story into atomic, executable tasks
-- Creating a task checklist for the executor
-- Identifying potential blockers
-
-## Instructions for Claude
-
-<ace-refine-story>
-
-### Prerequisites
-
-1. Verify ACE is initialized
-2. Read the story file
-3. Understand acceptance criteria
-
-### Refinement Process
-
-1. **Codebase Research**
-   - Find relevant existing code
-   - Understand patterns in use
-   - Identify integration points
-
-2. **Task Breakdown**
-   - Create atomic tasks (30 min - 2 hours each)
-   - Tasks should be independently committable
-   - Each task has clear done criteria
-
-3. **For Each Task:**
-   - ID: T1, T2, T3...
-   - Description: What exactly to do
-   - Files: Which files to modify/create
-   - Done Criteria: How to verify completion
-
-4. **Update Story File**
-
-Add tasks section:
-
-```markdown
-## Tasks
-
-### T1: <Task Description>
-- **Files:** `path/to/file.ts`
-- **Done:** <verification criteria>
-- **Status:** Pending
-
-### T2: <Task Description>
-- **Files:** `path/to/file.ts`, `path/to/other.ts`
-- **Done:** <verification criteria>
-- **Status:** Pending
-```
-
-5. **Identify Blockers**
-   - Missing information
-   - External dependencies
-   - Questions for the user
-
-### Output
-
-```
-✓ Story E1-F1-S1 refined!
-
-Tasks:
-  T1: <Task Description>
-  T2: <Task Description>
-  T3: <Task Description>
-
-Blockers: [None | List of blockers]
-
-Ready for: /ace:execute-story E1-F1-S1
-```
-
-</ace-refine-story>

package/commands/ace-verify-story.md

@@ -1,127 +0,0 @@
-# /ace:verify-story - Verify a Completed Story
-
-Verify that a completed story meets all acceptance criteria.
-
-## Usage
-
-```
-/ace:verify-story <story-id>
-/ace:verify-story E1-F1-S1
-```
-
-### Arguments
-
-- `story-id` - The story identifier to verify
-
-## Behavior
-
-This command verifies a story by:
-- Checking all acceptance criteria are met
-- Running the full test suite
-- Reviewing code changes for quality
-- Confirming with the user
-
-## Instructions for Claude
-
-<ace-verify-story>
-
-### Prerequisites
-
-1. Verify ACE is initialized
-2. Verify story status is "Done" (executed)
-3. Read story acceptance criteria
-
-### Verification Process
-
-1. **Acceptance Criteria Check**
-
-   For each acceptance criterion:
-   - Verify it's implemented
-   - Test the behavior manually if possible
-   - Check for edge cases
-
-2. **Code Quality Review**
-
-   Review the commits:
-   ```bash
-   git log --oneline -10  # See recent commits
-   ```
-
-   Check for:
-   - Consistent code style
-   - Appropriate error handling
-   - No security vulnerabilities
-   - Tests included
-
-3. **Test Suite**
-
-   Run the full test suite:
-   ```bash
-   npm test  # or appropriate test command
-   ```
-
-4. **User Acceptance**
-
-   Present findings to user:
-   ```
-   Story: E1-F1-S1 - <Title>
-
-   Acceptance Criteria:
-   ✓ Given X, when Y, then Z
-   ✓ Given A, when B, then C
-   ? Edge case needs user verification
-
-   Code Changes:
-   - X files modified
-   - Y lines added
-   - Z tests added
-
-   Test Results: All passing
-
-   Ready for user acceptance testing?
-   ```
-
-5. **Mark as Verified**
-
-   If all criteria pass:
-   - Update story status to "Verified"
-   - Update STATE.md
-   - Update BACKLOG.md progress
-
-### Issue Handling
-
-If issues are found:
-
-1. **Minor Issues**
-   - Note them for user
-   - Offer to fix immediately
-
-2. **Major Issues**
-   - Document in story file
-   - Recommend re-execution
-   - Update story status to "Needs Work"
-
-### GitHub Integration (if enabled)
-
-- Close the story issue if verified
-- Add verification comment with summary
-
-### Output
-
-```
-✓ Story E1-F1-S1 verified!
-
-All acceptance criteria met:
-  ✓ Criterion 1
-  ✓ Criterion 2
-  ✓ Criterion 3
-
-Code Quality: Good
-Tests: 12 passing, 0 failing
-
-Story marked as Verified.
-
-Feature E1-F1 progress: 2/4 stories complete
-```
-
-</ace-verify-story>