get-shit-done-cc 1.0.0

package/get-shit-done/templates/milestone.md

@@ -0,0 +1,115 @@
+# Milestone Entry Template
+
+Add this entry to `.planning/MILESTONES.md` when completing a milestone:
+
+```markdown
+## v[X.Y] [Name] (Shipped: YYYY-MM-DD)
+
+**Delivered:** [One sentence describing what shipped]
+
+**Phases completed:** [X-Y] ([Z] plans total)
+
+**Key accomplishments:**
+- [Major achievement 1]
+- [Major achievement 2]
+- [Major achievement 3]
+- [Major achievement 4]
+
+**Stats:**
+- [X] files created/modified
+- [Y] lines of code (primary language)
+- [Z] phases, [N] plans, [M] tasks
+- [D] days from start to ship (or milestone to milestone)
+
+**Git range:** `feat(XX-XX)` → `feat(YY-YY)`
+
+**What's next:** [Brief description of next milestone goals, or "Project complete"]
+
+---
+```
+
+<structure>
+If MILESTONES.md doesn't exist, create it with header:
+
+```markdown
+# Project Milestones: [Project Name]
+
+[Entries in reverse chronological order - newest first]
+```
+</structure>
+
+<guidelines>
+**When to create milestones:**
+- Initial v1.0 MVP shipped
+- Major version releases (v2.0, v3.0)
+- Significant feature milestones (v1.1, v1.2)
+- Before archiving planning (capture what was shipped)
+
+**Don't create milestones for:**
+- Individual phase completions (normal workflow)
+- Work in progress (wait until shipped)
+- Minor bug fixes that don't constitute a release
+
+**Stats to include:**
+- Count modified files: `git diff --stat feat(XX-XX)..feat(YY-YY) | tail -1`
+- Count LOC: `find . -name "*.swift" -o -name "*.ts" | xargs wc -l` (or relevant extension)
+- Phase/plan/task counts from ROADMAP
+- Timeline from first phase commit to last phase commit
+
+**Git range format:**
+- First commit of milestone → last commit of milestone
+- Example: `feat(01-01)` → `feat(04-01)` for phases 1-4
+</guidelines>
+
+<example>
+```markdown
+# Project Milestones: WeatherBar
+
+## v1.1 Security & Polish (Shipped: 2025-12-10)
+
+**Delivered:** Security hardening with Keychain integration and comprehensive error handling
+
+**Phases completed:** 5-6 (3 plans total)
+
+**Key accomplishments:**
+- Migrated API key storage from plaintext to macOS Keychain
+- Implemented comprehensive error handling for network failures
+- Added Sentry crash reporting integration
+- Fixed memory leak in auto-refresh timer
+
+**Stats:**
+- 23 files modified
+- 650 lines of Swift added
+- 2 phases, 3 plans, 12 tasks
+- 8 days from v1.0 to v1.1
+
+**Git range:** `feat(05-01)` → `feat(06-02)`
+
+**What's next:** v2.0 SwiftUI redesign with widget support
+
+---
+
+## v1.0 MVP (Shipped: 2025-11-25)
+
+**Delivered:** Menu bar weather app with current conditions and 3-day forecast
+
+**Phases completed:** 1-4 (7 plans total)
+
+**Key accomplishments:**
+- Menu bar app with popover UI (AppKit)
+- OpenWeather API integration with auto-refresh
+- Current weather display with conditions icon
+- 3-day forecast list with high/low temperatures
+- Code signed and notarized for distribution
+
+**Stats:**
+- 47 files created
+- 2,450 lines of Swift
+- 4 phases, 7 plans, 28 tasks
+- 12 days from start to ship
+
+**Git range:** `feat(01-01)` → `feat(04-01)`
+
+**What's next:** Security audit and hardening for v1.1
+```
+</example>

package/get-shit-done/templates/phase-prompt.md

@@ -0,0 +1,290 @@
+# Phase Prompt Template
+
+Template for `.planning/phases/XX-name/{phase}-{plan}-PLAN.md` - executable phase plans.
+
+**Naming:** Use `{phase}-{plan}-PLAN.md` format (e.g., `01-02-PLAN.md` for Phase 1, Plan 2)
+
+---
+
+## File Template
+
+```markdown
+---
+phase: XX-name
+type: execute
+domain: [optional - if domain skill loaded]
+---
+
+<objective>
+[What this phase accomplishes - from roadmap phase goal]
+
+Purpose: [Why this matters for the project]
+Output: [What artifacts will be created]
+</objective>
+
+<execution_context>
+~/.claude/get-shit-done/workflows/execute-phase.md
+./summary.md
+[If plan contains checkpoint tasks (type="checkpoint:*"), add:]
+~/.claude/get-shit-done/references/checkpoints.md
+</execution_context>
+
+<context>
+@.planning/PROJECT.md
+@.planning/ROADMAP.md
+[If research exists:]
+@.planning/phases/XX-name/FINDINGS.md
+[Relevant source files:]
+@src/path/to/relevant.ts
+</context>
+
+<tasks>
+
+<task type="auto">
+  <name>Task 1: [Action-oriented name]</name>
+  <files>path/to/file.ext, another/file.ext</files>
+  <action>[Specific implementation - what to do, how to do it, what to avoid and WHY]</action>
+  <verify>[Command or check to prove it worked]</verify>
+  <done>[Measurable acceptance criteria]</done>
+</task>
+
+<task type="auto">
+  <name>Task 2: [Action-oriented name]</name>
+  <files>path/to/file.ext</files>
+  <action>[Specific implementation]</action>
+  <verify>[Command or check]</verify>
+  <done>[Acceptance criteria]</done>
+</task>
+
+<task type="checkpoint:decision" gate="blocking">
+  <decision>[What needs deciding]</decision>
+  <context>[Why this decision matters]</context>
+  <options>
+    <option id="option-a">
+      <name>[Option name]</name>
+      <pros>[Benefits and advantages]</pros>
+      <cons>[Tradeoffs and limitations]</cons>
+    </option>
+    <option id="option-b">
+      <name>[Option name]</name>
+      <pros>[Benefits and advantages]</pros>
+      <cons>[Tradeoffs and limitations]</cons>
+    </option>
+  </options>
+  <resume-signal>[How to indicate choice - "Select: option-a or option-b"]</resume-signal>
+</task>
+
+<task type="auto">
+  <name>Task 3: [Action-oriented name]</name>
+  <files>path/to/file.ext</files>
+  <action>[Specific implementation]</action>
+  <verify>[Command or check]</verify>
+  <done>[Acceptance criteria]</done>
+</task>
+
+<task type="checkpoint:human-verify" gate="blocking">
+  <what-built>[What Claude just built that needs verification]</what-built>
+  <how-to-verify>
+    1. Run: [command to start dev server/app]
+    2. Visit: [URL to check]
+    3. Test: [Specific interactions]
+    4. Confirm: [Expected behaviors]
+  </how-to-verify>
+  <resume-signal>Type "approved" to continue, or describe issues to fix</resume-signal>
+</task>
+
+[Continue for all tasks - mix of auto and checkpoints as needed...]
+
+</tasks>
+
+<verification>
+Before declaring phase complete:
+- [ ] [Specific test command]
+- [ ] [Build/type check passes]
+- [ ] [Behavior verification]
+</verification>
+
+<success_criteria>
+
+- All tasks completed
+- All verification checks pass
+- No errors or warnings introduced
+- [Phase-specific criteria]
+  </success_criteria>
+
+<output>
+After completion, create `.planning/phases/XX-name/{phase}-{plan}-SUMMARY.md`:
+
+# Phase [X] Plan [Y]: [Name] Summary
+
+**[Substantive one-liner - what shipped, not "phase complete"]**
+
+## Accomplishments
+
+- [Key outcome 1]
+- [Key outcome 2]
+
+## Files Created/Modified
+
+- `path/to/file.ts` - Description
+- `path/to/another.ts` - Description
+
+## Decisions Made
+
+[Key decisions and rationale, or "None"]
+
+## Issues Encountered
+
+[Problems and resolutions, or "None"]
+
+## Next Step
+
+[If more plans in this phase: "Ready for {phase}-{next-plan}-PLAN.md"]
+[If phase complete: "Phase complete, ready for next phase"]
+</output>
+```
+
+<key_elements>
+From create-meta-prompts patterns:
+
+- XML structure for Claude parsing
+- @context references for file loading
+- Task types: auto, checkpoint:human-action, checkpoint:human-verify, checkpoint:decision
+- Action includes "what to avoid and WHY" (from intelligence-rules)
+- Verification is specific and executable
+- Success criteria is measurable
+- Output specification includes SUMMARY.md structure
+  </key_elements>
+
+<scope_guidance>
+**Plan sizing:**
+
+- Aim for 2-3 tasks per plan
+- If planning >3 tasks, split into multiple plans (01-01, 01-02, etc.)
+- Target ~50% context usage maximum
+- Complex phases: Create 01-01, 01-02, 01-03 plans instead of one large plan
+
+**When to split:**
+
+- Different subsystems (auth vs API vs UI)
+- Clear dependency boundaries (setup → implement → test)
+- Risk of context overflow (>50% estimated usage)
+  </scope_guidance>
+
+<good_examples>
+
+```markdown
+---
+phase: 01-foundation
+type: execute
+domain: next-js
+---
+
+<objective>
+Set up Next.js project with authentication foundation.
+
+Purpose: Establish the core structure and auth patterns all features depend on.
+Output: Working Next.js app with JWT auth, protected routes, and user model.
+</objective>
+
+<execution_context>
+~/.claude/get-shit-done/workflows/execute-phase.md
+./summary.md
+</execution_context>
+
+<context>
+@.planning/PROJECT.md
+@.planning/ROADMAP.md
+@src/lib/db.ts
+</context>
+
+<tasks>
+
+<task type="auto">
+  <name>Task 1: Add User model to database schema</name>
+  <files>prisma/schema.prisma</files>
+  <action>Add User model with fields: id (cuid), email (unique), passwordHash, createdAt, updatedAt. Add Session relation. Use @db.VarChar(255) for email to prevent index issues.</action>
+  <verify>npx prisma validate passes, npx prisma generate succeeds</verify>
+  <done>Schema valid, types generated, no errors</done>
+</task>
+
+<task type="auto">
+  <name>Task 2: Create login API endpoint</name>
+  <files>src/app/api/auth/login/route.ts</files>
+  <action>POST endpoint that accepts {email, password}, validates against User table using bcrypt, returns JWT in httpOnly cookie with 15-min expiry. Use jose library for JWT (not jsonwebtoken - it has CommonJS issues with Next.js).</action>
+  <verify>curl -X POST /api/auth/login -d '{"email":"test@test.com","password":"test"}' -H "Content-Type: application/json" returns 200 with Set-Cookie header</verify>
+  <done>Valid credentials return 200 + cookie, invalid return 401, missing fields return 400</done>
+</task>
+
+</tasks>
+
+<verification>
+Before declaring phase complete:
+- [ ] `npm run build` succeeds without errors
+- [ ] `npx prisma validate` passes
+- [ ] Login endpoint responds correctly to valid/invalid credentials
+- [ ] Protected route redirects unauthenticated users
+</verification>
+
+<success_criteria>
+
+- All tasks completed
+- All verification checks pass
+- No TypeScript errors
+- JWT auth flow works end-to-end
+  </success_criteria>
+
+<output>
+After completion, create `.planning/phases/01-foundation/01-01-SUMMARY.md`
+</output>
+```
+
+</good_examples>
+
+<bad_examples>
+
+```markdown
+# Phase 1: Foundation
+
+## Tasks
+
+### Task 1: Set up authentication
+
+**Action**: Add auth to the app
+**Done when**: Users can log in
+```
+
+This is useless. No XML structure, no @context, no verification, no specificity.
+</bad_examples>
+
+<guidelines>
+**When to use:**
+- Creating execution plans for each phase
+- One plan per 2-3 tasks, multiple plans per phase if needed
+- Always use XML structure for Claude parsing
+
+**Task types:**
+
+- `type="auto"`: Execute without stopping
+- `type="checkpoint:human-action"`: User must do something (manual step)
+- `type="checkpoint:human-verify"`: User must verify output (testing, visual check)
+- `type="checkpoint:decision"`: User must choose between options
+
+**Gate values:**
+
+- `gate="blocking"`: Must resolve before continuing
+- `gate="optional"`: Can skip or defer
+
+**Context references:**
+
+- Use @path/to/file.md to load files
+- Always include @.planning/PROJECT.md and @.planning/ROADMAP.md
+- Include relevant source files for context
+- Include workflow/template references
+
+**After completion:**
+
+- Create SUMMARY.md in same directory
+- Follow summary.md template structure
+- Document deviations, decisions, issues
+  </guidelines>

package/get-shit-done/templates/project.md

@@ -0,0 +1,207 @@
+# PROJECT.md Template
+
+Template for `.planning/PROJECT.md` - the full project context captured during initialization.
+
+## Greenfield Project (v1.0)
+
+```markdown
+# [Project Name]
+
+## Vision
+
+[What this is and why it matters. 2-4 paragraphs capturing the full picture.
+Use the user's language and framing. Include motivation, not just description.
+This should feel like the user explaining their project to a smart collaborator.]
+
+## Problem
+
+[What problem exists, who has it, why it matters, what the current state is.
+Be specific - vague problems lead to vague solutions.
+Include the pain, the gap, or the opportunity that makes this worth building.]
+
+## Success Criteria
+
+How we know this worked:
+
+- [ ] [Measurable outcome 1 - specific, verifiable]
+- [ ] [Measurable outcome 2 - specific, verifiable]
+- [ ] [Measurable outcome 3 - specific, verifiable]
+- [ ] [Add as many as genuinely needed]
+
+## Scope
+
+### Building
+- [Feature/capability 1]
+- [Feature/capability 2]
+- [Feature/capability 3]
+
+### Not Building
+- [Explicit exclusion 1 - prevents scope creep]
+- [Explicit exclusion 2 - clarifies boundaries]
+- [Explicit exclusion 3 - manages expectations]
+
+## Context
+
+[Background information that informs implementation:
+- Current state (greenfield)
+- Relevant prior work or experience
+- Technical environment or ecosystem context
+- Explored alternatives and why they were rejected]
+
+## Constraints
+
+- **[Constraint type]**: [What] - [Why]
+- **[Constraint type]**: [What] - [Why]
+- **[Constraint type]**: [What] - [Why]
+
+Common types: Tech stack, Timeline, Resources, Dependencies, Compatibility, Performance, Security
+
+## Decisions Made
+
+Key decisions from project exploration:
+
+| Decision | Choice | Rationale |
+|----------|--------|-----------|
+| [Area/Topic] | [What we decided] | [Why this choice] |
+| [Area/Topic] | [What we decided] | [Why this choice] |
+
+## Open Questions
+
+Things to figure out during execution:
+
+- [ ] [Question 1 - known unknown to resolve]
+- [ ] [Question 2 - decision to make later]
+- [ ] [Question 3 - area needing research]
+
+---
+*Initialized: [date]*
+```
+
+## Brownfield Project (v1.1+)
+
+After shipping v1.0, update PROJECT.md to include current state:
+
+```markdown
+# [Project Name]
+
+## Current State (Updated: YYYY-MM-DD)
+
+**Shipped:** v[X.Y] [Name] (YYYY-MM-DD)
+**Status:** [Production / Beta / Internal / Live with users]
+**Users:** [If known: "~500 downloads, 50 DAU" or "Internal use only" or "N/A"]
+**Feedback:** [Key themes from user feedback, or "Initial release, gathering feedback"]
+
+**Codebase:**
+- [X,XXX] lines of [primary language]
+- [Key tech stack: framework, platform, deployment target]
+- [Notable dependencies or architecture]
+
+**Known Issues:**
+- [Issue 1 from v1.x that needs addressing]
+- [Issue 2]
+- [Or "None" if clean slate]
+
+## v[Next] Goals
+
+**Vision:** [What's the goal for this next iteration?]
+
+**Motivation:**
+- [Why this work matters now]
+- [User feedback driving it]
+- [Technical debt or improvements needed]
+
+**Scope (v[X.Y]):**
+- [Feature/improvement 1]
+- [Feature/improvement 2]
+- [Feature/improvement 3]
+
+**Success Criteria:**
+- [ ] [Measurable outcome 1]
+- [ ] [Measurable outcome 2]
+- [ ] [Measurable outcome 3]
+
+**Not Building (this version):**
+- [Not doing X in this version]
+- [Not doing Y in this version]
+
+## Constraints
+
+- **[Constraint type]**: [What] - [Why]
+- **[Constraint type]**: [What] - [Why]
+
+## Open Questions
+
+- [ ] [Question for this version]
+- [ ] [Question for this version]
+
+---
+
+<details>
+<summary>Original Vision (v1.0 - Archived)</summary>
+
+## Vision
+
+[Original vision content]
+
+## Problem
+
+[Original problem statement]
+
+## Success Criteria
+
+- [x] [Outcome 1] - Achieved
+- [x] [Outcome 2] - Achieved
+- [x] [Outcome 3] - Achieved
+
+## Scope
+
+### Built
+- [What was built]
+
+### Not Built
+- [What was excluded]
+
+## Context
+
+[Original context]
+
+## Constraints
+
+[Original constraints]
+
+## Decisions Made
+
+[Original decisions table]
+
+</details>
+```
+
+<guidelines>
+**Greenfield:**
+- Don't compress - capture everything from questioning
+- Use user's words - preserve their language and framing
+- Be specific - vague inputs create vague outputs
+- Include rationale - "what" without "why" loses context
+- Mark unknowns - open questions are valuable, not failures
+
+**Brownfield:**
+- Current State shows real-world context (shipped, users, feedback)
+- v[Next] Goals focuses on the upcoming work
+- Original Vision collapsed in `<details>` for reference
+- Checkboxes marked [x] for achieved goals
+- This makes all plans brownfield-aware automatically
+</guidelines>
+
+<state_summary>
+When creating STATE.md, extract a summary from PROJECT.md:
+
+**Building:** [One-liner from Vision]
+
+**Core requirements:**
+- [Top 3 from Success Criteria]
+
+**Constraints:**
+- [Key constraints]
+
+This goes in STATE.md's immutable "Project Summary" section.
+</state_summary>