get-shit-done-cc 1.9.11 → 1.10.0-experimental.0

package/get-shit-done/workflows/discuss-design.md

@@ -0,0 +1,330 @@
+---
+name: discuss-design
+description: Design phase-specific UI through conversation, then generate mockups
+triggers: [custom]
+replaces: null
+requires: [ui-principles, framework-patterns]
+---
+
+<purpose>
+Design phase-specific UI elements through conversation before planning. Creates mockups for visual review, ensuring design decisions are made before implementation time is spent.
+</purpose>
+
+<when_to_use>
+- Before planning a phase with UI components
+- When you want to visualize before coding
+- When UI decisions need iteration
+- To create component mockups for review
+</when_to_use>
+
+<required_reading>
+@~/.claude/get-shit-done/references/ui-principles.md
+@~/.claude/get-shit-done/references/framework-patterns.md
+</required_reading>
+
+<process>
+
+<step name="display_banner" priority="first">
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ GSD ► DISCUSS DESIGN
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+</step>
+
+<step name="parse_phase">
+Extract phase number from argument.
+
+If no phase provided:
+```bash
+# List available phases
+ls -d .planning/phases/*/ 2>/dev/null | head -10
+```
+
+Ask via AskUserQuestion:
+- header: "Phase"
+- question: "Which phase are you designing for?"
+- options: [list phases found, or freeform input]
+
+Load phase details from ROADMAP.md:
+```bash
+grep -A 20 "^## Phase ${PHASE_NUM}" .planning/ROADMAP.md
+```
+</step>
+
+<step name="load_design_system">
+Check for project design system:
+
+```bash
+if [[ -f ".planning/DESIGN-SYSTEM.md" ]]; then
+  echo "Design system found - loading as context"
+  # Read and summarize key points
+else
+  echo "No design system - will use ui-principles defaults"
+fi
+```
+
+If design system exists, load and summarize key constraints:
+- Color palette
+- Typography scale
+- Component patterns
+- Framework-specific notes
+</step>
+
+<step name="detect_framework">
+```bash
+if [[ -f "package.json" ]]; then
+  if grep -q '"next"' package.json; then
+    FRAMEWORK="nextjs"
+  elif grep -q '"react"' package.json; then
+    FRAMEWORK="react"
+  fi
+elif ls *.xcodeproj 2>/dev/null || [[ -f "Package.swift" ]]; then
+  FRAMEWORK="swift"
+elif [[ -f "requirements.txt" ]]; then
+  FRAMEWORK="python"
+else
+  FRAMEWORK="html"
+fi
+```
+
+State: "I'll create {FRAMEWORK} mockups for this phase."
+</step>
+
+<step name="phase_context">
+Display phase summary:
+
+```
+## Phase {number}: {name}
+
+**Goal:** {phase goal from roadmap}
+
+**Relevant requirements:**
+{requirements that involve UI}
+```
+
+Ask inline (freeform):
+"What UI elements does this phase need? Describe the screens, components, or interactions you're envisioning."
+
+Wait for response.
+</step>
+
+<step name="visual_references">
+Ask via AskUserQuestion:
+- header: "References"
+- question: "Do you have visual references for this specific phase?"
+- options:
+  - "Yes, images/screenshots" - I'll provide files
+  - "Yes, URLs" - I'll share example sites
+  - "Both" - Images and URLs
+  - "No, use design system" - Work from existing system
+
+**If references provided:**
+Analyze and extract:
+- Specific component patterns
+- Layout approaches
+- Interaction patterns
+
+"From your references, I see: [analysis]"
+</step>
+
+<step name="component_discovery">
+Based on user description, identify components needed.
+
+For each component, ask follow-up questions:
+- "For the {component}, what states should it have?"
+- "What data does it display?"
+- "What actions can users take?"
+
+Use 4-then-check pattern:
+After ~4 questions, ask:
+- header: "More?"
+- question: "More questions about {component}, or move on?"
+- options:
+  - "More questions" - I want to clarify further
+  - "Move on" - I've said enough
+
+Continue until all components understood.
+</step>
+
+<step name="layout_discussion">
+Ask about layout:
+- "How should these components be arranged?"
+- "What's the primary action on this screen?"
+- "How does it behave on mobile?"
+
+Probe for:
+- Content hierarchy
+- Navigation patterns
+- Responsive behavior
+</step>
+
+<step name="interaction_discussion">
+For interactive components:
+- "What happens when user clicks {action}?"
+- "How should loading states look?"
+- "What error states are possible?"
+
+Document:
+- User flows
+- State transitions
+- Feedback patterns
+</step>
+
+<step name="design_summary">
+Present design summary:
+
+```
+## Design Summary: Phase {number}
+
+### Components
+{list with brief specs}
+
+### Layout
+{layout description}
+
+### Interactions
+{key interactions}
+
+### States
+{loading, error, empty states}
+```
+
+Ask via AskUserQuestion:
+- header: "Ready?"
+- question: "Ready to generate mockups?"
+- options:
+  - "Generate mockups" - Create the visual files
+  - "Adjust design" - I want to change something
+  - "Add more" - I have more components to discuss
+</step>
+
+<step name="generate_mockups">
+Create phase directory:
+```bash
+PHASE_DIR=".planning/phases/${PHASE_NUM}-${PHASE_NAME}"
+mkdir -p "$PHASE_DIR/mockups"
+```
+
+Spawn design specialist agent:
+
+Task(
+  prompt="@~/.claude/agents/design-specialist.md
+
+  <context>
+  **Phase:** {phase_number} - {phase_name}
+  **Framework:** {detected_framework}
+  **Design System:** @.planning/DESIGN-SYSTEM.md
+
+  **Components to create:**
+  {component_specs}
+
+  **Layout:**
+  {layout_description}
+
+  **States:**
+  {state_requirements}
+  </context>
+
+  Create mockups in: {PHASE_DIR}/mockups/",
+  subagent_type="general-purpose",
+  model="sonnet",
+  description="Generate phase mockups"
+)
+</step>
+
+<step name="review_mockups">
+After mockups generated, present for review:
+
+```
+## Mockups Created
+
+{list of files}
+
+### Preview
+
+Run:
+{preview command based on framework}
+```
+
+Ask via AskUserQuestion:
+- header: "Review"
+- question: "Review the mockups. What's the verdict?"
+- options:
+  - "Approved" - These look good, proceed
+  - "Iterate" - I want changes
+  - "Major revision" - Start fresh on specific components
+
+**If "Iterate":**
+Ask what changes needed, update mockups, re-present.
+
+Loop until "Approved".
+</step>
+
+<step name="create_design_doc">
+Generate phase design document:
+
+Write `.planning/phases/{phase}/${PHASE}-DESIGN.md` using template:
+@~/.claude/get-shit-done/templates/phase-design.md
+
+Include:
+- All component specs
+- Layout decisions
+- State definitions
+- Mockup file references
+- Implementation notes
+</step>
+
+<step name="present_result">
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ GSD ► DESIGN COMPLETE ✓
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+## Phase {number}: {name}
+
+**Components designed:** {count}
+**Mockups created:** {count}
+**Status:** Approved
+
+### Files
+
+| File | Purpose |
+|------|---------|
+| {PHASE}-DESIGN.md | Design specifications |
+{mockup_files}
+
+───────────────────────────────────────────────────────────────
+
+## What's Next
+
+The design is ready for implementation.
+
+Option 1: Plan the phase
+  /gsd:plan-phase {phase_number}
+
+Option 2: View mockups
+  {preview_command}
+
+Option 3: Edit design
+  Open .planning/phases/{phase}/${PHASE}-DESIGN.md
+
+The planner will automatically load {PHASE}-DESIGN.md as context.
+
+───────────────────────────────────────────────────────────────
+```
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] Phase requirements understood
+- [ ] Design system loaded (if exists)
+- [ ] All UI components identified
+- [ ] Component specs complete with states
+- [ ] Layout documented
+- [ ] Mockups generated in framework-appropriate format
+- [ ] User approved mockups
+- [ ] {PHASE}-DESIGN.md created
+- [ ] User knows next steps
+</success_criteria>

package/get-shit-done/workflows/execute-phase.md

@@ -143,6 +143,21 @@ waves = {
 
 **No dependency analysis needed.** Wave numbers are pre-computed during `/gsd:plan-phase`.
 
+**Check autopilot mode:**
+
+```bash
+echo $GSD_AUTOPILOT
+```
+
+**If GSD_AUTOPILOT=1 (autopilot mode):**
+
+Report minimal plain text:
+```
+Phase {X}: {total_plans} plans, {wave_count} waves
+```
+
+**Otherwise (interactive mode):**
+
 Report wave structure with context:
 ```
 ## Execution Plan
@@ -213,7 +228,7 @@ Execute each wave in sequence. Autonomous plans within a wave run in parallel.
    <execution_context>
    @~/.claude/get-shit-done/workflows/execute-plan.md
    @~/.claude/get-shit-done/templates/summary.md
-   @~/.claude/get-shit-done/references/checkpoints.md
+   @~/.claude/get-shit-done/references/checkpoint-execution.md
    @~/.claude/get-shit-done/references/tdd.md
    </execution_context>
 
@@ -456,6 +471,16 @@ If user reports issues → treat as gaps_found.
 
 **If gaps_found:**
 
+**Check autopilot mode:**
+
+```bash
+echo $GSD_AUTOPILOT
+```
+
+**If GSD_AUTOPILOT=1:** Output `Phase {X} verification: gaps_found` and stop. Autopilot script handles gap closure.
+
+**Otherwise (interactive mode):**
+
 Present gaps and offer next command:
 
 ```markdown
@@ -524,6 +549,24 @@ git commit -m "docs(phase-{X}): complete phase execution"
 </step>
 
 <step name="offer_next">
+**Check autopilot mode first:**
+
+```bash
+echo $GSD_AUTOPILOT
+```
+
+**If GSD_AUTOPILOT=1 (autopilot mode):**
+
+Output minimal plain text confirmation:
+
+```
+Phase {X} complete: {N} plans executed, verification {passed|gaps_found|human_needed}
+```
+
+Then stop. Do NOT output the "Next Up" section or any guidance.
+
+**Otherwise (interactive mode):**
+
 Present next steps based on milestone status:
 
 **If more phases remain:**

package/get-shit-done/workflows/execute-plan-auth.md

@@ -0,0 +1,122 @@
+<purpose>
+Authentication gate handling for execute-plan.md. Load this file dynamically when an authentication error is encountered during task execution.
+</purpose>
+
+<trigger>
+Load this file when CLI/API returns authentication errors:
+- "Error: Not authenticated", "Not logged in", "Unauthorized", "401", "403"
+- "Authentication required", "Invalid API key", "Missing credentials"
+- "Please run {tool} login" or "Set {ENV_VAR} environment variable"
+</trigger>
+
+<authentication_gates>
+
+## Handling Authentication Errors During Execution
+
+**When you encounter authentication errors during `type="auto"` task execution:**
+
+This is NOT a failure. Authentication gates are expected and normal. Handle them dynamically:
+
+**Authentication error indicators:**
+
+- CLI returns: "Error: Not authenticated", "Not logged in", "Unauthorized", "401", "403"
+- API returns: "Authentication required", "Invalid API key", "Missing credentials"
+- Command fails with: "Please run {tool} login" or "Set {ENV_VAR} environment variable"
+
+**Authentication gate protocol:**
+
+1. **Recognize it's an auth gate** - Not a bug, just needs credentials
+2. **STOP current task execution** - Don't retry repeatedly
+3. **Create dynamic checkpoint:human-action** - Present it to user immediately
+4. **Provide exact authentication steps** - CLI commands, where to get keys
+5. **Wait for user to authenticate** - Let them complete auth flow
+6. **Verify authentication works** - Test that credentials are valid
+7. **Retry the original task** - Resume automation where you left off
+8. **Continue normally** - Don't treat this as an error in Summary
+
+**Example: Vercel deployment hits auth error**
+
+```
+Task 3: Deploy to Vercel
+Running: vercel --yes
+
+Error: Not authenticated. Please run 'vercel login'
+
+[Create checkpoint dynamically]
+
+╔═══════════════════════════════════════════════════════╗
+║  CHECKPOINT: Action Required                          ║
+╚═══════════════════════════════════════════════════════╝
+
+Progress: 2/8 tasks complete
+Task: Authenticate Vercel CLI
+
+Attempted: vercel --yes
+Error: Not authenticated
+
+What you need to do:
+  1. Run: vercel login
+  2. Complete browser authentication
+
+I'll verify: vercel whoami returns your account
+
+────────────────────────────────────────────────────────
+→ YOUR ACTION: Type "done" when authenticated
+────────────────────────────────────────────────────────
+
+[Wait for user response]
+
+[User types "done"]
+
+Verifying authentication...
+Running: vercel whoami
+✓ Authenticated as: user@example.com
+
+Retrying deployment...
+Running: vercel --yes
+✓ Deployed to: https://myapp-abc123.vercel.app
+
+Task 3 complete. Continuing to task 4...
+```
+
+**Common services and their auth patterns:**
+
+| Service | Auth Error Pattern | Auth Command | Verification |
+|---------|-------------------|--------------|--------------|
+| Vercel | "Not authenticated" | `vercel login` | `vercel whoami` |
+| Netlify | "Not logged in" | `netlify login` | `netlify status` |
+| AWS | "Unable to locate credentials" | `aws configure` | `aws sts get-caller-identity` |
+| GCP | "Could not load the default credentials" | `gcloud auth login` | `gcloud auth list` |
+| Supabase | "Not logged in" | `supabase login` | `supabase projects list` |
+| Stripe | "No API key provided" | Set STRIPE_SECRET_KEY | `stripe config --list` |
+| Railway | "Not authenticated" | `railway login` | `railway whoami` |
+| Fly.io | "Not logged in" | `fly auth login` | `fly auth whoami` |
+| Convex | "Not authenticated" | `npx convex login` | `npx convex dashboard` |
+| Cloudflare | "Authentication error" | `wrangler login` | `wrangler whoami` |
+
+**In Summary documentation:**
+
+Document authentication gates as normal flow, not deviations:
+
+```markdown
+## Authentication Gates
+
+During execution, I encountered authentication requirements:
+
+1. Task 3: Vercel CLI required authentication
+   - Paused for `vercel login`
+   - Resumed after authentication
+   - Deployed successfully
+
+These are normal gates, not errors.
+```
+
+**Key principles:**
+
+- Authentication gates are NOT failures or bugs
+- They're expected interaction points during first-time setup
+- Handle them gracefully and continue automation after unblocked
+- Don't mark tasks as "failed" or "incomplete" due to auth gates
+- Document them as normal flow, separate from deviations
+
+</authentication_gates>