get-shit-done-cc 1.0.0

package/commands/gsd/execute-plan.md

@@ -0,0 +1,108 @@
+---
+description: Execute a PLAN.md file
+argument-hint: "[path-to-PLAN.md]"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Glob
+  - Grep
+  - Task
+  - AskUserQuestion
+---
+
+<objective>
+Execute a PLAN.md file, create SUMMARY.md, update project state, commit.
+
+Uses intelligent segmentation:
+
+- Plans without checkpoints → spawn subagent for full autonomous execution
+- Plans with verify checkpoints → segment execution, pause at checkpoints
+- Plans with decision checkpoints → execute in main context
+  </objective>
+
+<execution_context>
+@~/.claude/get-shit-done/workflows/execute-phase.md
+@~/.claude/get-shit-done/templates/summary.md
+@~/.claude/get-shit-done/references/checkpoints.md
+</execution_context>
+
+<context>
+Plan path: $ARGUMENTS
+
+**Load project state first:**
+@.planning/STATE.md
+
+**Load workflow config:**
+@.planning/config.json
+</context>
+
+<process>
+1. Check .planning/ directory exists (error if not - user should run /gsd:new-project)
+2. Verify plan at $ARGUMENTS exists
+3. Check if SUMMARY.md already exists (plan already executed?)
+4. Load workflow config for mode (interactive/yolo)
+5. Follow execute-phase.md workflow:
+   - Parse plan and determine execution strategy (A/B/C)
+   - Execute tasks (via subagent or main context as appropriate)
+   - Handle checkpoints and deviations
+   - Create SUMMARY.md
+   - Update STATE.md
+   - Commit changes
+</process>
+
+<execution_strategies>
+**Strategy A: Fully Autonomous** (no checkpoints)
+
+- Spawn subagent to execute entire plan
+- Subagent creates SUMMARY.md and commits
+- Main context: orchestration only (~5% usage)
+
+**Strategy B: Segmented** (has verify-only checkpoints)
+
+- Execute in segments between checkpoints
+- Subagent for autonomous segments
+- Main context for checkpoints
+- Aggregate results → SUMMARY → commit
+
+**Strategy C: Decision-Dependent** (has decision checkpoints)
+
+- Execute in main context
+- Decision outcomes affect subsequent tasks
+- Quality maintained through small scope (2-3 tasks per plan)
+  </execution_strategies>
+
+<deviation_rules>
+During execution, handle discoveries automatically:
+
+1. **Auto-fix bugs** - Fix immediately, document in Summary
+2. **Auto-add critical** - Security/correctness gaps, add and document
+3. **Auto-fix blockers** - Can't proceed without fix, do it and document
+4. **Ask about architectural** - Major structural changes, stop and ask user
+5. **Log enhancements** - Nice-to-haves, log to ISSUES.md, continue
+
+Only rule 4 requires user intervention.
+</deviation_rules>
+
+<commit_rules>
+**Critical: Stage only files this plan actually modified.**
+
+NEVER use:
+
+- `git add .`
+- `git add -A`
+- `git add src/` or any broad directory
+
+Stage each file individually from the modified-files list.
+</commit_rules>
+
+<success_criteria>
+
+- [ ] All tasks executed
+- [ ] SUMMARY.md created with substantive content
+- [ ] STATE.md updated (position, decisions, issues, session)
+- [ ] ROADMAP updated (plan count, phase status)
+- [ ] Changes committed with feat({phase}-{plan}): [summary]
+- [ ] User informed of next steps
+      </success_criteria>

package/commands/gsd/help.md

@@ -0,0 +1,252 @@
+---
+description: Show available GSD commands and usage guide
+---
+
+<objective>
+Display the complete GSD command reference.
+
+Output ONLY the reference content below. Do NOT add:
+
+- Project-specific analysis
+- Git status or file context
+- Next-step suggestions
+- Any commentary beyond the reference
+  </objective>
+
+<reference>
+# GSD Command Reference
+
+**GSD** (Get Shit Done) creates hierarchical project plans optimized for solo agentic development with Claude Code.
+
+## Quick Start
+
+1. `/gsd:new-project` - Initialize project with brief and roadmap
+2. `/gsd:plan-phase <number>` - Create detailed plan for first phase
+3. `/gsd:execute-plan <path>` - Execute the plan
+
+## Core Workflow
+
+```
+Initialization → Planning → Execution → Milestone Completion
+```
+
+### Project Initialization
+
+**`/gsd:new-project`**
+Initialize new project with brief, roadmap, and state tracking.
+
+- Creates `.planning/PROJECT.md` (vision and requirements)
+- Creates `.planning/ROADMAP.md` (phase breakdown)
+- Creates `.planning/STATE.md` (project memory)
+- Creates `.planning/config.json` (workflow mode)
+- Asks for workflow mode (interactive/yolo) upfront
+- Commits all initialization files to git
+
+Usage: `/gsd:new-project`
+
+### Phase Planning
+
+**`/gsd:discuss-phase <number>`**
+Gather phase context through adaptive questioning before planning.
+
+- Builds understanding of objectives, constraints, risks
+- Creates CONTEXT.md in phase directory
+- Use before planning unfamiliar or complex phases
+
+Usage: `/gsd:discuss-phase 2`
+
+**`/gsd:list-phase-assumptions <number>`**
+Surface Claude's assumptions about a phase before planning.
+
+- Shows what Claude thinks about technical approach, scope, risks
+- Enables early course correction before planning begins
+- No files created - conversational output only
+
+Usage: `/gsd:list-phase-assumptions 3`
+
+**`/gsd:plan-phase <number>`**
+Create detailed execution plan for a specific phase.
+
+- Generates `.planning/phases/XX-phase-name/XX-YY-PLAN.md`
+- Breaks phase into concrete, actionable tasks
+- Includes verification criteria and success measures
+- Multiple plans per phase supported (XX-01, XX-02, etc.)
+
+Usage: `/gsd:plan-phase 1`
+Result: Creates `.planning/phases/01-foundation/01-01-PLAN.md`
+
+### Execution
+
+**`/gsd:execute-plan <path>`**
+Execute a PLAN.md file directly.
+
+- Runs plan tasks sequentially
+- Creates SUMMARY.md after completion
+- Updates STATE.md with accumulated context
+- Fast execution without loading full skill context
+
+Usage: `/gsd:execute-plan .planning/phases/01-foundation/01-01-PLAN.md`
+
+### Roadmap Management
+
+**`/gsd:add-phase <description>`**
+Add new phase to end of current milestone.
+
+- Appends to ROADMAP.md
+- Uses next sequential number
+- Updates phase directory structure
+
+Usage: `/gsd:add-phase "Add admin dashboard"`
+
+**`/gsd:insert-phase <after> <description>`**
+Insert urgent work as decimal phase between existing phases.
+
+- Creates intermediate phase (e.g., 7.1 between 7 and 8)
+- Useful for discovered work that must happen mid-milestone
+- Maintains phase ordering
+
+Usage: `/gsd:insert-phase 7 "Fix critical auth bug"`
+Result: Creates Phase 7.1
+
+### Milestone Management
+
+**`/gsd:discuss-milestone`**
+Gather context for next milestone through adaptive questioning.
+
+- Reviews previous milestone accomplishments
+- Asks about scope, constraints, priorities for next milestone
+- Routes to /gsd:new-milestone when ready
+
+Usage: `/gsd:discuss-milestone`
+
+**`/gsd:new-milestone <name>`**
+Create a new milestone with phases for an existing project.
+
+- Adds milestone section to ROADMAP.md
+- Creates phase directories
+- Updates STATE.md for new milestone
+
+Usage: `/gsd:new-milestone "v2.0 Features"`
+
+**`/gsd:complete-milestone <version>`**
+Archive completed milestone and prepare for next version.
+
+- Creates MILESTONES.md entry with stats
+- Archives full details to milestones/ directory
+- Creates git tag for the release
+- Prepares workspace for next version
+
+Usage: `/gsd:complete-milestone 1.0.0`
+
+### Progress Tracking
+
+**`/gsd:progress`**
+Check project status and intelligently route to next action.
+
+- Shows visual progress bar and completion percentage
+- Summarizes recent work from SUMMARY files
+- Displays current position and what's next
+- Lists key decisions and open issues
+- Offers to execute next plan or create it if missing
+- Detects 100% milestone completion
+
+Usage: `/gsd:progress`
+
+### Session Management
+
+**`/gsd:resume-work`**
+Resume work from previous session with full context restoration.
+
+- Reads STATE.md for project context
+- Shows current position and recent progress
+- Offers next actions based on project state
+
+Usage: `/gsd:resume-work`
+
+**`/gsd:pause-work`**
+Create context handoff when pausing work mid-phase.
+
+- Creates .continue-here file with current state
+- Updates STATE.md session continuity section
+- Captures in-progress work context
+
+Usage: `/gsd:pause-work`
+
+### Utility Commands
+
+**`/gsd:help`**
+Show this command reference.
+
+## Files & Structure
+
+```
+.planning/
+├── PROJECT.md            # Project vision
+├── ROADMAP.md            # Current phase breakdown
+├── STATE.md              # Project memory & context
+├── config.json           # Workflow mode & gates
+└── phases/
+    ├── 01-foundation/
+    │   ├── 01-01-PLAN.md
+    │   └── 01-01-SUMMARY.md
+    └── 02-core-features/
+        ├── 02-01-PLAN.md
+        └── 02-01-SUMMARY.md
+```
+
+## Workflow Modes
+
+Set during `/gsd:new-project`:
+
+**Interactive Mode**
+
+- Confirms each major decision
+- Pauses at checkpoints for approval
+- More guidance throughout
+
+**YOLO Mode**
+
+- Auto-approves most decisions
+- Executes plans without confirmation
+- Only stops for critical checkpoints
+
+Change anytime by editing `.planning/config.json`
+
+## Common Workflows
+
+**Starting a new project:**
+
+```
+/gsd:new-project
+/gsd:plan-phase 1
+/gsd:execute-plan .planning/phases/01-foundation/01-01-PLAN.md
+```
+
+**Resuming work after a break:**
+
+```
+/gsd:progress  # See where you left off and continue
+```
+
+**Adding urgent mid-milestone work:**
+
+```
+/gsd:insert-phase 5 "Critical security fix"
+/gsd:plan-phase 5.1
+/gsd:execute-plan .planning/phases/05.1-critical-security-fix/05.1-01-PLAN.md
+```
+
+**Completing a milestone:**
+
+```
+/gsd:complete-milestone 1.0.0
+/gsd:new-project  # Start next milestone
+```
+
+## Getting Help
+
+- Read `.planning/PROJECT.md` for project vision
+- Read `.planning/STATE.md` for current context
+- Check `.planning/ROADMAP.md` for phase status
+- Run `/gsd:progress` to check where you're up to
+  </reference>

package/commands/gsd/insert-phase.md

@@ -0,0 +1,218 @@
+---
+description: Insert urgent work as decimal phase (e.g., 72.1) between existing phases
+argument-hint: <after> <description>
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+---
+
+<objective>
+Insert a decimal phase for urgent work discovered mid-milestone that must be completed between existing integer phases.
+
+Uses decimal numbering (72.1, 72.2, etc.) to preserve the logical sequence of planned phases while accommodating urgent insertions.
+
+Purpose: Handle urgent work discovered during execution without renumbering entire roadmap.
+</objective>
+
+<execution_context>
+@.planning/ROADMAP.md
+@.planning/STATE.md
+</execution_context>
+
+<process>
+
+<step name="parse_arguments">
+Parse the command arguments:
+- First argument: integer phase number to insert after
+- Remaining arguments: phase description
+
+Example: `/gsd:insert-phase 72 Fix critical auth bug`
+→ after = 72
+→ description = "Fix critical auth bug"
+
+Validation:
+
+```bash
+if [ $# -lt 2 ]; then
+  echo "ERROR: Both phase number and description required"
+  echo "Usage: /gsd:insert-phase <after> <description>"
+  echo "Example: /gsd:insert-phase 72 Fix critical auth bug"
+  exit 1
+fi
+```
+
+Parse first argument as integer:
+
+```bash
+after_phase=$1
+shift
+description="$*"
+
+# Validate after_phase is an integer
+if ! [[ "$after_phase" =~ ^[0-9]+$ ]]; then
+  echo "ERROR: Phase number must be an integer"
+  exit 1
+fi
+```
+
+</step>
+
+<step name="load_roadmap">
+Load the roadmap file:
+
+```bash
+if [ -f .planning/ROADMAP.md ]; then
+  ROADMAP=".planning/ROADMAP.md"
+else
+  echo "ERROR: No roadmap found (.planning/ROADMAP.md)"
+  exit 1
+fi
+```
+
+Read roadmap content for parsing.
+</step>
+
+<step name="verify_target_phase">
+Verify that the target phase exists in the roadmap:
+
+1. Search for "### Phase {after_phase}:" heading
+2. If not found:
+
+   ```
+   ERROR: Phase {after_phase} not found in roadmap
+   Available phases: [list phase numbers]
+   ```
+
+   Exit.
+
+3. Verify phase is in current milestone (not completed/archived)
+   </step>
+
+<step name="find_existing_decimals">
+Find existing decimal phases after the target phase:
+
+1. Search for all "### Phase {after_phase}.N:" headings
+2. Extract decimal suffixes (e.g., for Phase 72: find 72.1, 72.2, 72.3)
+3. Find the highest decimal suffix
+4. Calculate next decimal: max + 1
+
+Examples:
+
+- Phase 72 with no decimals → next is 72.1
+- Phase 72 with 72.1 → next is 72.2
+- Phase 72 with 72.1, 72.2 → next is 72.3
+
+Store as: `decimal_phase="${after_phase}.${next_decimal}"`
+</step>
+
+<step name="generate_slug">
+Convert the phase description to a kebab-case slug:
+
+```bash
+slug=$(echo "$description" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | sed 's/--*/-/g' | sed 's/^-//;s/-$//')
+```
+
+Phase directory name: `{decimal-phase}-{slug}`
+Example: `72.1-fix-critical-auth-bug`
+</step>
+
+<step name="create_phase_directory">
+Create the phase directory structure:
+
+```bash
+phase_dir=".planning/phases/${decimal_phase}-${slug}"
+mkdir -p "$phase_dir"
+```
+
+Confirm: "Created directory: $phase_dir"
+</step>
+
+<step name="update_roadmap">
+Insert the new phase entry into the roadmap:
+
+1. Find insertion point: immediately after Phase {after_phase}'s content (before next phase heading or "---")
+2. Insert new phase heading with (INSERTED) marker:
+
+   ```
+   ### Phase {decimal_phase}: {Description} (INSERTED)
+
+   **Goal:** [Urgent work - to be planned]
+   **Depends on:** Phase {after_phase}
+   **Plans:** 0 plans
+
+   Plans:
+   - [ ] TBD (run /gsd:plan-phase {decimal_phase} to break down)
+
+   **Details:**
+   [To be added during planning]
+   ```
+
+3. Write updated roadmap back to file
+
+The "(INSERTED)" marker helps identify decimal phases as urgent insertions.
+
+Preserve all other content exactly (formatting, spacing, other phases).
+</step>
+
+<step name="update_project_state">
+Update STATE.md to reflect the inserted phase:
+
+1. Read `.planning/STATE.md`
+2. Under "## Accumulated Context" → "### Roadmap Evolution" add entry:
+   ```
+   - Phase {decimal_phase} inserted after Phase {after_phase}: {description} (URGENT)
+   ```
+
+If "Roadmap Evolution" section doesn't exist, create it.
+
+Add note about insertion reason if appropriate.
+</step>
+
+<step name="completion">
+Present completion summary:
+
+```
+Phase {decimal_phase} inserted after Phase {after_phase}:
+- Description: {description}
+- Directory: .planning/phases/{decimal-phase}-{slug}/
+- Status: Not planned yet
+- Marker: (INSERTED) - indicates urgent work
+
+Roadmap updated: {roadmap-path}
+Project state updated: .planning/STATE.md
+
+What's next?
+1. Plan this phase: /gsd:plan-phase {decimal_phase}
+2. Review insertion impact: Check if Phase {next_integer} dependencies still make sense
+3. Review roadmap: cat .planning/ROADMAP.md
+```
+
+**If user selects option 1:**
+Invoke SlashCommand("/gsd:plan-phase {decimal_phase}")
+
+Note: Command is shown in option 1 above so user can see what will run.
+</step>
+
+</process>
+
+<anti_patterns>
+
+- Don't use this for planned work at end of milestone (use /gsd:add-phase)
+- Don't insert before Phase 1 (decimal 0.1 makes no sense)
+- Don't renumber existing phases
+- Don't modify the target phase content
+- Don't create plans yet (that's /gsd:plan-phase)
+- Don't commit changes (user decides when to commit)
+  </anti_patterns>
+
+<success_criteria>
+Phase insertion is complete when:
+
+- [ ] Phase directory created: `.planning/phases/{N.M}-{slug}/`
+- [ ] Roadmap updated with new phase entry (includes "(INSERTED)" marker)
+- [ ] Phase inserted in correct position (after target phase, before next integer phase)
+- [ ] STATE.md updated with roadmap evolution note
+- [ ] Decimal number calculated correctly (based on existing decimals)
+- [ ] User informed of next steps and dependency implications
+      </success_criteria>

package/commands/gsd/list-phase-assumptions.md

@@ -0,0 +1,49 @@
+---
+description: Surface Claude's assumptions about a phase approach before planning
+argument-hint: "[phase]"
+allowed-tools:
+  - Read
+  - Bash
+  - Grep
+  - Glob
+---
+
+<objective>
+Analyze a phase and present Claude's assumptions about technical approach, implementation order, scope boundaries, risk areas, and dependencies.
+
+Purpose: Help users see what Claude thinks BEFORE planning begins - enabling course correction early when assumptions are wrong.
+Output: Conversational output only (no file creation) - ends with "What do you think?" prompt
+</objective>
+
+<execution_context>
+@~/.claude/get-shit-done/workflows/list-phase-assumptions.md
+</execution_context>
+
+<context>
+Phase number: $ARGUMENTS (required)
+
+**Load project state first:**
+@.planning/STATE.md
+
+**Load roadmap:**
+@.planning/ROADMAP.md
+</context>
+
+<process>
+1. Validate phase number argument (error if missing or invalid)
+2. Check if phase exists in roadmap
+3. Follow list-phase-assumptions.md workflow:
+   - Analyze roadmap description
+   - Surface assumptions about: technical approach, implementation order, scope, risks, dependencies
+   - Present assumptions clearly
+   - Prompt "What do you think?"
+4. Gather feedback and offer next steps
+</process>
+
+<success_criteria>
+
+- Phase validated against roadmap
+- Assumptions surfaced across five areas
+- User prompted for feedback
+- User knows next steps (discuss context, plan phase, or correct assumptions)
+  </success_criteria>

package/commands/gsd/new-milestone.md

@@ -0,0 +1,58 @@
+---
+description: Create a new milestone with phases for an existing project
+argument-hint: "[milestone name, e.g., 'v2.0 Features']"
+---
+
+<objective>
+Create a new milestone for an existing project with defined phases.
+
+Purpose: After completing a milestone (or when ready to define next chunk of work), creates the milestone structure in ROADMAP.md with phases, updates STATE.md, and creates phase directories.
+Output: New milestone in ROADMAP.md, updated STATE.md, phase directories created
+</objective>
+
+<execution_context>
+@~/.claude/get-shit-done/workflows/create-milestone.md
+@~/.claude/get-shit-done/templates/roadmap.md
+</execution_context>
+
+<context>
+Milestone name: $ARGUMENTS (optional - will prompt if not provided)
+
+**Load project state first:**
+@.planning/STATE.md
+
+**Load roadmap:**
+@.planning/ROADMAP.md
+
+**Load milestones (if exists):**
+@.planning/MILESTONES.md
+</context>
+
+<process>
+1. Load project context (STATE.md, ROADMAP.md, MILESTONES.md)
+2. Calculate next milestone version and starting phase number
+3. If milestone name provided in arguments, use it; otherwise prompt
+4. Gather phases (3-6 recommended):
+   - If called from /gsd:discuss-milestone, use provided context
+   - Otherwise, prompt for phase breakdown
+5. Detect research needs for each phase
+6. Confirm phases (respect config.json gate settings)
+7. Follow create-milestone.md workflow:
+   - Update ROADMAP.md with new milestone section
+   - Create phase directories
+   - Update STATE.md for new milestone
+   - Git commit milestone creation
+8. Offer next steps (discuss first phase, plan first phase, review)
+</process>
+
+<success_criteria>
+
+- Next phase number calculated correctly (continues from previous milestone)
+- 3-6 phases defined with clear names
+- Research flags assigned for each phase
+- ROADMAP.md updated with new milestone section
+- Phase directories created
+- STATE.md reset for new milestone
+- Git commit made
+- User knows next steps
+  </success_criteria>