Fix bin name and remove circular dependency
- bin: get-shit-done → get-shit-done-cc (matches package name) - Removed self-referencing dependency 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Lex Christopherson
201
node_modules/get-shit-done-cc/commands/gsd/add-phase.md
generated
vendored
Normal file
201
node_modules/get-shit-done-cc/commands/gsd/add-phase.md
generated
vendored
Normal file
@@ -0,0 +1,201 @@
|
||||
---
|
||||
description: Add phase to end of current milestone in roadmap
|
||||
argument-hint: <description>
|
||||
allowed-tools:
|
||||
- Read
|
||||
- Write
|
||||
- Bash
|
||||
---
|
||||
|
||||
<objective>
|
||||
Add a new integer phase to the end of the current milestone in the roadmap.
|
||||
|
||||
This command appends sequential phases to the current milestone's phase list, automatically calculating the next phase number based on existing phases.
|
||||
|
||||
Purpose: Add planned work discovered during execution that belongs at the end of current milestone.
|
||||
</objective>
|
||||
|
||||
<execution_context>
|
||||
@.planning/ROADMAP.md
|
||||
@.planning/STATE.md
|
||||
</execution_context>
|
||||
|
||||
<process>
|
||||
|
||||
<step name="parse_arguments">
|
||||
Parse the command arguments:
|
||||
- All arguments become the phase description
|
||||
- Example: `/gsd:add-phase Add authentication` → description = "Add authentication"
|
||||
- Example: `/gsd:add-phase Fix critical performance issues` → description = "Fix critical performance issues"
|
||||
|
||||
If no arguments provided:
|
||||
|
||||
```
|
||||
ERROR: Phase description required
|
||||
Usage: /gsd:add-phase <description>
|
||||
Example: /gsd:add-phase Add authentication system
|
||||
```
|
||||
|
||||
Exit.
|
||||
</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="find_current_milestone">
|
||||
Parse the roadmap to find the current milestone section:
|
||||
|
||||
1. Locate the "## Current Milestone:" heading
|
||||
2. Extract milestone name and version
|
||||
3. Identify all phases under this milestone (before next "---" separator or next milestone heading)
|
||||
4. Parse existing phase numbers (including decimals if present)
|
||||
|
||||
Example structure:
|
||||
|
||||
```
|
||||
## Current Milestone: v1.0 Foundation
|
||||
|
||||
### Phase 4: Focused Command System
|
||||
### Phase 5: Path Routing & Validation
|
||||
### Phase 6: Documentation & Distribution
|
||||
```
|
||||
|
||||
</step>
|
||||
|
||||
<step name="calculate_next_phase">
|
||||
Find the highest integer phase number in the current milestone:
|
||||
|
||||
1. Extract all phase numbers from phase headings (### Phase N:)
|
||||
2. Filter to integer phases only (ignore decimals like 4.1, 4.2)
|
||||
3. Find the maximum integer value
|
||||
4. Add 1 to get the next phase number
|
||||
|
||||
Example: If phases are 4, 5, 5.1, 6 → next is 7
|
||||
|
||||
Format as two-digit: `printf "%02d" $next_phase`
|
||||
</step>
|
||||
|
||||
<step name="generate_slug">
|
||||
Convert the phase description to a kebab-case slug:
|
||||
|
||||
```bash
|
||||
# Example transformation:
|
||||
# "Add authentication" → "add-authentication"
|
||||
# "Fix critical performance issues" → "fix-critical-performance-issues"
|
||||
|
||||
slug=$(echo "$description" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | sed 's/--*/-/g' | sed 's/^-//;s/-$//')
|
||||
```
|
||||
|
||||
Phase directory name: `{two-digit-phase}-{slug}`
|
||||
Example: `07-add-authentication`
|
||||
</step>
|
||||
|
||||
<step name="create_phase_directory">
|
||||
Create the phase directory structure:
|
||||
|
||||
```bash
|
||||
phase_dir=".planning/phases/${phase_num}-${slug}"
|
||||
mkdir -p "$phase_dir"
|
||||
```
|
||||
|
||||
Confirm: "Created directory: $phase_dir"
|
||||
</step>
|
||||
|
||||
<step name="update_roadmap">
|
||||
Add the new phase entry to the roadmap:
|
||||
|
||||
1. Find the insertion point (after last phase in current milestone, before "---" separator)
|
||||
2. Insert new phase heading:
|
||||
|
||||
```
|
||||
### Phase {N}: {Description}
|
||||
|
||||
**Goal:** [To be planned]
|
||||
**Depends on:** Phase {N-1}
|
||||
**Plans:** 0 plans
|
||||
|
||||
Plans:
|
||||
- [ ] TBD (run /gsd:plan-phase {N} to break down)
|
||||
|
||||
**Details:**
|
||||
[To be added during planning]
|
||||
```
|
||||
|
||||
3. Write updated roadmap back to file
|
||||
|
||||
Preserve all other content exactly (formatting, spacing, other phases).
|
||||
</step>
|
||||
|
||||
<step name="update_project_state">
|
||||
Update STATE.md to reflect the new phase:
|
||||
|
||||
1. Read `.planning/STATE.md`
|
||||
2. Under "## Current Position" → "**Next Phase:**" add reference to new phase
|
||||
3. Under "## Accumulated Context" → "### Roadmap Evolution" add entry:
|
||||
```
|
||||
- Phase {N} added: {description}
|
||||
```
|
||||
|
||||
If "Roadmap Evolution" section doesn't exist, create it.
|
||||
</step>
|
||||
|
||||
<step name="completion">
|
||||
Present completion summary:
|
||||
|
||||
```
|
||||
Phase {N} added to current milestone:
|
||||
- Description: {description}
|
||||
- Directory: .planning/phases/{phase-num}-{slug}/
|
||||
- Status: Not planned yet
|
||||
|
||||
Roadmap updated: {roadmap-path}
|
||||
Project state updated: .planning/STATE.md
|
||||
|
||||
What's next?
|
||||
1. Plan this phase: /gsd:plan-phase {N}
|
||||
2. Add another phase: /gsd:add-phase <description>
|
||||
3. Review roadmap: cat .planning/ROADMAP.md
|
||||
```
|
||||
|
||||
**If user selects option 1:**
|
||||
Invoke SlashCommand("/gsd:plan-phase {N}")
|
||||
|
||||
**If user selects option 2:**
|
||||
Invoke SlashCommand("/gsd:add-phase <description>")
|
||||
|
||||
Note: Commands are shown in options above so user can see what will run.
|
||||
</step>
|
||||
|
||||
</process>
|
||||
|
||||
<anti_patterns>
|
||||
|
||||
- Don't modify phases outside current milestone
|
||||
- Don't renumber existing phases
|
||||
- Don't use decimal numbering (that's /gsd:insert-phase)
|
||||
- Don't create plans yet (that's /gsd:plan-phase)
|
||||
- Don't commit changes (user decides when to commit)
|
||||
</anti_patterns>
|
||||
|
||||
<success_criteria>
|
||||
Phase addition is complete when:
|
||||
|
||||
- [ ] Phase directory created: `.planning/phases/{NN}-{slug}/`
|
||||
- [ ] Roadmap updated with new phase entry
|
||||
- [ ] STATE.md updated with roadmap evolution note
|
||||
- [ ] New phase appears at end of current milestone
|
||||
- [ ] Next phase number calculated correctly (ignoring decimals)
|
||||
- [ ] User informed of next steps
|
||||
</success_criteria>
|
||||
105
node_modules/get-shit-done-cc/commands/gsd/complete-milestone.md
generated
vendored
Normal file
105
node_modules/get-shit-done-cc/commands/gsd/complete-milestone.md
generated
vendored
Normal file
@@ -0,0 +1,105 @@
|
||||
---
|
||||
type: prompt
|
||||
description: Archive completed milestone and prepare for next version
|
||||
argument-hint: <version>
|
||||
allowed-tools:
|
||||
- Read
|
||||
- Write
|
||||
- Bash
|
||||
---
|
||||
|
||||
<objective>
|
||||
Mark milestone {{version}} complete, archive to milestones/, and update ROADMAP.md.
|
||||
|
||||
Purpose: Create historical record of shipped version, collapse completed work in roadmap, and prepare for next milestone.
|
||||
Output: Milestone archived, roadmap reorganized, git tagged.
|
||||
</objective>
|
||||
|
||||
<execution_context>
|
||||
**Load these files NOW (before proceeding):**
|
||||
|
||||
- @~/.claude/get-shit-done/workflows/complete-milestone.md (main workflow)
|
||||
- @~/.claude/get-shit-done/templates/milestone-archive.md (archive template)
|
||||
</execution_context>
|
||||
|
||||
<context>
|
||||
**Project files:**
|
||||
- `.planning/ROADMAP.md`
|
||||
- `.planning/STATE.md`
|
||||
- `.planning/PROJECT.md`
|
||||
|
||||
**User input:**
|
||||
|
||||
- Version: {{version}} (e.g., "1.0", "1.1", "2.0")
|
||||
</context>
|
||||
|
||||
<process>
|
||||
|
||||
**Follow complete-milestone.md workflow:**
|
||||
|
||||
1. **Verify readiness:**
|
||||
|
||||
- Check all phases in milestone have completed plans (SUMMARY.md exists)
|
||||
- Present milestone scope and stats
|
||||
- Wait for confirmation
|
||||
|
||||
2. **Gather stats:**
|
||||
|
||||
- Count phases, plans, tasks
|
||||
- Calculate git range, file changes, LOC
|
||||
- Extract timeline from git log
|
||||
- Present summary, confirm
|
||||
|
||||
3. **Extract accomplishments:**
|
||||
|
||||
- Read all phase SUMMARY.md files in milestone range
|
||||
- Extract 4-6 key accomplishments
|
||||
- Present for approval
|
||||
|
||||
4. **Archive milestone:**
|
||||
|
||||
- Create `.planning/milestones/v{{version}}-ROADMAP.md`
|
||||
- Extract full phase details from ROADMAP.md
|
||||
- Fill milestone-archive.md template
|
||||
- Update ROADMAP.md to one-line summary with link
|
||||
- Offer to create next milestone
|
||||
|
||||
5. **Update PROJECT.md:**
|
||||
|
||||
- Add "Current State" section with shipped version
|
||||
- Add "Next Milestone Goals" section
|
||||
- Archive previous content in `<details>` (if v1.1+)
|
||||
|
||||
6. **Commit and tag:**
|
||||
|
||||
- Stage: MILESTONES.md, PROJECT.md, ROADMAP.md, STATE.md, archive file
|
||||
- Commit: `chore: archive v{{version}} milestone`
|
||||
- Tag: `git tag -a v{{version}} -m "[milestone summary]"`
|
||||
- Ask about pushing tag
|
||||
|
||||
7. **Offer next steps:**
|
||||
- Plan next milestone
|
||||
- Archive planning
|
||||
- Done for now
|
||||
|
||||
</process>
|
||||
|
||||
<success_criteria>
|
||||
|
||||
- Milestone archived to `.planning/milestones/v{{version}}-ROADMAP.md`
|
||||
- ROADMAP.md collapsed to one-line entry
|
||||
- PROJECT.md updated with current state
|
||||
- Git tag v{{version}} created
|
||||
- Commit successful
|
||||
- User knows next steps
|
||||
</success_criteria>
|
||||
|
||||
<critical_rules>
|
||||
|
||||
- **Load workflow first:** Read complete-milestone.md before executing
|
||||
- **Verify completion:** All phases must have SUMMARY.md files
|
||||
- **User confirmation:** Wait for approval at verification gates
|
||||
- **Archive before collapsing:** Always create archive file before updating ROADMAP.md
|
||||
- **One-line summary:** Collapsed milestone in ROADMAP.md should be single line with link
|
||||
- **Context efficiency:** Archive keeps ROADMAP.md constant size
|
||||
</critical_rules>
|
||||
202
node_modules/get-shit-done-cc/commands/gsd/consider-issues.md
generated
vendored
Normal file
202
node_modules/get-shit-done-cc/commands/gsd/consider-issues.md
generated
vendored
Normal file
@@ -0,0 +1,202 @@
|
||||
---
|
||||
description: Review deferred issues with codebase context, close resolved ones, identify urgent ones
|
||||
allowed-tools:
|
||||
- Read
|
||||
- Bash
|
||||
- Grep
|
||||
- Glob
|
||||
- Edit
|
||||
- AskUserQuestion
|
||||
- SlashCommand
|
||||
---
|
||||
|
||||
<objective>
|
||||
Review all open issues from ISSUES.md with current codebase context. Identify which issues are resolved (can close), which are now urgent (should address), and which can continue waiting.
|
||||
|
||||
This prevents issue pile-up by providing a triage mechanism with codebase awareness.
|
||||
</objective>
|
||||
|
||||
<context>
|
||||
Issues file: !`cat .planning/ISSUES.md 2>/dev/null || echo "NO_ISSUES_FILE"`
|
||||
Project state: !`cat .planning/STATE.md 2>/dev/null | head -50`
|
||||
Current phase: !`grep -E "^Phase:" .planning/STATE.md 2>/dev/null || echo "UNKNOWN"`
|
||||
Roadmap phases: !`grep -E "^### Phase [0-9]" .planning/ROADMAP.md 2>/dev/null || echo "NO_ROADMAP"`
|
||||
</context>
|
||||
|
||||
<process>
|
||||
|
||||
<step name="verify">
|
||||
**Verify issues file exists:**
|
||||
|
||||
If no `.planning/ISSUES.md`:
|
||||
```
|
||||
No issues file found.
|
||||
|
||||
This means no enhancements have been deferred yet (Rule 5 hasn't triggered).
|
||||
|
||||
Nothing to review.
|
||||
```
|
||||
Exit.
|
||||
|
||||
If ISSUES.md exists but has no open issues (only template or empty "Open Enhancements"):
|
||||
```
|
||||
No open issues to review.
|
||||
|
||||
All clear - continue with current work.
|
||||
```
|
||||
Exit.
|
||||
</step>
|
||||
|
||||
<step name="parse">
|
||||
**Parse all open issues:**
|
||||
|
||||
Extract from "## Open Enhancements" section:
|
||||
- ISS number (ISS-001, ISS-002, etc.)
|
||||
- Brief description
|
||||
- Discovered phase/date
|
||||
- Type (Performance/Refactoring/UX/Testing/Documentation/Accessibility)
|
||||
- Description details
|
||||
- Effort estimate
|
||||
|
||||
Build list of issues to analyze.
|
||||
</step>
|
||||
|
||||
<step name="analyze">
|
||||
**For each open issue, perform codebase analysis:**
|
||||
|
||||
1. **Check if still relevant:**
|
||||
- Search codebase for related code/files mentioned in issue
|
||||
- If code no longer exists or was significantly refactored: likely resolved
|
||||
|
||||
2. **Check if accidentally resolved:**
|
||||
- Look for commits/changes that may have addressed this
|
||||
- Check if the enhancement was implemented as part of other work
|
||||
|
||||
3. **Assess current urgency:**
|
||||
- Is this blocking upcoming phases?
|
||||
- Has this become a pain point mentioned in recent summaries?
|
||||
- Is this now affecting code we're actively working on?
|
||||
|
||||
4. **Check natural fit:**
|
||||
- Does this align with an upcoming phase in the roadmap?
|
||||
- Would addressing it now touch the same files as current work?
|
||||
|
||||
**Categorize each issue:**
|
||||
- **Resolved** - Can be closed (code changed, no longer applicable)
|
||||
- **Urgent** - Should address before continuing (blocking or causing problems)
|
||||
- **Natural fit** - Good candidate for upcoming phase X
|
||||
- **Can wait** - Keep deferred, no change in status
|
||||
</step>
|
||||
|
||||
<step name="report">
|
||||
**Present categorized report:**
|
||||
|
||||
```
|
||||
# Issue Review
|
||||
|
||||
**Analyzed:** [N] open issues
|
||||
**Last reviewed:** [today's date]
|
||||
|
||||
## Resolved (can close)
|
||||
|
||||
### ISS-XXX: [description]
|
||||
**Reason:** [Why it's resolved - code changed, implemented elsewhere, no longer applicable]
|
||||
**Evidence:** [What you found - file changes, missing code, etc.]
|
||||
|
||||
[Repeat for each resolved issue, or "None" if none resolved]
|
||||
|
||||
---
|
||||
|
||||
## Urgent (should address now)
|
||||
|
||||
### ISS-XXX: [description]
|
||||
**Why urgent:** [What changed - blocking next phase, causing active problems, etc.]
|
||||
**Recommendation:** Insert plan before Phase [X] / Add to current phase
|
||||
**Effort:** [Quick/Medium/Substantial]
|
||||
|
||||
[Repeat for each urgent issue, or "None - all issues can wait" if none urgent]
|
||||
|
||||
---
|
||||
|
||||
## Natural Fit for Upcoming Work
|
||||
|
||||
### ISS-XXX: [description]
|
||||
**Fits with:** Phase [X] - [phase name]
|
||||
**Reason:** [Same files, same subsystem, natural inclusion]
|
||||
|
||||
[Repeat for each, or "None" if no natural fits]
|
||||
|
||||
---
|
||||
|
||||
## Can Wait (no change)
|
||||
|
||||
### ISS-XXX: [description]
|
||||
**Status:** Still valid, not urgent, keep deferred
|
||||
|
||||
[Repeat for each, or list ISS numbers if many]
|
||||
```
|
||||
</step>
|
||||
|
||||
<step name="offer_actions">
|
||||
**Offer batch actions:**
|
||||
|
||||
Based on analysis, present options:
|
||||
|
||||
```
|
||||
## Actions
|
||||
|
||||
What would you like to do?
|
||||
```
|
||||
|
||||
Use AskUserQuestion with appropriate options based on findings:
|
||||
|
||||
**If resolved issues exist:**
|
||||
- "Close resolved issues" - Move to Closed Enhancements section
|
||||
- "Review each first" - Show details before closing
|
||||
|
||||
**If urgent issues exist:**
|
||||
- "Insert urgent phase" - Create phase to address urgent issues (/gsd:insert-phase)
|
||||
- "Add to current plan" - Include in next plan being created
|
||||
- "Defer anyway" - Keep as-is despite urgency
|
||||
|
||||
**If natural fits exist:**
|
||||
- "Note for phase planning" - Will be picked up during /gsd:plan-phase
|
||||
- "Add explicit reminder" - Update issue with "Include in Phase X"
|
||||
|
||||
**Always include:**
|
||||
- "Done for now" - Exit without changes
|
||||
</step>
|
||||
|
||||
<step name="execute_actions">
|
||||
**Execute selected actions:**
|
||||
|
||||
**If closing resolved issues:**
|
||||
1. Read current ISSUES.md
|
||||
2. For each resolved issue:
|
||||
- Remove from "## Open Enhancements"
|
||||
- Add to "## Closed Enhancements" with resolution note:
|
||||
```
|
||||
### ISS-XXX: [description]
|
||||
**Resolved:** [date] - [reason]
|
||||
```
|
||||
3. Write updated ISSUES.md
|
||||
4. Update STATE.md deferred issues count
|
||||
|
||||
**If inserting urgent phase:**
|
||||
- Invoke: `SlashCommand("/gsd:insert-phase [after-phase] Address urgent issues ISS-XXX, ISS-YYY")`
|
||||
|
||||
**If noting for phase planning:**
|
||||
- Update issue's "Suggested phase" field with specific phase number
|
||||
- These will be picked up by /gsd:plan-phase workflow
|
||||
</step>
|
||||
|
||||
</process>
|
||||
|
||||
<success_criteria>
|
||||
- [ ] All open issues analyzed against current codebase
|
||||
- [ ] Each issue categorized (resolved/urgent/natural-fit/can-wait)
|
||||
- [ ] Clear reasoning provided for each categorization
|
||||
- [ ] Actions offered based on findings
|
||||
- [ ] ISSUES.md updated if user takes action
|
||||
- [ ] STATE.md updated if issue count changes
|
||||
</success_criteria>
|
||||
45
node_modules/get-shit-done-cc/commands/gsd/discuss-milestone.md
generated
vendored
Normal file
45
node_modules/get-shit-done-cc/commands/gsd/discuss-milestone.md
generated
vendored
Normal file
@@ -0,0 +1,45 @@
|
||||
---
|
||||
description: Gather context for next milestone through adaptive questioning
|
||||
---
|
||||
|
||||
<objective>
|
||||
Use adaptive questioning to gather comprehensive milestone context before creating a new milestone.
|
||||
|
||||
Purpose: After completing a milestone, discuss the scope and focus of the next milestone before diving into phase creation. Builds understanding of goals, constraints, priorities, and lessons learned.
|
||||
Output: Context gathered, then routes to /gsd:new-milestone
|
||||
</objective>
|
||||
|
||||
<execution_context>
|
||||
@~/.claude/get-shit-done/workflows/discuss-milestone.md
|
||||
</execution_context>
|
||||
|
||||
<context>
|
||||
**Load project state first:**
|
||||
@.planning/STATE.md
|
||||
|
||||
**Load roadmap:**
|
||||
@.planning/ROADMAP.md
|
||||
|
||||
**Load milestones (if exists):**
|
||||
@.planning/MILESTONES.md
|
||||
</context>
|
||||
|
||||
<process>
|
||||
1. Verify previous milestone complete (or acknowledge active milestone)
|
||||
2. Present context from previous milestone (accomplishments, phase count)
|
||||
3. Follow discuss-milestone.md workflow:
|
||||
- Ask about milestone theme/focus
|
||||
- Ask about scope (estimated phases)
|
||||
- Ask about constraints and priorities
|
||||
- Ask about lessons from previous milestone
|
||||
- Present decision gate (ready / ask more / let me add context)
|
||||
4. Hand off to /gsd:new-milestone with gathered context
|
||||
</process>
|
||||
|
||||
<success_criteria>
|
||||
|
||||
- Project state loaded and presented
|
||||
- Previous milestone context summarized
|
||||
- Milestone scope gathered through adaptive questioning
|
||||
- Context handed off to /gsd:new-milestone
|
||||
</success_criteria>
|
||||
47
node_modules/get-shit-done-cc/commands/gsd/discuss-phase.md
generated
vendored
Normal file
47
node_modules/get-shit-done-cc/commands/gsd/discuss-phase.md
generated
vendored
Normal file
@@ -0,0 +1,47 @@
|
||||
---
|
||||
description: Gather phase context through adaptive questioning before planning
|
||||
argument-hint: "[phase]"
|
||||
---
|
||||
|
||||
<objective>
|
||||
Use adaptive questioning to gather comprehensive phase context before planning.
|
||||
|
||||
Purpose: Build deep understanding of objectives, constraints, risks, success indicators, and codebase state through structured intake flow. Creates CONTEXT.md file that informs high-quality planning.
|
||||
Output: {phase}-CONTEXT.md in phase directory with complete context documentation
|
||||
</objective>
|
||||
|
||||
<execution_context>
|
||||
@~/.claude/get-shit-done/workflows/discuss-phase.md
|
||||
@~/.claude/get-shit-done/templates/context.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. Check if CONTEXT.md already exists (offer to update if yes)
|
||||
4. Follow discuss-phase.md workflow:
|
||||
- Present initial context from roadmap
|
||||
- Analyze gaps in: objectives, constraints, risks, success indicators, codebase context
|
||||
- Ask 2-4 questions about genuine gaps (skip what roadmap provides)
|
||||
- Present decision gate (ready / ask more / let me add context)
|
||||
- Create CONTEXT.md using template
|
||||
5. Offer next steps (typically: plan the phase)
|
||||
</process>
|
||||
|
||||
<success_criteria>
|
||||
|
||||
- Phase validated against roadmap
|
||||
- Context gathered through adaptive questioning
|
||||
- CONTEXT.md created in phase directory
|
||||
- User knows next steps (plan phase, review context, or done)
|
||||
</success_criteria>
|
||||
109
node_modules/get-shit-done-cc/commands/gsd/execute-plan.md
generated
vendored
Normal file
109
node_modules/get-shit-done-cc/commands/gsd/execute-plan.md
generated
vendored
Normal file
@@ -0,0 +1,109 @@
|
||||
---
|
||||
description: Execute a PLAN.md file
|
||||
argument-hint: "[path-to-PLAN.md]"
|
||||
allowed-tools:
|
||||
- Read
|
||||
- Write
|
||||
- Edit
|
||||
- Bash
|
||||
- Glob
|
||||
- Grep
|
||||
- Task
|
||||
- AskUserQuestion
|
||||
- SlashCommand
|
||||
---
|
||||
|
||||
<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>
|
||||
266
node_modules/get-shit-done-cc/commands/gsd/help.md
generated
vendored
Normal file
266
node_modules/get-shit-done-cc/commands/gsd/help.md
generated
vendored
Normal file
@@ -0,0 +1,266 @@
|
||||
---
|
||||
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`
|
||||
|
||||
### Issue Management
|
||||
|
||||
**`/gsd:consider-issues`**
|
||||
Review deferred issues with codebase context.
|
||||
|
||||
- Analyzes all open issues against current codebase state
|
||||
- Identifies resolved issues (can close)
|
||||
- Identifies urgent issues (should address now)
|
||||
- Identifies natural fits for upcoming phases
|
||||
- Offers batch actions (close, insert phase, note for planning)
|
||||
|
||||
Usage: `/gsd:consider-issues`
|
||||
|
||||
### 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
|
||||
├── ISSUES.md # Deferred enhancements (created when needed)
|
||||
├── 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>
|
||||
218
node_modules/get-shit-done-cc/commands/gsd/insert-phase.md
generated
vendored
Normal file
218
node_modules/get-shit-done-cc/commands/gsd/insert-phase.md
generated
vendored
Normal file
@@ -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>
|
||||
49
node_modules/get-shit-done-cc/commands/gsd/list-phase-assumptions.md
generated
vendored
Normal file
49
node_modules/get-shit-done-cc/commands/gsd/list-phase-assumptions.md
generated
vendored
Normal file
@@ -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>
|
||||
58
node_modules/get-shit-done-cc/commands/gsd/new-milestone.md
generated
vendored
Normal file
58
node_modules/get-shit-done-cc/commands/gsd/new-milestone.md
generated
vendored
Normal file
@@ -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>
|
||||
177
node_modules/get-shit-done-cc/commands/gsd/new-project.md
generated
vendored
Normal file
177
node_modules/get-shit-done-cc/commands/gsd/new-project.md
generated
vendored
Normal file
@@ -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>
|
||||
```
|
||||
123
node_modules/get-shit-done-cc/commands/gsd/pause-work.md
generated
vendored
Normal file
123
node_modules/get-shit-done-cc/commands/gsd/pause-work.md
generated
vendored
Normal file
@@ -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>
|
||||
```
|
||||
60
node_modules/get-shit-done-cc/commands/gsd/plan-phase.md
generated
vendored
Normal file
60
node_modules/get-shit-done-cc/commands/gsd/plan-phase.md
generated
vendored
Normal file
@@ -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>
|
||||
182
node_modules/get-shit-done-cc/commands/gsd/progress.md
generated
vendored
Normal file
182
node_modules/get-shit-done-cc/commands/gsd/progress.md
generated
vendored
Normal file
@@ -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>
|
||||
50
node_modules/get-shit-done-cc/commands/gsd/resume-work.md
generated
vendored
Normal file
50
node_modules/get-shit-done-cc/commands/gsd/resume-work.md
generated
vendored
Normal file
@@ -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>
|
||||
Reference in New Issue
Block a user