get-shit-done-cc 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Lex Christopherson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,192 @@
+# Get Shit Done
+
+**THE meta-prompting and context engineering system for Claude Code.**
+
+Vibecoding has a bad reputation. You describe what you want, AI generates code, and you get inconsistent garbage that falls apart at scale.
+
+GSD fixes that. It's the context engineering layer that makes Claude Code reliable. Describe your idea, let the system extract everything it needs to know, and then let Claude Code get to work.
+
+THIS is how you vibecode and actually get shit done.
+
+_Warning: Not for people who enjoy inconsistent and sloppy results._
+
+---
+
+## Why I Built This
+
+I'm a solo developer. I don't write code — Claude Code does.
+
+Other spec-driven development tools exist; BMAD, Speckit... But they all seem to make things way more complicated than they need to be (sprint ceremonies, story points, stakeholder syncs, retrospectives, Jira workflows) or lack real big picture understanding of what you're building. I'm not a 50-person software company. I don't want to play enterprise theater. I'm just a creative person trying to build great things that work.
+
+So I built GSD. The complexity is in the system, not in your workflow. Behind the scenes: context engineering, XML prompt formatting, subagent orchestration, state management. What you see: a few commands that just work.
+
+I wanted to spend my time having ideas and seeing them through to implementation — not babysitting Claude. Now I can say "go," put it in YOLO mode, and go to the beach. The system gives Claude everything it needs to do the work _and_ verify it. I trust the workflow. It just does a good job.
+
+That's what this is. No enterprise roleplay bullshit. Just an incredibly effective system for building cool stuff consistently using Claude Code.
+
+— TÂCHES
+
+---
+
+## How It Works
+
+### 1. Start with an idea
+
+```
+/gsd:new-project
+```
+
+The system asks questions. Keeps asking until it has everything — your goals, constraints, tech preferences, edge cases. You go back and forth until the idea is fully captured.
+
+### 2. Initialize the project
+
+Your idea becomes:
+
+- **PROJECT.md** - Project vision (~50 lines)
+- **ROADMAP.md** - Phases from start to finish
+- **STATE.md** - Living memory that persists across sessions
+
+### 3. Plan and execute phases
+
+```
+/gsd:plan-phase 1      # System creates atomic task plans
+/gsd:execute-plan      # Subagent implements autonomously
+```
+
+Each phase breaks into 2-3 atomic tasks. Each task runs in a fresh subagent context — 200k tokens purely for implementation, zero degradation.
+
+### 4. Ship and iterate
+
+```
+/gsd:complete-milestone   # Archive v1, prep for v2
+/gsd:add-phase            # Append new work
+/gsd:insert-phase 2       # Slip urgent work between phases
+```
+
+Ship your MVP in a day. Add features. Insert hotfixes. The system stays modular — you're never stuck.
+
+---
+
+## Why It Works
+
+### Context Engineering
+
+Claude Code is incredibly powerful _if_ you give it the context it needs. Most people don't.
+
+GSD handles it for you:
+
+| File         | What it does                                           |
+| ------------ | ------------------------------------------------------ |
+| `PROJECT.md` | Project vision, always loaded                          |
+| `ROADMAP.md` | Where you're going, what's done                        |
+| `STATE.md`   | Decisions, blockers, position — memory across sessions |
+| `PLAN.md`    | Atomic task with XML structure, verification steps     |
+| `SUMMARY.md` | What happened, what changed, committed to history      |
+
+Size limits based on where Claude's quality degrades. Stay under, get consistent excellence.
+
+### XML Prompt Formatting
+
+Every plan is structured XML optimized for Claude:
+
+```xml
+<task type="auto">
+  <name>Create login endpoint</name>
+  <files>src/app/api/auth/login/route.ts</files>
+  <action>
+    Use jose for JWT (not jsonwebtoken - CommonJS issues).
+    Validate credentials against users table.
+    Return httpOnly cookie on success.
+  </action>
+  <verify>curl -X POST localhost:3000/api/auth/login returns 200 + Set-Cookie</verify>
+  <done>Valid credentials return cookie, invalid return 401</done>
+</task>
+```
+
+Precise instructions. No guessing. Verification built in.
+
+### Subagent Execution
+
+Plans run in fresh contexts:
+
+- 0% overhead to start
+- Maximum quality, zero degradation
+- Walk away, come back to completed work
+
+### Clean Git History
+
+Every task: atomic commit, clear message, summary documenting outcomes. Maintainable history you can trace.
+
+### Modular by Design
+
+- Add phases to current milestone
+- Insert urgent work between phases
+- Complete milestones and start fresh
+- Adjust plans without rebuilding everything
+
+You're never locked in. The system adapts.
+
+---
+
+## Commands
+
+| Command                           | What it does                                                  |
+| --------------------------------- | ------------------------------------------------------------- |
+| `/gsd:new-project`                | Extract your idea through questions, create project structure |
+| `/gsd:plan-phase [N]`             | Generate task plans for phase                                 |
+| `/gsd:execute-plan`               | Run plan via subagent                                         |
+| `/gsd:progress`                   | Where am I? What's next?                                      |
+| `/gsd:complete-milestone`         | Ship it, prep next version                                    |
+| `/gsd:discuss-milestone`          | Gather context for next milestone                             |
+| `/gsd:new-milestone [name]`       | Create new milestone with phases                              |
+| `/gsd:add-phase`                  | Append phase to roadmap                                       |
+| `/gsd:insert-phase [N]`           | Insert urgent work                                            |
+| `/gsd:discuss-phase [N]`          | Gather context before planning                                |
+| `/gsd:list-phase-assumptions [N]` | See what Claude thinks before you correct it                  |
+| `/gsd:pause-work`                 | Create handoff file when stopping mid-phase                   |
+| `/gsd:resume-work`                | Restore from last session                                     |
+| `/gsd:help`                       | Show all commands and usage guide                             |
+
+---
+
+## Who This Is For
+
+People who want to vibecode and have it actually work.
+
+Anyone who wants to clearly describe what they want, trust the system to build it, and go live their life.
+
+Not for people who enjoy inconsistent and sloppy results.
+
+---
+
+## Installation
+
+Clone the repo and run the installer for your platform:
+
+**Mac / Linux:**
+
+```bash
+git clone https://github.com/glittercowboy/get-shit-done.git
+cd get-shit-done
+./install/mac/install.sh    # or ./install/linux/install.sh
+```
+
+**Windows (PowerShell):**
+
+```powershell
+git clone https://github.com/glittercowboy/get-shit-done.git
+cd get-shit-done
+powershell -ExecutionPolicy Bypass -File install\windows\install.ps1
+```
+
+Verify: `/gsd:help`
+
+---
+
+## License
+
+MIT License. See [LICENSE](LICENSE) for details.
+
+---
+
+**Claude Code is powerful. GSD gives it the context and the systematic consistency to prove it.**

package/bin/install.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Colors
+const cyan = '\x1b[36m';
+const green = '\x1b[32m';
+const dim = '\x1b[2m';
+const reset = '\x1b[0m';
+
+// Get version from package.json
+const pkg = require('../package.json');
+
+const banner = `
+${cyan}   ██████╗ ███████╗██████╗
+  ██╔════╝ ██╔════╝██╔══██╗
+  ██║  ███╗███████╗██║  ██║
+  ██║   ██║╚════██║██║  ██║
+  ╚██████╔╝███████║██████╔╝
+   ╚═════╝ ╚══════╝╚═════╝${reset}
+
+  Get Shit Done ${dim}v${pkg.version}${reset}
+  A meta-prompting, context engineering and spec-driven
+  development system for Claude Code by TÂCHES.
+`;
+
+console.log(banner);
+
+// Paths
+const src = path.join(__dirname, '..');
+const claudeDir = path.join(os.homedir(), '.claude');
+const commandsDir = path.join(claudeDir, 'commands');
+
+// Create directories
+fs.mkdirSync(commandsDir, { recursive: true });
+
+// Copy commands/gsd
+const gsdSrc = path.join(src, 'commands', 'gsd');
+const gsdDest = path.join(commandsDir, 'gsd');
+fs.cpSync(gsdSrc, gsdDest, { recursive: true });
+console.log(`  ${green}✓${reset} Installed commands/gsd`);
+
+// Copy get-shit-done
+const skillSrc = path.join(src, 'get-shit-done');
+const skillDest = path.join(claudeDir, 'get-shit-done');
+fs.cpSync(skillSrc, skillDest, { recursive: true });
+console.log(`  ${green}✓${reset} Installed get-shit-done`);
+
+console.log(`
+  ${green}Done!${reset} Run ${cyan}/gsd:help${reset} to get started.
+`);

package/commands/gsd/add-phase.md

@@ -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>

package/commands/gsd/complete-milestone.md

@@ -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>

package/commands/gsd/discuss-milestone.md

@@ -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>

package/commands/gsd/discuss-phase.md

@@ -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>