jettypod 3.0.1 → 3.0.3

package/.claude/skills/feature-discover/SKILL.md

@@ -186,13 +186,16 @@ Scenario: User successfully logs in with valid credentials
 
 ### Step 7: Propose Speed Mode Chores
 
-**CRITICAL:** After generating BDD scenarios, analyze the codebase and propose technical implementation chores.
+**CRITICAL:** After generating BDD scenarios, analyze the codebase and propose technical implementation chores with rich breadcrumbs for speed mode execution.
 
 **Your analysis should consider:**
 - The BDD scenarios (especially the happy path)
 - Existing codebase structure and patterns
 - Epic's architectural decisions (if any)
 - Tech stack and framework conventions
+- Which scenario steps each chore addresses
+- Similar code patterns to follow
+- Specific step definitions that should pass
 
 **Say to the user:**
 
@@ -205,11 +208,25 @@ Based on the scenario and codebase, here are the chores I recommend for speed mo
 
 **Chore 1: [Technical task title]**
 - Why: [What this accomplishes toward the scenario]
-- Scope: [Specific implementation details]
+- Scenario steps addressed:
+  • [Which Given/When/Then steps this chore makes work]
+- Implementation guidance:
+  • Files to create/modify: [specific paths]
+  • Patterns to follow: [reference existing similar code]
+  • Key functions/components needed: [list]
+- Verification:
+  • Step definitions that should pass: [specific steps from .steps.js]
 
 **Chore 2: [Technical task title]**
 - Why: [What this accomplishes]
-- Scope: [Specific implementation details]
+- Scenario steps addressed:
+  • [Which steps]
+- Implementation guidance:
+  • Files to create/modify: [paths]
+  • Patterns to follow: [references]
+  • Key functions/components needed: [list]
+- Verification:
+  • Step definitions that should pass: [steps]
 
 [etc.]
 
@@ -220,20 +237,58 @@ Sound good? Any adjustments?
 
 **Wait for user confirmation/adjustments.**
 
-**Then create the chores:**
+**Then create the chores with rich descriptions:**
 
 ```javascript
 // For each confirmed chore:
 const { create } = require('./features/work-tracking');
 
-await create('chore', 'Chore Title', 'Description', featureId, 'speed', false);
+const description = `[Technical description]
+
+Scenario steps addressed:
+• [Which Given/When/Then steps this chore makes work]
+
+Implementation guidance:
+• Files to create/modify: [specific paths]
+• Patterns to follow: [reference existing similar code]
+• Key functions/components needed: [list]
+
+Verification:
+• Step definitions that should pass: [specific steps from .steps.js file]`;
+
+await create('chore', 'Chore Title', description, featureId, 'speed', false);
 // Repeat for each chore
 ```
 
+**Example chore description:**
+
+```
+Build login form component with email/password fields
+
+Scenario steps addressed:
+• Given I am on the login page
+• When I enter valid credentials and submit
+
+Implementation guidance:
+• Create: src/components/LoginForm.jsx
+• Follow pattern: src/components/SignupForm.jsx (similar form structure)
+• Key components: EmailInput, PasswordInput, SubmitButton
+• Key functions: handleSubmit(), validateEmailFormat()
+
+Verification:
+• features/step_definitions/login.steps.js - 'I am on the login page' should pass
+• features/step_definitions/login.steps.js - 'I enter valid credentials and submit' should pass
+```
+
 **Report:**
 ```
 ✅ Created X chores for speed mode
 
+Each chore includes:
+• Scenario steps it addresses
+• Implementation guidance with file paths and patterns
+• Step definitions to verify against
+
 Ready to start implementation: jettypod work start [first-chore-id]
 ```
 

package/.claude/skills/speed-mode/SKILL.md

@@ -29,17 +29,18 @@ When this skill is activated, you are helping implement a speed mode chore to ma
 
 ## Implementation Steps
 
-### Step 1: Autonomous Scenario Analysis
+### Step 1: Check for Breadcrumbs and Analyze Scenario
 
 **CRITICAL:** Claude Code executes this autonomously - no user permission needed.
 
 **Your task:**
-1. Get the current work item to find the parent feature's scenario file
-2. Read the scenario file from the database path
-3. Parse the Gherkin format and extract the happy path scenario (first scenario)
-4. Identify what needs to be implemented based on Given/When/Then steps
+1. Get the current work item and read its description for breadcrumbs
+2. If breadcrumbs exist (Scenario steps addressed, Implementation guidance, Verification), use them
+3. If no breadcrumbs, fall back to full autonomous analysis
+4. Read the parent feature's scenario file
+5. Parse the Gherkin and identify what needs to be implemented
 
-**Code to get scenario file:**
+**Code to check for breadcrumbs:**
 
 ```javascript
 const { getCurrentWork } = require('../../lib/current-work');
@@ -49,6 +50,12 @@ const path = require('path');
 
 const currentWork = getCurrentWork();
 
+// Check if description has breadcrumbs from feature-discover
+const hasBreadcrumbs = currentWork.description &&
+  currentWork.description.includes('Scenario steps addressed:') &&
+  currentWork.description.includes('Implementation guidance:') &&
+  currentWork.description.includes('Verification:');
+
 // Get parent feature
 const db = getDb();
 db.get('SELECT * FROM work_items WHERE id = ?', [currentWork.parent_id], (err, feature) => {
@@ -73,7 +80,24 @@ db.get('SELECT * FROM work_items WHERE id = ?', [currentWork.parent_id], (err, f
   - Expected outcomes (Then)
   - Observable changes (And)
 
-**Display to user:**
+**Display to user (with breadcrumbs):**
+
+```
+🚀 Speed Mode: [Chore Title]
+
+Scenario steps addressed:
+[Steps from breadcrumbs]
+
+Implementation guidance:
+[Files, patterns, functions from breadcrumbs]
+
+Verification:
+[Step definitions from breadcrumbs]
+
+Now analyzing codebase to finalize implementation approach...
+```
+
+**Display to user (without breadcrumbs):**
 
 ```
 🚀 Speed Mode: [Feature Name]
@@ -98,9 +122,10 @@ Now analyzing codebase to propose implementation...
 
 **Your task:**
 1. Check for epic architectural decisions
-2. Find relevant existing files
-3. Understand code patterns and conventions
-4. Identify where new code should be added
+2. Use breadcrumbs if available, otherwise discover patterns
+3. Verify/find relevant existing files
+4. Understand code patterns and conventions
+5. Identify where new code should be added
 
 **Check for architectural decisions:**
 
@@ -116,7 +141,14 @@ db.get('SELECT epic_id FROM work_items WHERE id = ?', [currentWork.parent_id], a
 });
 ```
 
-**Find relevant files:**
+**If breadcrumbs exist (from feature-discover):**
+- Parse "Files to create/modify" section - these are your target files
+- Parse "Patterns to follow" section - read these reference files first
+- Parse "Key functions/components needed" - these guide your implementation
+- Verify reference files exist and read them to understand patterns
+- Confirm target file locations make sense in project structure
+
+**If no breadcrumbs (autonomous discovery):**
 - Use Glob tool to find files matching patterns from scenario
   - Example: Scenario mentions "login" → search for `**/*login*.js`, `**/*auth*.js`
 - Use Grep tool to search for keywords from scenario

package/features/work-tracking/index.js

@@ -1220,13 +1220,14 @@ async function main() {
 
       if (!featureId || isNaN(featureId)) {
         console.error('Error: Feature ID is required');
-        console.log('Usage: jettypod work implement <feature-id> [--prototypes="file1,file2"] [--winner="file.js"]');
+        console.log('Usage: jettypod work implement <feature-id> [--prototypes="file1,file2"] [--winner="file.js"] [--rationale="why this approach"]');
         process.exit(1);
       }
 
-      // Parse optional --prototypes and --winner flags
+      // Parse optional --prototypes, --winner, and --rationale flags
       const prototypesIndex = args.findIndex(a => a.startsWith('--prototypes='));
       const winnerIndex = args.findIndex(a => a.startsWith('--winner='));
+      const rationaleIndex = args.findIndex(a => a.startsWith('--rationale='));
 
       const prototypes = prototypesIndex !== -1
         ? args[prototypesIndex].split('=')[1].replace(/^["']|["']$/g, '').split(',').map(p => p.trim())
@@ -1234,6 +1235,9 @@ async function main() {
       const winner = winnerIndex !== -1
         ? args[winnerIndex].split('=')[1].replace(/^["']|["']$/g, '')
         : null;
+      const rationale = rationaleIndex !== -1
+        ? args[rationaleIndex].split('=')[1].replace(/^["']|["']$/g, '')
+        : null;
 
       db.get(`SELECT * FROM work_items WHERE id = ?`, [featureId], (err, feature) => {
         if (err) {
@@ -1297,10 +1301,11 @@ async function main() {
         // Transition to implementation phase, set mode to speed
         const prototypeFilesValue = prototypes.length > 0 ? JSON.stringify(prototypes) : null;
         const winnerValue = winner || null;
+        const rationaleValue = rationale || null;
 
         db.run(
-          `UPDATE work_items SET phase = 'implementation', mode = 'speed', prototype_files = ?, discovery_winner = ? WHERE id = ?`,
-          [prototypeFilesValue, winnerValue, featureId],
+          `UPDATE work_items SET phase = 'implementation', mode = 'speed', prototype_files = ?, discovery_winner = ?, discovery_rationale = ? WHERE id = ?`,
+          [prototypeFilesValue, winnerValue, rationaleValue, featureId],
           (err) => {
             if (err) {
               console.error(`Error: ${err.message}`);
@@ -1321,6 +1326,9 @@ async function main() {
             if (winner) {
               console.log(`Winner: ${winner}`);
             }
+            if (rationale) {
+              console.log(`Rationale: ${rationale}`);
+            }
             console.log('');
             console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
             console.log('🚀 Speed Mode: Prove It Works');

package/lib/migrations/009-discovery-rationale-field.js

@@ -0,0 +1,24 @@
+// Migration: Add discovery_rationale field for feature discovery decisions
+// Created: 2025-01-06
+// Purpose: Track rationale for UX approach chosen during feature discovery
+// Related: Feature-discover skill - records why an approach was selected
+
+module.exports = {
+  id: '009-discovery-rationale-field',
+  description: 'Add discovery_rationale field for feature discovery decisions',
+
+  up: (db) => {
+    return new Promise((resolve, reject) => {
+      db.run(
+        `ALTER TABLE work_items ADD COLUMN discovery_rationale TEXT`,
+        (err) => {
+          if (err && !err.message.includes('duplicate column')) {
+            return reject(err);
+          }
+          console.log('Added discovery_rationale column to work_items');
+          resolve();
+        }
+      );
+    });
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jettypod",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "description": "Simplified development mode manager",
   "main": "jettypod.js",
   "bin": {