agile-context-engineering 0.1.0 → 0.2.0

package/commands/ace-execute-story.md

@@ -1,114 +0,0 @@
-# /ace:execute-story - Execute a Story
-
-Execute a refined story by completing all tasks with atomic commits.
-
-## Usage
-
-```
-/ace:execute-story <story-id>
-/ace:execute-story E1-F1-S1
-```
-
-### Arguments
-
-- `story-id` - The story identifier to execute
-
-## Behavior
-
-This command executes a story by:
-- Working through each task in sequence
-- Making atomic commits per task
-- Updating task status as work progresses
-- Running tests after each significant change
-
-## Instructions for Claude
-
-<ace-execute-story>
-
-### Prerequisites
-
-1. Verify ACE is initialized
-2. Verify story is refined (has tasks)
-3. Check for blockers
-4. Ensure clean git state
-
-### Execution Process
-
-1. **Pre-flight Check**
-   ```bash
-   git status  # Ensure clean working tree
-   ```
-
-2. **For Each Task:**
-
-   a. **Read task details**
-      - Understand what to do
-      - Know the done criteria
-
-   b. **Implement the task**
-      - Make focused changes
-      - Follow existing code patterns
-      - Write/update tests as needed
-
-   c. **Verify done criteria**
-      - Run relevant tests
-      - Check acceptance criteria
-
-   d. **Commit atomically**
-      ```bash
-      git add <specific-files>
-      git commit -m "feat(E1-F1-S1-T1): <task description>"
-      ```
-
-   e. **Update task status**
-      - Mark task as completed in story file
-
-3. **After All Tasks:**
-   - Run full test suite
-   - Update story status to "Done"
-   - Update STATE.md
-
-### Commit Message Format
-
-```
-<type>(<story-task>): <description>
-
-[optional body]
-
-Co-Authored-By: Claude <noreply@anthropic.com>
-```
-
-Types:
-- `feat` - New feature
-- `fix` - Bug fix
-- `refactor` - Code refactoring
-- `test` - Adding tests
-- `docs` - Documentation
-- `chore` - Maintenance
-
-### Error Handling
-
-If a task fails:
-1. Document the issue
-2. Ask user for guidance
-3. Do NOT proceed to next task until resolved
-4. Consider creating a blocker in STATE.md
-
-### Output
-
-```
-✓ Story E1-F1-S1 executed!
-
-Completed Tasks:
-  ✓ T1: <description> (commit abc123)
-  ✓ T2: <description> (commit def456)
-  ✓ T3: <description> (commit ghi789)
-
-Tests: All passing
-
-Next steps:
-  - Run /ace:verify-story E1-F1-S1
-  - Or continue with next story
-```
-
-</ace-execute-story>

package/commands/ace-init.md

@@ -1,254 +0,0 @@
-# /ace:init - Initialize ACE in Your Project
-
-Initialize Agile Context Engineering (ACE) for spec-driven development with Claude Code or OpenCode.
-
-## Usage
-
-```
-/ace:init [--github]
-```
-
-### Options
-
-- `--github` - Create items as GitHub issues instead of local files (requires `gh` CLI)
-
-## Behavior
-
-When invoked, this command will:
-
-1. **Check prerequisites**
-   - Verify you're in a git repository
-   - Check if ACE is already initialized
-   - If `--github` flag is used, verify `gh` CLI is authenticated
-
-2. **Create ACE directory structure**
-   ```
-   .ace/
-   ├── config.json          # ACE configuration
-   ├── backlog/             # Epic and feature definitions
-   ├── sprints/             # Sprint planning and tracking
-   └── research/            # Domain research and findings
-   ```
-
-3. **Create initial project files**
-   - `PROJECT.md` - Project vision and goals
-   - `BACKLOG.md` - Product backlog overview
-   - `STATE.md` - Current project state and decisions
-
-4. **Configure GitHub integration** (if `--github` flag used)
-   - Create GitHub labels for epics, features, stories
-   - Set up issue templates
-
-## Instructions for Claude
-
-<ace-init>
-
-### Step 1: Verify Prerequisites
-
-Check if we're in a git repository:
-```bash
-git rev-parse --is-inside-work-tree
-```
-
-Check if ACE is already initialized:
-- Look for `.ace/config.json` file
-- If exists, ask user if they want to reinitialize
-
-### Step 2: Gather Project Information
-
-Ask the user for:
-1. **Project name** - What is this project called?
-2. **Project description** - One-line description of what this project does
-3. **Storage preference** - Local files or GitHub issues?
-4. **GitHub integration** - If GitHub, which repo? (auto-detect from git remote if possible)
-
-### Step 3: Create Directory Structure
-
-Create the following structure:
-
-```
-.ace/
-├── config.json
-├── backlog/
-├── sprints/
-└── research/
-```
-
-### Step 4: Create Configuration File
-
-Create `.ace/config.json`:
-
-```json
-{
-  "version": "0.1.0",
-  "projectName": "<project-name>",
-  "description": "<project-description>",
-  "storage": "local|github",
-  "github": {
-    "enabled": false,
-    "repo": null,
-    "labels": {
-      "epic": "ace:epic",
-      "feature": "ace:feature",
-      "story": "ace:story",
-      "task": "ace:task"
-    }
-  },
-  "createdAt": "<timestamp>",
-  "hierarchy": {
-    "levels": ["epic", "feature", "story", "task"],
-    "current": {
-      "epic": null,
-      "feature": null,
-      "story": null,
-      "sprint": null
-    }
-  }
-}
-```
-
-### Step 5: Create PROJECT.md
-
-Create `PROJECT.md` in the repository root:
-
-```markdown
-# <Project Name>
-
-> <One-line description>
-
-## Vision
-
-<!-- Describe the long-term vision for this project -->
-
-## Goals
-
-<!-- List 3-5 key goals this project aims to achieve -->
-
-## Non-Goals
-
-<!-- What is explicitly out of scope -->
-
-## Success Criteria
-
-<!-- How will you measure success? -->
-
----
-
-*Managed with [ACE](https://github.com/agile-context-engineering/ace) - Agile Context Engineering*
-```
-
-### Step 6: Create BACKLOG.md
-
-Create `BACKLOG.md` in the repository root:
-
-```markdown
-# Product Backlog
-
-## Epics
-
-<!-- Epics are large bodies of work that can be broken down into features -->
-
-| ID | Epic | Status | Features |
-|----|------|--------|----------|
-| - | - | - | - |
-
-## Prioritized Features
-
-<!-- Features ready for sprint planning -->
-
-| Priority | Feature | Epic | Stories | Status |
-|----------|---------|------|---------|--------|
-| - | - | - | - | - |
-
----
-
-*Use `/ace:plan-epic` to add epics, `/ace:plan-feature` to break them into features*
-```
-
-### Step 7: Create STATE.md
-
-Create `STATE.md` in the repository root:
-
-```markdown
-# Project State
-
-> Last updated: <timestamp>
-
-## Current Sprint
-
-**Sprint:** None
-**Goal:** N/A
-**Status:** Not started
-
-## Active Work
-
-<!-- Currently in-progress items -->
-
-| Item | Type | Assignee | Status |
-|------|------|----------|--------|
-| - | - | - | - |
-
-## Decisions Log
-
-<!-- Important decisions made during development -->
-
-| Date | Decision | Context | Alternatives Considered |
-|------|----------|---------|------------------------|
-| - | - | - | - |
-
-## Blockers
-
-<!-- Current blockers and their status -->
-
-| Blocker | Impact | Owner | Status |
-|---------|--------|-------|--------|
-| - | - | - | - |
-
-## Context Notes
-
-<!-- Important context for future sessions -->
-
----
-
-*Updated automatically by ACE commands*
-```
-
-### Step 8: GitHub Setup (if enabled)
-
-If GitHub integration is enabled:
-
-1. Create labels:
-```bash
-gh label create "ace:epic" --color "7057ff" --description "ACE Epic - large body of work"
-gh label create "ace:feature" --color "0075ca" --description "ACE Feature - deliverable functionality"
-gh label create "ace:story" --color "008672" --description "ACE Story - user-facing work item"
-gh label create "ace:task" --color "d73a4a" --description "ACE Task - technical work item"
-gh label create "ace:blocked" --color "b60205" --description "ACE Blocked - waiting on dependency"
-gh label create "ace:sprint" --color "fbca04" --description "ACE Sprint - current sprint item"
-```
-
-2. Update config.json with GitHub settings
-
-### Step 9: Confirm Success
-
-Output a summary:
-
-```
-✓ ACE initialized successfully!
-
-Created:
-  - .ace/config.json
-  - .ace/backlog/
-  - .ace/sprints/
-  - .ace/research/
-  - PROJECT.md
-  - BACKLOG.md
-  - STATE.md
-
-Next steps:
-  1. Edit PROJECT.md to define your vision and goals
-  2. Run /ace:plan-project to create your initial epics
-  3. Run /ace:plan-epic to break epics into features
-```
-
-</ace-init>

package/commands/ace-plan-epic.md

@@ -1,79 +0,0 @@
-# /ace:plan-epic - Plan an Epic
-
-Break down an epic into features and define acceptance criteria.
-
-## Usage
-
-```
-/ace:plan-epic <epic-id>
-/ace:plan-epic E1
-```
-
-### Arguments
-
-- `epic-id` - The epic identifier (e.g., E1, E2)
-
-## Behavior
-
-This command helps you detail an epic by:
-- Defining all features within the epic
-- Setting acceptance criteria
-- Identifying dependencies between features
-- Estimating relative complexity
-
-## Instructions for Claude
-
-<ace-plan-epic>
-
-### Prerequisites
-
-1. Verify ACE is initialized
-2. Verify the epic exists in `.ace/backlog/`
-3. Read the epic file and understand context
-
-### Planning Flow
-
-1. **Review Epic Context**
-   - Read the epic definition
-   - Understand the user value
-   - Review any existing features
-
-2. **Feature Breakdown**
-   - Identify 3-8 features for this epic
-   - Each feature should be completable in 1-2 sprints
-   - Features should deliver demonstrable value
-
-3. **For Each Feature, Capture:**
-   - ID: E1-F1, E1-F2, etc.
-   - Name: Clear, action-oriented name
-   - Description: What this feature delivers
-   - User stories preview: High-level story count estimate
-   - Dependencies: Other features this depends on
-   - Acceptance criteria: How we know it's done
-
-4. **Create Feature Files**
-   - Save to `.ace/backlog/<epic-id>/F1-feature-name.md`
-
-5. **Update Epic File**
-   - Add features table
-   - Update status
-
-6. **GitHub Integration** (if enabled)
-   - Create feature issues linked to epic
-   - Add `ace:feature` label
-
-### Output
-
-```
-✓ Epic E1 planned!
-
-Features:
-  E1-F1: <Feature Name>
-  E1-F2: <Feature Name>
-  ...
-
-Next steps:
-  - Run /ace:plan-feature E1-F1 to break into stories
-```
-
-</ace-plan-epic>

package/commands/ace-plan-feature.md

@@ -1,78 +0,0 @@
-# /ace:plan-feature - Plan a Feature
-
-Break down a feature into user stories ready for sprint planning.
-
-## Usage
-
-```
-/ace:plan-feature <feature-id>
-/ace:plan-feature E1-F1
-```
-
-### Arguments
-
-- `feature-id` - The feature identifier (e.g., E1-F1)
-
-## Behavior
-
-This command helps you detail a feature by:
-- Defining user stories using the "As a... I want... So that..." format
-- Setting story acceptance criteria
-- Identifying technical considerations
-- Preparing stories for sprint planning
-
-## Instructions for Claude
-
-<ace-plan-feature>
-
-### Prerequisites
-
-1. Verify ACE is initialized
-2. Verify the feature exists
-3. Read feature and parent epic context
-
-### Planning Flow
-
-1. **Review Feature Context**
-   - Understand what this feature delivers
-   - Review acceptance criteria
-   - Understand dependencies
-
-2. **Story Breakdown**
-   - Create 2-5 user stories per feature
-   - Each story should be completable in 1-3 days
-   - Stories should be independently valuable
-
-3. **For Each Story, Capture:**
-   - ID: E1-F1-S1, etc.
-   - Title: Action-oriented title
-   - User Story: "As a [user], I want [goal], so that [benefit]"
-   - Acceptance Criteria: Testable conditions
-   - Technical Notes: Implementation considerations
-   - Estimate: Story points (1, 2, 3, 5, 8)
-
-4. **Create Story Files**
-   - Save to `.ace/backlog/<epic>/<feature>/S1-story-name.md`
-
-5. **GitHub Integration** (if enabled)
-   - Create story issues linked to feature
-   - Add `ace:story` label
-
-### Output
-
-```
-✓ Feature E1-F1 planned!
-
-Stories:
-  E1-F1-S1: <Story Title> (3 pts)
-  E1-F1-S2: <Story Title> (2 pts)
-  ...
-
-Total Points: X
-
-Next steps:
-  - Run /ace:refine-story E1-F1-S1 to prepare for execution
-  - Add stories to sprint with /ace:sprint-plan
-```
-
-</ace-plan-feature>