jettypod 4.4.1 → 4.4.3

package/jettypod.js

@@ -222,6 +222,7 @@ jettypod work create feature "<title>" --parent=<id>
 jettypod work start <id>
 jettypod work status <id> cancelled
 jettypod backlog
+jettypod impact <file>    # Show tests/features affected by changing a file
 
 ## Advanced Commands
 For mode management, decisions, project state: docs/COMMAND_REFERENCE.md
@@ -2062,6 +2063,94 @@ Quick commands:
     break;
   }
 
+  case 'impact': {
+    // Test impact analysis
+    const targetFile = args[0];
+
+    if (!targetFile) {
+      console.log('Usage: jettypod impact <file-path>');
+      console.log('');
+      console.log('Analyze what tests and features would be affected by changing a file.');
+      console.log('');
+      console.log('Examples:');
+      console.log('  jettypod impact lib/database.js');
+      console.log('  jettypod impact features/work-tracking/index.js');
+      process.exit(1);
+    }
+
+    try {
+      const { DependencyGraph } = require('./lib/test-impact-analyzer');
+      const graph = new DependencyGraph();
+
+      console.log('🔍 Building dependency graph...');
+      await graph.build(process.cwd());
+
+      const impact = graph.getImpact(targetFile);
+
+      if (impact.error) {
+        console.error(`\n❌ ${impact.error}`);
+        console.log('');
+        console.log('Make sure the file path is relative to the project root.');
+        process.exit(1);
+      }
+
+      // Pretty-print impact analysis
+      const levelColors = {
+        LOW: '\x1b[32m',    // green
+        MEDIUM: '\x1b[33m', // yellow
+        HIGH: '\x1b[31m'    // red
+      };
+      const reset = '\x1b[0m';
+      const bold = '\x1b[1m';
+      const dim = '\x1b[2m';
+
+      console.log('');
+      console.log('═'.repeat(60));
+      console.log(`${bold}IMPACT ANALYSIS: ${targetFile}${reset}`);
+      console.log('═'.repeat(60));
+      console.log('');
+      console.log(`Impact Score: ${bold}${impact.impactScore}/100${reset} ${levelColors[impact.impactLevel]}(${impact.impactLevel})${reset}`);
+      console.log(`Total Affected Files: ${impact.totalAffected}`);
+
+      if (impact.tests.length > 0) {
+        console.log('');
+        console.log(`${bold}AFFECTED TESTS (${impact.tests.length}):${reset}`);
+        for (const t of impact.tests) {
+          console.log(`  ${dim}[dist=${t.distance}]${reset} ${t.file}`);
+        }
+      }
+
+      if (impact.features.length > 0) {
+        console.log('');
+        console.log(`${bold}AFFECTED BDD FILES (${impact.features.length}):${reset}`);
+        for (const f of impact.features) {
+          console.log(`  ${dim}[dist=${f.distance}]${reset} ${f.file}`);
+        }
+      }
+
+      if (impact.code.length > 0) {
+        console.log('');
+        console.log(`${bold}AFFECTED CODE (${impact.code.length}):${reset}`);
+        const displayCode = impact.code.slice(0, 10);
+        for (const c of displayCode) {
+          console.log(`  ${dim}[dist=${c.distance}]${reset} ${c.file}`);
+        }
+        if (impact.code.length > 10) {
+          console.log(`  ${dim}... and ${impact.code.length - 10} more${reset}`);
+        }
+      }
+
+      console.log('');
+      console.log('═'.repeat(60));
+      console.log('');
+
+    } catch (err) {
+      console.error(`❌ Error: ${err.message}`);
+      process.exit(1);
+    }
+    break;
+  }
+
   default:
     // Smart mode: auto-initialize if needed, otherwise show guidance
     if (!fs.existsSync('.jettypod')) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jettypod",
-  "version": "4.4.1",
+  "version": "4.4.3",
   "description": "AI-powered development workflow manager with TDD, BDD, and automatic test generation",
   "main": "jettypod.js",
   "bin": {

package/skills-templates/epic-planning/SKILL.md

@@ -211,23 +211,114 @@ node jettypod.js work epic-implement [epic-id] \
 
 **DO NOT display this as example text. EXECUTE IT using the Bash tool.**
 
-After execution succeeds, verify the decision was recorded and display:
+After execution succeeds, display:
 
 ```
 ✅ Architectural decision recorded
+```
+
+Then proceed to Step 7.
+
+### Step 7: Route to Next Planning Skill
+
+After features/chores are created (and architectural decision recorded if applicable), route to the appropriate planning skill.
+
+#### Step 7A: Query Created Items
+
+Query the database to find what was just created under this epic:
+
+```bash
+sqlite3 .jettypod/work.db "SELECT id, title, type FROM work_items WHERE parent_id = <EPIC_ID> ORDER BY id"
+```
+
+#### Step 7B: Display and Recommend
+
+Display what was created and recommend which item to plan first:
 
+```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 🎯 Epic Planning Complete!
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-Features created: [count]
-Architectural decision: Recorded
+Created under this epic:
+  ✨ Feature #[id]: [title]
+  ✨ Feature #[id]: [title]
+  🔧 Chore #[id]: [title]  (if any chores were created)
+
+💡 Recommendation: Start with [Feature/Chore] #[id] ([title])
+   [Reason - e.g., "It's foundational - other items may depend on it."]
+
+Plan this one now? [yes / pick different / done for now]
+```
+
+**Recommendation logic:**
+- If features exist, recommend the first feature (features are typically foundational)
+- If only chores exist, recommend the first chore
+- Provide brief reasoning for the recommendation
+
+**WAIT for user response.**
+
+#### Step 7C: Route on Confirmation
+
+Based on user response:
+
+**If user confirms (says "yes", "let's go", "proceed", etc.):**
+
+Determine the skill to invoke based on item type:
+- **Feature** → invoke `feature-planning`
+- **Chore** → invoke `chore-planning`
 
-**Next step:** Plan your first feature
-Run: jettypod work discover [feature-id]
-Or talk to Claude Code: "Let's do feature discovery for #[feature-id]"
+**IMMEDIATELY invoke the appropriate skill using the Skill tool:**
+
+```
+Use the Skill tool with skill: "feature-planning"
+```
+or
+```
+Use the Skill tool with skill: "chore-planning"
+```
+
+**If user picks different item (says "pick different", "different one", "let me choose", etc.):**
+
+Display a numbered list of all created items:
+
+```
+Which item would you like to plan?
+
+1. ✨ Feature #[id]: [title]
+2. ✨ Feature #[id]: [title]
+3. 🔧 Chore #[id]: [title]
+
+Enter the number of your choice:
 ```
 
+**WAIT for user to enter a number.**
+
+After user selects (e.g., "2" or "number 2"):
+1. Look up the item from the list
+2. Determine the skill based on item type:
+   - **Feature** → invoke `feature-planning`
+   - **Chore** → invoke `chore-planning`
+3. **IMMEDIATELY invoke the appropriate skill using the Skill tool**
+
+**If user says "done for now" (or "later", "not now", "skip", "no thanks", etc.):**
+
+Display with actual IDs from the created items:
+```
+No problem! When you're ready to continue, you can plan any of these:
+
+Features:
+  • "Let's do feature discovery for #10" (User registration)
+  • "Let's do feature discovery for #11" (Password reset)
+
+Chores:
+  • "Help me plan chore #12" (Update CI config)
+
+Or run: jettypod backlog to see all items.
+```
+
+**Do NOT invoke any skill. End epic-planning skill.**
+
 ## Key Principles
 
 1. **Feature brainstorming is always required** - Don't skip this even if architectural decision is clear
@@ -235,8 +326,9 @@ Or talk to Claude Code: "Let's do feature discovery for #[feature-id]"
 3. **Always suggest exactly 3 options** when architectural decision needed - Simple/Conservative, Balanced, Advanced
 4. **Be specific about features** - Each feature should be user-facing capability
 5. **Use the Approach Suggestion template** - Pros, Cons, Technical Impact format
-6. **Suggest next step** - Always end with clear guidance on what to do next
+6. **Route to next skill** - After creating items, recommend one and invoke the appropriate planning skill
 7. **Use jettypod commands** - Create features using jettypod CLI, record decisions with epic-implement
+8. **Skill handoff** - Invoke `feature-planning` for features, `chore-planning` for chores
 
 ## Example: Epic with Architectural Decision
 
@@ -297,9 +389,11 @@ Epic: "User Management"
 
 ## Validation
 
-Before completing epic discovery, ensure:
-- [ ] At least 2-3 features identified
+Before completing epic planning, ensure:
+- [ ] At least 2-3 features/chores identified
 - [ ] Features are user-facing capabilities (not technical tasks)
+- [ ] Chores (if any) are standalone work items for this epic
 - [ ] Architectural decision documented if needed
-- [ ] Features created in database
-- [ ] User knows next step .jettypod work discover [feature-id])
+- [ ] All items created in database with correct parent_id
+- [ ] Recommended next item to plan
+- [ ] Routed to feature-planning or chore-planning (or user declined)

package/skills-templates/feature-planning/SKILL.md

@@ -11,6 +11,21 @@ Guides Claude through feature planning including UX approach exploration, option
 
 When this skill is activated, you are helping discover the best approach for a feature. Follow this structured approach:
 
+## 🔑 Critical Command Distinction
+
+**Two different commands, two different purposes:**
+
+| Command | Used For | When | Phase |
+|---------|----------|------|-------|
+| `work implement <feature-id>` | Transition feature to implementation phase | During feature planning (Step 8B) | Feature Planning |
+| `work start <chore-id>` | Start implementing a specific chore | After feature planning complete (Step 8D) | Speed Mode |
+
+**CRITICAL:** Both commands are run by **Claude**, not the user. The distinction is:
+- `work implement` = Ends feature planning, creates chores
+- `work start` = Begins implementing a chore (triggers speed-mode skill)
+
+---
+
 ### Step 1: Understand the Feature Context
 
 You'll receive context about:
@@ -96,15 +111,42 @@ If user wants prototypes:
 1. **Build prototypes** in `/prototypes/feature-[id]-[approach-name]/`
 2. **Name format**: `YYYY-MM-DD-[feature-slug]-[option].ext`
 3. **Focus on UX**: Show the feel, not production code
-4. **Add prototype header**:
-   ```
-   // Prototype: [feature] - [option]
-   // Created: [date]
-   // Purpose: [what this explores]
-   // Decision: [to be filled after testing]
+4. **Add visible banner header at TOP of page** (for HTML/web prototypes):
+   ```html
+   <div style="background: #f0f0f0; border: 2px solid #333; padding: 16px; margin-bottom: 24px; font-family: monospace;">
+     <strong>🧪 PROTOTYPE</strong><br>
+     Feature: [feature name]<br>
+     Option: [option number/name]<br>
+     Created: [YYYY-MM-DD]<br>
+     Purpose: [what this explores]<br>
+     Decision: [to be filled after testing]
+   </div>
    ```
+   For CLI/terminal prototypes, add similar info as first output.
 5. **Offer to open them**: "Want me to open these in your browser?"
 
+<details>
+<summary><strong>📋 Prototyping Guidelines (click to expand)</strong></summary>
+
+**Use fastest tech to demonstrate UX:**
+- Quick HTML+JS for web UX
+- Simple CLI scripts for command-line UX
+- Minimal frameworks, maximum clarity
+
+**What to prototype:**
+- User interaction flow
+- Visual layout (if UI)
+- Command structure (if CLI)
+- API shape (if API)
+
+**What NOT to prototype:**
+- Production error handling
+- Database layer
+- Authentication (unless that's the feature)
+- Test coverage
+
+</details>
+
 ### Step 5: Choose Winner
 
 After user tests (or skips prototyping):
@@ -124,10 +166,12 @@ Based on chosen approach, generate:
 **A. Scenario file** at `features/[feature-slug].feature` using Write tool:
 
 1. **Create file** at `features/[feature-slug].feature` using Write tool
-2. **ONLY include happy path scenario**:
-   - Happy path ONLY - the core user journey that proves it works
+2. **Include all "make it work" scenarios**:
+   - All success paths - required functionality AND optional features
+   - Multiple valid workflows if the feature supports them
+   - Success variations (different outcomes that are all correct)
    - NO error handling scenarios (added in stable mode)
-   - NO edge cases (added in stable mode)
+   - NO validation failures (added in stable mode)
    - NO security/compliance scenarios (added in production mode)
 
 **B. Step definitions file** at `features/step_definitions/[feature-slug].steps.js` using Write tool:
@@ -147,7 +191,7 @@ Based on chosen approach, generate:
    sqlite3 .jettypod/work.db "UPDATE work_items SET scenario_file = 'features/[feature-slug].feature' WHERE id = <feature-id>"
    ```
 
-**Template for speed mode (happy path only):**
+**Template for speed mode (make it work):**
 
 ```gherkin
 Feature: [Feature Name]
@@ -156,15 +200,20 @@ Feature: [Feature Name]
   Epic: [Epic name if applicable]
   Approach: [Chosen approach name]
 
-Scenario: [Happy path scenario - core user journey]
+Scenario: [Core functionality - required workflow]
   Given [initial state]
   When [user takes main action]
   Then [expected successful outcome]
   And [observable UI/system state change]
 
-# SPEED MODE: Only happy path above
-# STABLE MODE: Will add error handling, edge cases, validation scenarios
-# These additional scenarios are added by stable-mode skill, NOT during feature discovery
+Scenario: [Optional feature 1 - if applicable]
+  Given [initial state]
+  When [user uses optional feature]
+  Then [feature works correctly]
+
+# SPEED MODE: All success scenarios above (required + optional functionality)
+# STABLE MODE: Will add error handling, validation failures, edge cases
+# These failure scenarios are added by stable-mode skill, NOT during feature discovery
 ```
 
 **Example for Login feature (speed mode):**
@@ -182,8 +231,66 @@ Scenario: User successfully logs in with valid credentials
   Then I am redirected to the dashboard
   And I see a welcome message with my name
   And I have an active session token
+
+Scenario: User logs in with "Remember me" option (optional feature)
+  Given I am on the login page
+  When I enter valid credentials
+  And I check the "Remember me" checkbox
+  And I click the login button
+  Then I am redirected to the dashboard
+  And my session persists for 30 days
+```
+
+<details>
+<summary><strong>📋 BDD Scenario Guidelines (click to expand)</strong></summary>
+
+**Scenario naming:**
+- Use present tense
+- Be specific about what's being tested
+- Focus on user behavior
+
+**Given/When/Then structure:**
+- **Given**: Set up initial state
+- **When**: User action
+- **Then**: Observable outcome
+
+**What feature planning creates:**
+
+Feature planning creates speed mode scenarios (make it work - all success paths):
+```gherkin
+Scenario: User successfully [does the required thing]
+  Given [setup]
+  When [action]
+  Then [success]
+
+Scenario: User successfully [uses optional feature]
+  Given [setup]
+  When [uses optional capability]
+  Then [feature works correctly]
+```
+
+**Additional scenarios are added LATER by stable-mode skill:**
+
+Stable mode adds error handling and validation:
+```gherkin
+Scenario: Handle invalid input
+  Given [setup]
+  When [invalid action]
+  Then [appropriate error]
 ```
 
+Production mode adds security/scale/compliance:
+```gherkin
+Scenario: Prevent unauthorized access
+  Given [unauthorized user]
+  When [attempts action]
+  Then [access denied with proper error]
+```
+
+**IMPORTANT:** Feature planning creates all success scenarios (required + optional). Stable/production chores add failure scenarios later.
+
+</details>
+
 ### Step 6.5: Validate BDD Infrastructure
 
 **CRITICAL:** After creating both scenario and step definition files, automatically validate them with cucumber dry-run to catch errors immediately.
@@ -236,7 +343,7 @@ console.log(''); // Extra line before continuing
 
 The speed-mode skill guides Claude to:
 1. Implement the feature code
-2. Create corresponding unit tests for the happy path
+2. Create corresponding unit tests for all success scenarios
 3. Ensure tests pass before completing the chore
 
 This keeps feature planning focused on BDD scenarios (what users experience) while speed mode handles unit tests (implementation details).
@@ -246,7 +353,7 @@ This keeps feature planning focused on BDD scenarios (what users experience) whi
 **CRITICAL:** After BDD validation passes, analyze the codebase and propose technical implementation chores. **DO NOT CREATE CHORES YET** - the feature must transition to implementation mode first (Step 8).
 
 **Your analysis should consider:**
-- The BDD scenarios (especially the happy path)
+- The BDD scenarios (all success paths - required + optional features)
 - Existing codebase structure and patterns
 - Epic's architectural decisions (if any)
 - Tech stack and framework conventions
@@ -286,7 +393,7 @@ Based on the scenario and my understanding of the codebase, here are the chores
 
 [etc.]
 
-These chores will make the happy path scenario pass.
+These chores will make all success scenarios pass (required + optional features).
 
 Sound good? Any adjustments?
 ```
@@ -331,16 +438,11 @@ node jettypod.js work implement [feature-id] \
 
 **CRITICAL: NOW create the chores.** The feature has transitioned to implementation mode, so chore creation will succeed.
 
-**IMPORTANT:** You MUST pass `--parent=<FEATURE_ID>` with the actual numeric feature ID. Without this, chores won't be linked to the feature.
-
-For each chore that the user confirmed in Step 7, use the Bash tool to create it. Replace `<FEATURE_ID>` with the actual feature ID number:
+For each chore that the user confirmed in Step 7, use the Bash tool to create it:
 
 ```bash
-# CORRECT - uses actual numeric feature ID:
-node jettypod.js work create chore "Implement cursor position broadcast" "Broadcast cursor positions..." --parent=12
-
-# WRONG - missing parent flag (chore won't be linked to feature):
-node jettypod.js work create chore "Implement cursor position broadcast" "Broadcast cursor positions..."
+# Use Bash tool to execute for each chore:
+node jettypod.js work create chore "[Chore title]" "[Chore description with all the implementation guidance]" --parent=[feature-id]
 ```
 
 **Build the description from your Step 7 proposal:**
@@ -367,7 +469,7 @@ After creating all chores, display:
 ✅ Created X chores for speed mode
 
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-🎯 Feature Discovery Complete!
+🎯 Feature Planning Complete!
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 📋 BDD scenarios: features/[feature-slug].feature
@@ -378,97 +480,30 @@ After creating all chores, display:
 Ready to start implementation?
 ```
 
-#### Step 8D: Transition to Speed Mode
+#### Step 8D: Start First Chore
 
-**WAIT for user confirmation.**
+**Feature planning is now complete.** The feature has been transitioned to implementation phase and chores are ready.
 
-When user confirms they want to proceed with implementation (responds with "yes", "let's go", "proceed", "start", or similar):
-
-**IMMEDIATELY invoke the speed-mode skill using the Skill tool:**
+**Ask user which chore to start with:**
 
 ```
-Use the Skill tool with skill: "speed-mode"
+Ready to start implementation? Which chore should we start with?
 ```
 
-**The speed-mode skill will then:**
-1. Guide the user to start the first chore with `jettypod work start [chore-id]`
-2. Create a worktree for the chore
-3. Follow TDD workflow to implement the chore
-4. Merge when complete
-
-**End feature-planning skill after invoking speed-mode.**
-
-## Key Principles
-
-1. **Always suggest exactly 3 options** - Simple, Balanced, Advanced
-2. **Show epic's architectural decision** - Feature should align with epic's technical approach
-3. **UX first, tech second** - Focus on what it feels like to use, not implementation details
-4. **Prototypes are optional but valuable** - User can skip if approach is obvious
-5. **BDD scenarios are required** - Discovery isn't complete without scenarios
-6. **Guide to next step** - Always end with clear action
-
-## Prototyping Guidelines
-
-**Use fastest tech to demonstrate UX:**
-- Quick HTML+JS for web UX
-- Simple CLI scripts for command-line UX
-- Minimal frameworks, maximum clarity
+**After user picks a chore, use Bash tool to run:**
 
-**What to prototype:**
-- User interaction flow
-- Visual layout (if UI)
-- Command structure (if CLI)
-- API shape (if API)
-
-**What NOT to prototype:**
-- Production error handling
-- Database layer
-- Authentication (unless that's the feature)
-- Test coverage
-
-## BDD Scenario Guidelines
-
-**Scenario naming:**
-- Use present tense
-- Be specific about what's being tested
-- Focus on user behavior
-
-**Given/When/Then structure:**
-- **Given**: Set up initial state
-- **When**: User action
-- **Then**: Observable outcome
-
-**What feature-discover creates:**
-
-**Feature discovery ONLY creates speed mode scenarios (happy path):**
-```gherkin
-Scenario: User successfully [does the thing]
-  Given [setup]
-  When [action]
-  Then [success]
-```
-
-**Additional scenarios are added LATER by stable-mode skill:**
-
-Stable mode adds error handling:
-```gherkin
-Scenario: Handle invalid input
-  Given [setup]
-  When [invalid action]
-  Then [appropriate error]
+```bash
+jettypod work start [chore-id]
 ```
 
-Production mode adds security/scale/compliance:
-```gherkin
-Scenario: Prevent unauthorized access
-  Given [unauthorized user]
-  When [attempts action]
-  Then [access denied with proper error]
-```
+**This command will:**
+1. Create a git worktree and branch for the chore
+2. Automatically invoke the speed-mode skill
+3. Begin TDD implementation workflow in the isolated worktree
 
-**IMPORTANT:** Feature discovery only creates happy path. Stable/production chores add more scenarios later.
+**The speed-mode skill takes over from here and handles the implementation.**
 
-## Example: Feature Discovery Flow
+## Example: Feature Planning Flow
 
 **Feature:** "Email/password login"
 **Epic decision:** "Using Auth.js with JWT tokens"
@@ -480,17 +515,25 @@ Scenario: Prevent unauthorized access
 
 **User picks:** Option 1 (Simple inline form)
 
-**Scenarios generated (happy path only for speed mode):**
+**Scenarios generated (speed mode - all success paths):**
 ```gherkin
 Feature: Email/Password Login
 
-Scenario: Successful login
+Scenario: Successful login with credentials
   Given I am on the login page
   When I enter valid credentials and submit
   Then I am redirected to the dashboard
   And I have an active JWT token
 
-# SPEED MODE: Only happy path above
+Scenario: Login with "Remember me" option
+  Given I am on the login page
+  When I enter valid credentials
+  And I check "Remember me"
+  And I submit
+  Then I am redirected to the dashboard
+  And my session persists for 30 days
+
+# SPEED MODE: All success scenarios above (required + optional features)
 # STABLE MODE: Will add error handling scenarios like "Invalid credentials"
 ```
 
@@ -500,15 +543,17 @@ User confirms: "Yes, perfect"
 
 **Transition:** `jettypod work implement 10 --winner="prototypes/2025-10-30-login-simple.html" --rationale="Simple inline form chosen - fastest for users, cleanest UX"`
 
-## Validation
+## Validation Checklist
 
-Before completing feature discovery, ensure:
+Before completing feature planning, ensure:
 - [ ] Epic's architectural decision is shown (if exists)
 - [ ] Exactly 3 approaches suggested
 - [ ] Winner chosen (with prototypes or without)
-- [ ] BDD scenarios written
+- [ ] BDD scenarios written (all success paths)
 - [ ] Step definitions written for ALL scenario steps
 - [ ] Scenarios file exists at `features/[feature-slug].feature`
 - [ ] Step definitions file exists at `features/step_definitions/[feature-slug].steps.js`
 - [ ] BDD infrastructure validated with dry-run (Step 6.5)
-- [ ] User knows next step .jettypod work start [feature-id])
+- [ ] Feature transitioned to implementation with `work implement`
+- [ ] Speed mode chores created
+- [ ] First chore started with `work start [chore-id]` (Step 8D)