get-shit-done-cc 1.2.12 → 1.3.0

package/README.md

@@ -52,14 +52,13 @@ That's what this is. No enterprise roleplay bullshit. Just an incredibly effecti
 
 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. Creates **PROJECT.md**.
 
-### 2. Research (optional) and create roadmap
+### 2. Create roadmap
 
 ```
-/gsd:research-project   # For niche domains (3D, audio, shaders)
 /gsd:create-roadmap     # Create phases and state tracking
 ```
 
-For complex domains, research spawns subagents to discover ecosystem patterns before planning. Then roadmap creation produces:
+Roadmap creation produces:
 
 - **ROADMAP.md** - Phases from start to finish
 - **STATE.md** - Living memory that persists across sessions
@@ -156,7 +155,6 @@ You're never locked in. The system adapts.
 | Command                           | What it does                                                  |
 | --------------------------------- | ------------------------------------------------------------- |
 | `/gsd:new-project`                | Extract your idea through questions, create PROJECT.md        |
-| `/gsd:research-project`           | Research domain ecosystem before roadmap (optional)           |
 | `/gsd:create-roadmap`             | Create roadmap and state tracking                             |
 | `/gsd:plan-phase [N]`             | Generate task plans for phase                                 |
 | `/gsd:execute-plan`               | Run plan via subagent                                         |

package/commands/gsd/add-phase.md

@@ -163,16 +163,25 @@ Phase {N} added to current milestone:
 Roadmap updated: {roadmap-path}
 Project state updated: .planning/STATE.md
 
-## To Continue
+---
+
+## ▶ Next Up
+
+**Phase {N}: {description}**
 
-Run `/clear`, then paste:
 ```
 /gsd:plan-phase {N}
 ```
 
-Other options:
-- Add another phase: `/gsd:add-phase <description>`
-- Review roadmap: `cat .planning/ROADMAP.md`
+<sub>`/clear` first → fresh context window</sub>
+
+---
+
+**Also available:**
+- `/gsd:add-phase <description>` — add another phase
+- Review roadmap
+
+---
 ```
 </step>
 

package/commands/gsd/create-roadmap.md

@@ -9,11 +9,9 @@ allowed-tools:
 ---
 
 <objective>
-Create project roadmap, optionally incorporating research findings from /gsd:research-project.
+Create project roadmap with phase breakdown.
 
-Roadmaps define the phase breakdown - what work happens in what order. This command can be used:
-1. After /gsd:new-project (without research)
-2. After /gsd:research-project (with domain research incorporated)
+Roadmaps define what work happens in what order. Run after /gsd:new-project.
 </objective>
 
 <execution_context>
@@ -57,46 +55,12 @@ If "Cancel": Exit
 If "Replace": Continue with workflow
 </step>
 
-<step name="check_research">
-Check for project research:
-
-```bash
-ls .planning/research/*.md 2>/dev/null
-```
-
-**If research found:**
-Load and summarize each research file:
-- ecosystem.md → Key libraries/frameworks recommended
-- architecture.md → Architectural patterns to follow
-- pitfalls.md → Top 2-3 critical pitfalls to avoid
-- standards.md → Standards and conventions to follow
-
-Present summary:
-```
-Found project research:
-
-Ecosystem: [key libraries/frameworks]
-Architecture: [key patterns]
-Pitfalls: [top 2-3 to avoid]
-Standards: [key conventions]
-
-This will inform phase structure.
-```
-
-**If no research found:**
-```
-No project research found.
-Creating roadmap based on PROJECT.md alone.
-(Optional: Run /gsd:research-project first for niche/complex domains)
-```
-</step>
-
 <step name="create_roadmap">
 Follow the create-roadmap.md workflow starting from detect_domain step.
 
 The workflow handles:
 - Domain expertise detection
-- Phase identification (informed by research if present)
+- Phase identification
 - Research flags for each phase
 - Confirmation gates (respecting config mode)
 - ROADMAP.md creation
@@ -112,19 +76,26 @@ Roadmap created:
 - State: .planning/STATE.md
 - [N] phases defined
 
-## To Continue
+---
 
-Run `/clear`, then paste one of:
+## ▶ Next Up
 
-**To discuss Phase 1 context first:**
-```
-/gsd:discuss-phase 1
-```
+**Phase 1: [Name]** — [Goal from ROADMAP.md]
 
-**To plan Phase 1 directly:**
 ```
 /gsd:plan-phase 1
 ```
+
+<sub>`/clear` first → fresh context window</sub>
+
+---
+
+**Also available:**
+- `/gsd:discuss-phase 1` — gather context first
+- `/gsd:research-phase 1` — investigate unknowns
+- Review roadmap
+
+---
 ```
 </step>
 
@@ -138,7 +109,6 @@ Run `/clear`, then paste one of:
 
 <success_criteria>
 - [ ] PROJECT.md validated
-- [ ] Research incorporated if present
 - [ ] ROADMAP.md created with phases
 - [ ] STATE.md initialized
 - [ ] Phase directories created

package/commands/gsd/help.md

@@ -21,10 +21,9 @@ Output ONLY the reference content below. Do NOT add:
 ## Quick Start
 
 1. `/gsd:new-project` - Initialize project with brief
-2. `/gsd:research-project` - (Optional) Research domain ecosystem
-3. `/gsd:create-roadmap` - Create roadmap and phases
-4. `/gsd:plan-phase <number>` - Create detailed plan for first phase
-5. `/gsd:execute-plan <path>` - Execute the plan
+2. `/gsd:create-roadmap` - Create roadmap and phases
+3. `/gsd:plan-phase <number>` - Create detailed plan for first phase
+4. `/gsd:execute-plan <path>` - Execute the plan
 
 ## Core Workflow
 
@@ -44,23 +43,12 @@ Initialize new project with brief and configuration.
 
 Usage: `/gsd:new-project`
 
-**`/gsd:research-project`**
-Research domain ecosystem before creating roadmap.
-
-- Spawns batched subagents to research domain patterns
-- Creates `.planning/research/` with ecosystem findings
-- Optional step for niche/complex domains
-- Run after new-project, before create-roadmap
-
-Usage: `/gsd:research-project`
-
 **`/gsd:create-roadmap`**
 Create roadmap and state tracking for initialized project.
 
 - Creates `.planning/ROADMAP.md` (phase breakdown)
 - Creates `.planning/STATE.md` (project memory)
 - Creates `.planning/phases/` directories
-- Incorporates research findings if present
 
 Usage: `/gsd:create-roadmap`
 
@@ -267,16 +255,6 @@ Change anytime by editing `.planning/config.json`
 /gsd:execute-plan .planning/phases/01-foundation/01-01-PLAN.md
 ```
 
-**Building something in a niche domain (3D, games, audio, shaders):**
-
-```
-/gsd:new-project
-/gsd:research-project  # Research domain ecosystem before roadmap
-/gsd:create-roadmap    # Roadmap incorporates research findings
-/gsd:plan-phase 1
-/gsd:execute-plan .planning/phases/01-foundation/01-01-PLAN.md
-```
-
 **Resuming work after a break:**
 
 ```

package/commands/gsd/insert-phase.md

@@ -182,16 +182,25 @@ Phase {decimal_phase} inserted after Phase {after_phase}:
 Roadmap updated: {roadmap-path}
 Project state updated: .planning/STATE.md
 
-## To Continue
+---
+
+## ▶ Next Up
+
+**Phase {decimal_phase}: {description}** — urgent insertion
 
-Run `/clear`, then paste:
 ```
 /gsd:plan-phase {decimal_phase}
 ```
 
-Other options:
+<sub>`/clear` first → fresh context window</sub>
+
+---
+
+**Also available:**
 - Review insertion impact: Check if Phase {next_integer} dependencies still make sense
-- Review roadmap: `cat .planning/ROADMAP.md`
+- Review roadmap
+
+---
 ```
 </step>
 

package/commands/gsd/map-codebase.md

@@ -0,0 +1,85 @@
+---
+description: Analyze codebase with parallel Explore agents to produce .planning/codebase/ documents
+argument-hint: "[optional: specific area to map, e.g., 'api' or 'auth']"
+allowed-tools:
+  - Read
+  - Bash
+  - Glob
+  - Grep
+  - Write
+  - Task
+---
+
+<objective>
+Analyze existing codebase using parallel Explore agents to produce structured codebase documents.
+
+This command spawns multiple Explore agents to analyze different aspects of the codebase in parallel, each with fresh context. Each agent produces focused documentation under 100 lines.
+
+Output: .planning/codebase/ folder with 7 structured documents about the codebase state.
+</objective>
+
+<execution_context>
+@~/.claude/get-shit-done/workflows/map-codebase.md
+@~/.claude/get-shit-done/templates/codebase/stack.md
+@~/.claude/get-shit-done/templates/codebase/architecture.md
+@~/.claude/get-shit-done/templates/codebase/structure.md
+@~/.claude/get-shit-done/templates/codebase/conventions.md
+@~/.claude/get-shit-done/templates/codebase/testing.md
+@~/.claude/get-shit-done/templates/codebase/integrations.md
+@~/.claude/get-shit-done/templates/codebase/concerns.md
+</execution_context>
+
+<context>
+Focus area: $ARGUMENTS (optional - if provided, tells agents to focus on specific subsystem)
+
+**Load project state if exists:**
+Check for .planning/STATE.md - loads context if project already initialized
+
+**This command can run:**
+- Before /gsd:new-project (brownfield codebases) - creates codebase map first
+- After /gsd:new-project (greenfield codebases) - updates codebase map as code evolves
+- Anytime to refresh codebase understanding
+</context>
+
+<when_to_use>
+**Use map-codebase for:**
+- Brownfield projects before initialization (understand existing code first)
+- Refreshing codebase map after significant changes
+- Onboarding to an unfamiliar codebase
+- Before major refactoring (understand current state)
+- When STATE.md references outdated codebase info
+
+**Skip map-codebase for:**
+- Greenfield projects with no code yet (nothing to map)
+- Trivial codebases (<5 files)
+</when_to_use>
+
+<process>
+1. Check if .planning/codebase/ already exists (offer to refresh or skip)
+2. Create .planning/codebase/ directory structure
+3. Spawn 4 parallel Explore agents to analyze codebase:
+   - Agent 1: Stack + Integrations (technology focus)
+   - Agent 2: Architecture + Structure (organization focus)
+   - Agent 3: Conventions + Testing (quality focus)
+   - Agent 4: Concerns (issues focus)
+4. Wait for all agents to complete, collect findings
+5. Write 7 codebase documents using templates:
+   - STACK.md - Languages, frameworks, key dependencies
+   - ARCHITECTURE.md - System design, patterns, data flow
+   - STRUCTURE.md - Directory layout, module organization
+   - CONVENTIONS.md - Code style, naming, patterns
+   - TESTING.md - Test structure, coverage, practices
+   - INTEGRATIONS.md - APIs, databases, external services
+   - CONCERNS.md - Technical debt, risks, issues
+6. Verify each document is under 100 lines (summarize if needed)
+7. Offer next steps (typically: /gsd:new-project or /gsd:plan-phase)
+</process>
+
+<success_criteria>
+- [ ] .planning/codebase/ directory created
+- [ ] All 7 codebase documents written
+- [ ] Each document under 100 lines
+- [ ] Documents follow template structure
+- [ ] Parallel agents completed without errors
+- [ ] User knows next steps
+</success_criteria>

package/commands/gsd/new-project.md

@@ -44,7 +44,40 @@ Creates `.planning/` with PROJECT.md and config.json.
    fi
    ```
 
-   **You MUST run both bash commands above using the Bash tool before proceeding.**
+3. **Detect existing code (brownfield detection):**
+   ```bash
+   # Check for existing code files
+   CODE_FILES=$(find . -name "*.ts" -o -name "*.js" -o -name "*.py" -o -name "*.go" -o -name "*.rs" -o -name "*.swift" -o -name "*.java" 2>/dev/null | grep -v node_modules | grep -v .git | head -20)
+   HAS_PACKAGE=$([ -f package.json ] || [ -f requirements.txt ] || [ -f Cargo.toml ] || [ -f go.mod ] || [ -f Package.swift ] && echo "yes")
+   HAS_CODEBASE_MAP=$([ -d .planning/codebase ] && echo "yes")
+   ```
+
+   **You MUST run all bash commands above using the Bash tool before proceeding.**
+</step>
+
+<step name="brownfield_offer">
+**If existing code detected and .planning/codebase/ doesn't exist:**
+
+Check the results from setup step:
+- If `CODE_FILES` is non-empty OR `HAS_PACKAGE` is "yes"
+- AND `HAS_CODEBASE_MAP` is NOT "yes"
+
+Use AskUserQuestion:
+- header: "Existing Code"
+- question: "I detected existing code in this directory. Would you like to map the codebase first?"
+- options:
+  - "Map codebase first" - Run /gsd:map-codebase to understand existing architecture (Recommended)
+  - "Skip mapping" - Proceed with project initialization
+
+**If "Map codebase first":**
+```
+Run `/gsd:map-codebase` first, then return to `/gsd:new-project`
+```
+Exit command.
+
+**If "Skip mapping":** Continue to question step.
+
+**If no existing code detected OR codebase already mapped:** Continue to question step.
 </step>
 
 <step name="question">
@@ -133,27 +166,28 @@ EOF
 </step>
 
 <step name="done">
-Present completion inline (not as a question):
+Present completion with next steps (see ~/.claude/get-shit-done/references/continuation-format.md):
 
 ```
 Project initialized:
 
 - Project: .planning/PROJECT.md
 - Config: .planning/config.json (mode: [chosen mode])
+[If .planning/codebase/ exists:] - Codebase: .planning/codebase/ (7 documents)
 
-## To Continue
+---
 
-Run `/clear`, then paste one of:
+## ▶ Next Up
 
-**For niche/complex domains (recommended):**
-```
-/gsd:research-project
-```
+**[Project Name]** — create roadmap
 
-**To skip research and go straight to planning:**
 ```
 /gsd:create-roadmap
 ```
+
+<sub>`/clear` first → fresh context window</sub>
+
+---
 ```
 </step>
 

package/commands/gsd/plan-phase.md

@@ -39,6 +39,9 @@ Phase number: $ARGUMENTS (optional - auto-detects next unplanned phase if not pr
 
 **Load phase context if exists (created by /gsd:discuss-phase):**
 Check for and read `.planning/phases/XX-name/{phase}-CONTEXT.md` - contains research findings, clarifications, and decisions from phase discussion.
+
+**Load codebase context if exists:**
+Check for `.planning/codebase/` and load relevant documents based on phase type.
 </context>
 
 <process>

package/commands/gsd/progress.md

@@ -98,14 +98,21 @@ Check if `{phase}-{plan}-PLAN.md` exists for that number.
 
 - Read its `<objective>` section
 - Show: "Ready to execute: [path] - [objective summary]"
-- Display:
+- Display (see ~/.claude/get-shit-done/references/continuation-format.md):
   ```
-  ## To Continue
+  ---
+
+  ## ▶ Next Up
+
+  **{phase}-{plan}: [Plan Name]** — [objective summary from PLAN.md]
 
-  Run `/clear`, then paste:
   ```
   /gsd:execute-plan [full-path-to-PLAN.md]
   ```
+
+  <sub>`/clear` first → fresh context window</sub>
+
+  ---
   ```
 
 **If PLAN.md does NOT exist:**
@@ -119,36 +126,45 @@ Check if `{phase}-{plan}-PLAN.md` exists for that number.
 - Display: "✓ Context gathered, ready to plan"
 - Display:
   ```
-  ## To Continue
+  ---
+
+  ## ▶ Next Up
+
+  **Phase [N]: [Name]** — [Goal from ROADMAP.md]
 
-  Run `/clear`, then paste:
   ```
   /gsd:plan-phase [phase-number]
   ```
+
+  <sub>`/clear` first → fresh context window</sub>
+
+  ---
   ```
 
 **If CONTEXT.md does NOT exist:**
 
 - Display:
   ```
-  ## To Continue
+  ---
 
-  Run `/clear`, then paste one of:
+  ## ▶ Next Up
 
-  **See Claude's assumptions:**
-  ```
-  /gsd:list-phase-assumptions [phase]
-  ```
-
-  **Discuss context first:**
-  ```
-  /gsd:discuss-phase [phase]
-  ```
+  **Phase [N]: [Name]** — [Goal from ROADMAP.md]
 
-  **Plan directly:**
   ```
   /gsd:plan-phase [phase]
   ```
+
+  <sub>`/clear` first → fresh context window</sub>
+
+  ---
+
+  **Also available:**
+  - `/gsd:discuss-phase [phase]` — gather context first
+  - `/gsd:research-phase [phase]` — investigate unknowns
+  - `/gsd:list-phase-assumptions [phase]` — see Claude's assumptions
+
+  ---
   ```
 
 **If all plans complete for current phase:**