get-shit-done-cc 1.0.0

package/commands/gsd/new-project.md

@@ -0,0 +1,177 @@
+---
+description: Initialize a new project with deep context gathering, PROJECT.md, roadmap, and state tracking
+allowed-tools:
+  - Read
+  - Bash
+  - Write
+  - AskUserQuestion
+---
+
+<!--
+DESIGN NOTE: Command + Workflow Pattern
+
+This command handles the questioning phase directly (user interaction intensive),
+then delegates roadmap/state creation to the create-roadmap workflow.
+
+Architecture:
+- Command: new-project.md - questioning, PROJECT.md, config.json
+- Workflow: create-roadmap.md - domain detection, research flags, ROADMAP.md, STATE.md
+-->
+
+<objective>
+Initialize a new project through comprehensive context gathering.
+
+This is the most leveraged moment in any project. Deep questioning here means better plans, better execution, better outcomes.
+
+Creates `.planning/` with PROJECT.md, ROADMAP.md, STATE.md, and config.json.
+</objective>
+
+<execution_context>
+@~/.claude/get-shit-done/workflows/create-roadmap.md
+@~/.claude/get-shit-done/references/principles.md
+@~/.claude/get-shit-done/references/questioning.md
+@~/.claude/get-shit-done/templates/project.md
+@~/.claude/get-shit-done/templates/config.json
+</execution_context>
+
+<context>
+!`[ -d .planning ] && echo "PLANNING_EXISTS" || echo "NO_PLANNING"`
+!`[ -d .git ] && echo "GIT_EXISTS" || echo "NO_GIT"`
+</context>
+
+<process>
+
+<step name="setup" silent="true">
+Silent setup - execute before any user output:
+
+```bash
+# Abort if project exists
+[ -d .planning ] && echo "Project already initialized. Use /gsd:progress" && exit 1
+
+# Initialize git
+[ -d .git ] || git init
+```
+
+</step>
+
+<step name="question">
+Start: "What do you want to build?"
+
+Then use AskUserQuestion to cover the 9 domains (project type, problem, audience, success, constraints, scope, current state, decisions, open questions).
+
+Skip domains already clear from user input. Probe for specifics on vague answers.
+
+**Decision gate (MUST have all 3 options):**
+
+```
+Header: "Ready?"
+Options:
+  1. "Create PROJECT.md" - Finalize
+  2. "Ask more questions" - Dig into uncovered domains
+  3. "Let me add context" - User shares more
+```
+
+If "Ask more questions" → ask about 2-3 uncovered domains → return to gate.
+Loop until "Create PROJECT.md" selected.
+</step>
+
+<step name="project">
+Synthesize all context into `.planning/PROJECT.md` using the template from `templates/project.md`.
+
+Do not compress. Capture everything gathered.
+</step>
+
+<step name="mode">
+Ask workflow mode preference:
+
+Use AskUserQuestion:
+
+- header: "Mode"
+- question: "How do you want to work?"
+- options:
+  - "Interactive" - Confirm at each step
+  - "YOLO" - Auto-approve, just execute
+
+Create `.planning/config.json` with chosen mode using `templates/config.json` structure.
+</step>
+
+<step name="roadmap_and_state">
+**Follow the create-roadmap workflow** from `@~/.claude/get-shit-done/workflows/create-roadmap.md`.
+
+This handles:
+
+1. Domain expertise detection (scan for applicable skills)
+2. Phase identification (3-6 phases based on PROJECT.md)
+3. Research needs detection (flag phases needing investigation)
+4. Phase confirmation (respects yolo/interactive mode)
+5. ROADMAP.md creation with research flags
+6. STATE.md initialization
+7. Phase directory creation
+
+The workflow will create:
+
+- `.planning/ROADMAP.md`
+- `.planning/STATE.md`
+- `.planning/phases/XX-name/` directories
+  </step>
+
+<step name="commit">
+```bash
+git add .planning/
+git commit -m "$(cat <<'EOF'
+docs: initialize [project-name] ([N] phases)
+
+[One-liner from PROJECT.md]
+
+Phases:
+
+1. [phase-name]: [goal]
+2. [phase-name]: [goal]
+3. [phase-name]: [goal]
+   EOF
+   )"
+
+```
+</step>
+
+<step name="done">
+```
+
+Project initialized:
+
+- Project: .planning/PROJECT.md
+- Roadmap: .planning/ROADMAP.md ([N] phases)
+- State: .planning/STATE.md
+- Config: .planning/config.json (mode: [chosen mode])
+
+What's next?
+
+1. Plan Phase 1 (/gsd:plan-phase 01)
+2. Review project setup
+3. Done for now
+
+```
+
+If user selects "Plan Phase 1" → invoke `/gsd:plan-phase 01`
+</step>
+
+</process>
+
+<output>
+- `.planning/PROJECT.md`
+- `.planning/ROADMAP.md`
+- `.planning/STATE.md`
+- `.planning/config.json`
+- `.planning/phases/XX-name/` directories
+</output>
+
+<success_criteria>
+- [ ] Deep questioning completed (not rushed)
+- [ ] PROJECT.md captures full context
+- [ ] config.json has workflow mode
+- [ ] ROADMAP.md has 3-6 phases with research flags
+- [ ] STATE.md initialized with project summary
+- [ ] Phase directories created
+- [ ] All committed to git
+</success_criteria>
+```

package/commands/gsd/pause-work.md

@@ -0,0 +1,123 @@
+---
+description: Create context handoff when pausing work mid-phase
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+---
+
+<objective>
+Create `.continue-here.md` handoff file to preserve complete work state across sessions.
+
+Enables seamless resumption in fresh session with full context restoration.
+</objective>
+
+<context>
+@.planning/STATE.md
+Current phase: !`ls -lt .planning/phases/*/*.md 2>/dev/null | head -1`
+</context>
+
+<process>
+
+<step name="detect">
+Find current phase directory from most recently modified files.
+</step>
+
+<step name="gather">
+**Collect complete state for handoff:**
+
+1. **Current position**: Which phase, which plan, which task
+2. **Work completed**: What got done this session
+3. **Work remaining**: What's left in current plan/phase
+4. **Decisions made**: Key decisions and rationale
+5. **Blockers/issues**: Anything stuck
+6. **Mental context**: The approach, next steps, "vibe"
+7. **Files modified**: What's changed but not committed
+
+Ask user for clarifications if needed.
+</step>
+
+<step name="write">
+**Write handoff to `.planning/phases/XX-name/.continue-here.md`:**
+
+```markdown
+---
+phase: XX-name
+task: 3
+total_tasks: 7
+status: in_progress
+last_updated: [timestamp]
+---
+
+<current_state>
+[Where exactly are we? Immediate context]
+</current_state>
+
+<completed_work>
+
+- Task 1: [name] - Done
+- Task 2: [name] - Done
+- Task 3: [name] - In progress, [what's done]
+  </completed_work>
+
+<remaining_work>
+
+- Task 3: [what's left]
+- Task 4: Not started
+- Task 5: Not started
+  </remaining_work>
+
+<decisions_made>
+
+- Decided to use [X] because [reason]
+- Chose [approach] over [alternative] because [reason]
+  </decisions_made>
+
+<blockers>
+- [Blocker 1]: [status/workaround]
+</blockers>
+
+<context>
+[Mental state, what were you thinking, the plan]
+</context>
+
+<next_action>
+Start with: [specific first action when resuming]
+</next_action>
+```
+
+Be specific enough for a fresh Claude to understand immediately.
+</step>
+
+<step name="commit">
+```bash
+git add .planning/phases/*/.continue-here.md
+git commit -m "wip: [phase-name] paused at task [X]/[Y]"
+```
+</step>
+
+<step name="confirm">
+```
+✓ Handoff created: .planning/phases/[XX-name]/.continue-here.md
+
+Current state:
+
+- Phase: [XX-name]
+- Task: [X] of [Y]
+- Status: [in_progress/blocked]
+- Committed as WIP
+
+To resume: /gsd:resume-work
+
+```
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] .continue-here.md created in correct phase directory
+- [ ] All sections filled with specific content
+- [ ] Committed as WIP
+- [ ] User knows location and how to resume
+</success_criteria>
+```

package/commands/gsd/plan-phase.md

@@ -0,0 +1,60 @@
+---
+description: Create detailed execution plan for a phase (PLAN.md)
+argument-hint: "[phase]"
+allowed-tools:
+  - Read
+  - Bash
+  - Write
+  - Glob
+  - Grep
+  - AskUserQuestion
+  - WebFetch
+  - mcp__context7__*
+---
+
+<objective>
+Create executable phase prompt with discovery, context injection, and task breakdown.
+
+Purpose: Break down roadmap phases into concrete, executable PLAN.md files that Claude can execute.
+Output: One or more PLAN.md files in the phase directory (.planning/phases/XX-name/{phase}-{plan}-PLAN.md)
+</objective>
+
+<execution_context>
+@~/.claude/get-shit-done/workflows/plan-phase.md
+@~/.claude/get-shit-done/templates/phase-prompt.md
+@~/.claude/get-shit-done/references/plan-format.md
+@~/.claude/get-shit-done/references/scope-estimation.md
+@~/.claude/get-shit-done/references/checkpoints.md
+@~/.claude/get-shit-done/references/cli-automation.md
+</execution_context>
+
+<context>
+Phase number: $ARGUMENTS (optional - auto-detects next unplanned phase if not provided)
+
+**Load project state first:**
+@.planning/STATE.md
+
+**Load roadmap:**
+@.planning/ROADMAP.md
+</context>
+
+<process>
+1. Check .planning/ directory exists (error if not - user should run /gsd:new-project)
+2. If phase number provided via $ARGUMENTS, validate it exists in roadmap
+3. If no phase number, detect next unplanned phase from roadmap
+4. Follow plan-phase.md workflow:
+   - Load project state and accumulated decisions
+   - Perform mandatory discovery (Level 0-3 as appropriate)
+   - Read project history (prior decisions, issues, concerns)
+   - Break phase into tasks
+   - Estimate scope and split into multiple plans if needed
+   - Create PLAN.md file(s) with executable structure
+</process>
+
+<success_criteria>
+
+- One or more PLAN.md files created in .planning/phases/XX-name/
+- Each plan has: objective, execution_context, context, tasks, verification, success_criteria, output
+- Tasks are specific enough for Claude to execute
+- User knows next steps (execute plan or review/adjust)
+  </success_criteria>

package/commands/gsd/progress.md

@@ -0,0 +1,182 @@
+---
+description: Check project progress, show context, and route to next action (execute or plan)
+allowed-tools:
+  - Read
+  - Bash
+  - Grep
+  - Glob
+  - SlashCommand
+---
+
+<objective>
+Check project progress, summarize recent work and what's ahead, then intelligently route to the next action - either executing an existing plan or creating the next one.
+
+Provides situational awareness before continuing work.
+</objective>
+
+<context>
+Planning structure: !`ls -la .planning/ 2>/dev/null || echo "NO_PLANNING_STRUCTURE"`
+Phases: !`ls .planning/phases/ 2>/dev/null || echo "NO_PHASES"`
+State exists: !`[ -f .planning/STATE.md ] && echo "EXISTS" || echo "MISSING"`
+Roadmap exists: !`[ -f .planning/ROADMAP.md ] && echo "EXISTS" || echo "MISSING"`
+Recent summaries: !`find .planning/phases -name "*-SUMMARY.md" -type f 2>/dev/null | sort | tail -3`
+All plans: !`find .planning/phases -name "*-PLAN.md" -type f 2>/dev/null | sort`
+All summaries: !`find .planning/phases -name "*-SUMMARY.md" -type f 2>/dev/null | sort`
+</context>
+
+<process>
+
+<step name="verify">
+**Verify planning structure exists:**
+
+If no `.planning/` directory:
+
+```
+No planning structure found.
+
+Run /gsd:new-project to start a new project.
+```
+
+Exit.
+
+If missing STATE.md or ROADMAP.md: inform what's missing, suggest running `/gsd:new-project`.
+</step>
+
+<step name="load">
+**Load full project context:**
+
+- Read `.planning/STATE.md` for living memory (position, decisions, issues)
+- Read `.planning/ROADMAP.md` for phase structure and objectives
+- Read `.planning/PROJECT.md` for project vision (brief summary only)
+  </step>
+
+<step name="recent">
+**Gather recent work context:**
+
+- Find the 2-3 most recent SUMMARY.md files
+- Extract from each: what was accomplished, key decisions, any issues logged
+- This shows "what we've been working on"
+  </step>
+
+<step name="position">
+**Parse current position:**
+
+- From STATE.md: current phase, plan number, status
+- Calculate: total plans, completed plans, remaining plans
+- Note any blockers, concerns, or deferred issues
+- Check for CONTEXT.md: For phases without PLAN.md files, check if `{phase}-CONTEXT.md` exists in phase directory
+  </step>
+
+<step name="report">
+**Present rich status report:**
+
+```
+# [Project Name]
+
+**Progress:** [████████░░] 8/10 plans complete
+
+## Recent Work
+- [Phase X, Plan Y]: [what was accomplished - 1 line]
+- [Phase X, Plan Z]: [what was accomplished - 1 line]
+
+## Current Position
+Phase [N] of [total]: [phase-name]
+Plan [M] of [phase-total]: [status]
+CONTEXT: [✓ if CONTEXT.md exists | - if not]
+
+## Key Decisions Made
+- [decision 1 from STATE.md]
+- [decision 2]
+
+## Open Issues
+- [any deferred issues or blockers]
+
+## What's Next
+[Next phase/plan objective from ROADMAP]
+```
+
+</step>
+
+<step name="route">
+**Determine next action:**
+
+Find the next plan number that needs work.
+Check if `{phase}-{plan}-PLAN.md` exists for that number.
+
+**If PLAN.md exists (unexecuted):**
+
+- Read its `<objective>` section
+- Show: "Ready to execute: [path] - [objective summary]"
+- Ask: "Execute? (y/n)"
+- **CRITICAL: If user responds "y", "yes", or affirmatively, immediately invoke:**
+  ```
+  SlashCommand("/gsd:execute-plan [full-path-to-PLAN.md]")
+  ```
+  Do NOT describe what you would do. INVOKE THE TOOL.
+
+**If PLAN.md does NOT exist:**
+
+- Check if `{phase}-CONTEXT.md` exists in phase directory
+- Show: "Next plan not yet created: [expected path]"
+- Show phase objective from ROADMAP
+
+**If CONTEXT.md exists:**
+
+- Display: "✓ Context gathered, ready to plan"
+- Ask: "Create this plan? (y/n)"
+- **CRITICAL: If user responds "y", "yes", or affirmatively, immediately invoke:**
+  ```
+  SlashCommand("/gsd:plan-phase [phase-number]")
+  ```
+  Do NOT describe what you would do. INVOKE THE TOOL.
+
+**If CONTEXT.md does NOT exist:**
+
+- Display options:
+  ```
+  Options for Phase [N]:
+  1. See assumptions (/gsd:list-phase-assumptions [phase]) - What Claude thinks about this phase
+  2. Discuss context (/gsd:discuss-phase [phase]) - Gather your context through questions
+  3. Plan directly (/gsd:plan-phase [phase]) - Skip to planning
+  ```
+- Ask: "Which approach? (assumptions/discuss/plan)"
+- **If user responds "assumptions":**
+  ```
+  SlashCommand("/gsd:list-phase-assumptions [phase-number]")
+  ```
+- **If user responds "discuss":**
+  ```
+  SlashCommand("/gsd:discuss-phase [phase-number]")
+  ```
+- **If user responds "plan":**
+  ```
+  SlashCommand("/gsd:plan-phase [phase-number]")
+  ```
+
+**If all plans complete for current phase:**
+
+- Check if more phases exist in ROADMAP
+- If yes: Offer to plan next phase with `/gsd:plan-phase [next-phase]`
+- If no (milestone 100% complete): Offer to complete milestone
+  </step>
+
+<step name="edge_cases">
+**Handle edge cases:**
+
+- Phase complete but next phase not planned → offer `/gsd:plan-phase [next]`
+- All work complete → offer milestone completion
+- Blockers present → highlight before offering to continue
+- Handoff file exists → mention it, offer `/gsd:resume-work`
+  </step>
+
+</process>
+
+<success_criteria>
+
+- [ ] Rich context provided (recent work, decisions, issues)
+- [ ] Current position clear with visual progress
+- [ ] What's next clearly explained
+- [ ] Smart routing: /gsd:execute-plan if plan exists, /gsd:plan-phase if not
+- [ ] User confirms before any action
+- [ ] Seamless handoff to appropriate gsd command
+      </success_criteria>

package/commands/gsd/resume-work.md

@@ -0,0 +1,50 @@
+---
+description: Resume work from previous session with full context restoration
+allowed-tools:
+  - Read
+  - Bash
+  - Write
+  - AskUserQuestion
+  - SlashCommand
+---
+
+<!--
+DESIGN NOTE: Command + Workflow Pattern
+
+This command is a thin wrapper that routes to the resume-project workflow.
+All resumption logic lives in the workflow for maintainability.
+
+Architecture:
+- Command: resume-work.md - entry point only
+- Workflow: resume-project.md - all resumption logic
+-->
+
+<objective>
+Restore complete project context and resume work seamlessly from previous session.
+
+Routes to the resume-project workflow which handles:
+
+- STATE.md loading (or reconstruction if missing)
+- Checkpoint detection (.continue-here files)
+- Incomplete work detection (PLAN without SUMMARY)
+- Status presentation
+- Context-aware next action routing
+  </objective>
+
+<execution_context>
+@~/.claude/get-shit-done/workflows/resume-project.md
+</execution_context>
+
+<process>
+**Follow the resume-project workflow** from `@~/.claude/get-shit-done/workflows/resume-project.md`.
+
+The workflow handles all resumption logic including:
+
+1. Project existence verification
+2. STATE.md loading or reconstruction
+3. Checkpoint and incomplete work detection
+4. Visual status presentation
+5. Context-aware option offering (checks CONTEXT.md before suggesting plan vs discuss)
+6. Routing to appropriate next command
+7. Session continuity updates
+   </process>