jettypod 4.1.2 → 4.1.4

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

@@ -20,14 +20,21 @@ You'll receive context about:
 
 ### Step 2: Check Epic Architectural Decisions
 
-**CRITICAL:** If this feature belongs to an epic, check for existing architectural decisions:
+**CRITICAL:** If this feature belongs to an epic, check for existing architectural decisions.
+
+**⚠️ IMPORTANT - USE EXACT CODE BELOW:**
+- Import from `./lib/decisions-helpers` (NOT `./features/decisions/index.js`)
+- The function name is `getDecisionsForEpic` (matches the import)
+- Use `await` because it returns a Promise
+
+**Execute this EXACT code (copy/paste as-is):**
 
 ```javascript
-const { getDecisionsForEpic } = require('../../lib/decisions-helpers');
+const { getDecisionsForEpic } = require('./lib/decisions-helpers');
 
 if (parentEpicId) {
   const epicDecisions = await getDecisionsForEpic(parentEpicId);
-  // Surface decisions to user
+  console.log('Epic decisions:', JSON.stringify(epicDecisions, null, 2));
 }
 ```
 
@@ -77,6 +84,8 @@ Here are 3 different approaches for [feature name]:
 - *[Alternative 1]*: [Brief] - Not selected because [reason]
 - *[Alternative 2]*: [Brief] - Not selected because [reason]
 
+**💡 Recommendation:** [State which option you recommend and why - 2-3 sentences explaining the reasoning]
+
 Would you like me to create working prototypes of these approaches?
 ```
 
@@ -184,9 +193,120 @@ Scenario: User successfully logs in with valid credentials
   And I have an active session token
 ```
 
+### 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.
+
+**Execute validation:**
+
+```javascript
+const { validateBddInfrastructure } = require('../../lib/skills/feature-planning/dry-run-validator');
+const { formatValidationResult } = require('../../lib/skills/feature-planning/validation-formatter');
+const path = require('path');
+
+console.log('🧪 Validating BDD infrastructure...\n');
+
+const featurePath = path.join(process.cwd(), 'features', '[feature-slug].feature');
+const result = await validateBddInfrastructure(featurePath);
+
+// Format and display results with colors and guidance
+const formattedOutput = formatValidationResult(result, featurePath);
+console.log(formattedOutput);
+
+if (!result.success) {
+  console.log(''); // Extra line before halting
+  return; // Halt - do not generate chores yet
+}
+
+// Continue to Step 7
+console.log(''); // Extra line before continuing
+```
+
+**Validation checks:**
+- ✅ Feature file has valid Gherkin syntax
+- ✅ All scenario steps have matching step definitions
+- ✅ No duplicate step definitions
+- ✅ Cucumber can parse the files
+- ✅ Validation completes in < 5 seconds
+
+**If validation fails:**
+1. Show clear error messages with file locations
+2. Provide actionable guidance on how to fix
+3. DO NOT proceed to chore generation
+4. Wait for user to fix issues
+
+**If validation succeeds:**
+1. Confirm success with checkmarks
+2. Proceed immediately to Step 6.75
+
+### Step 6.75: Scaffold Unit Test Files
+
+**CRITICAL:** After BDD validation passes, scaffold empty unit test files for expected implementation files.
+
+**Execute:**
+
+```javascript
+const { scaffoldUnitTestFile } = require('../../lib/unit-test-generator');
+const path = require('path');
+
+console.log('📝 Scaffolding unit test files...\n');
+
+// Infer implementation files from chore breadcrumbs
+// Parse "Files to create/modify" from each proposed chore
+const implementationFiles = [];
+
+// For each chore you're about to propose, extract file paths
+// Example: if chore says "Files to create/modify: src/login.js, src/auth.js"
+// Then implementationFiles = ['src/login.js', 'src/auth.js']
+
+for (const chore of proposedChores) {
+  const filesMatch = chore.description.match(/Files to create\/modify:\s*([^\n]+)/);
+  if (filesMatch) {
+    const files = filesMatch[1].split(',').map(f => f.trim());
+    implementationFiles.push(...files);
+  }
+}
+
+// Remove duplicates
+const uniqueFiles = [...new Set(implementationFiles)];
+
+// Scaffold test files
+const scaffoldedTests = [];
+for (const filePath of uniqueFiles) {
+  if (filePath.endsWith('.js') && !filePath.includes('test')) {
+    try {
+      const testFile = scaffoldUnitTestFile(filePath);
+      scaffoldedTests.push(testFile);
+      console.log(`  ✅ ${testFile}`);
+    } catch (err) {
+      console.log(`  ⚠️  Could not scaffold ${filePath}: ${err.message}`);
+    }
+  }
+}
+
+if (scaffoldedTests.length > 0) {
+  console.log(`\n📦 Scaffolded ${scaffoldedTests.length} unit test files`);
+  console.log('These files have empty TODO placeholders - speed mode will fill them.\n');
+} else {
+  console.log('No new test files to scaffold\n');
+}
+```
+
+**Why scaffold now:**
+- Creates test file structure before implementation
+- Reminds developers tests are required
+- Speed mode can update these TODO placeholders after GREEN
+- Prevents "I'll add tests later" (they never do)
+
+**What gets scaffolded:**
+- Empty `test/[path]/[file].test.js` files
+- Basic `describe()` blocks
+- TODO placeholders for actual tests
+- Won't overwrite existing test files
+
 ### Step 7: Propose Speed Mode Chores
 
-**CRITICAL:** After generating BDD scenarios, analyze the codebase and propose technical implementation chores with rich breadcrumbs for speed mode execution.
+**CRITICAL:** After BDD validation passes, 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)
@@ -240,27 +360,66 @@ Sound good? Any adjustments?
 **Then create the chores with rich descriptions:**
 
 ```javascript
-// For each confirmed chore:
+// Import breadcrumb generators
+const { parseStepDefinitions } = require('../../lib/step-definition-parser');
+const { findSimilarPatterns } = require('../../lib/pattern-finder');
+const { generateVerificationCommands } = require('../../lib/verification-command-generator');
 const { create } = require('./features/work-tracking');
+const path = require('path');
+
+// Parse step definitions for verification breadcrumbs
+const stepDefsPath = path.join(process.cwd(), 'features/step_definitions', `${featureSlug}.steps.js`);
+const stepMap = parseStepDefinitions(stepDefsPath);
 
-const description = `[Technical description]
+// For each confirmed chore:
+for (const chore of confirmedChores) {
+  // Find similar patterns for implementation guidance
+  const patterns = findSimilarPatterns(chore.keywords || []);
+
+  // Build pattern references
+  const patternRefs = patterns.length > 0
+    ? patterns.map(p => `${p.file} (${p.description})`).join('\n  • ')
+    : 'No similar patterns found - create new implementation';
+
+  // Build step definition references with file:line
+  const stepRefs = chore.steps
+    .map(stepText => {
+      const stepInfo = stepMap.get(stepText);
+      if (stepInfo) {
+        return `${path.basename(stepInfo.file)}:${stepInfo.lineNumber} - "${stepText}"`;
+      }
+      return `"${stepText}" (not yet implemented)`;
+    })
+    .join('\n  • ');
+
+  // Generate verification command for the chore's scenario
+  const verification = generateVerificationCommands(
+    `features/${featureSlug}.feature`,
+    chore.scenarioLine
+  );
+
+  const description = `${chore.technicalDescription}
 
 Scenario steps addressed:
-• [Which Given/When/Then steps this chore makes work]
+${chore.scenarioSteps.map(s => `• ${s}`).join('\n')}
 
 Implementation guidance:
-• Files to create/modify: [specific paths]
-• Patterns to follow: [reference existing similar code]
-• Key functions/components needed: [list]
+• Files to create/modify: ${chore.files.join(', ')}
+• Patterns to follow:
+  • ${patternRefs}
+• Key functions/components needed: ${chore.components.join(', ')}
 
 Verification:
-• Step definitions that should pass: [specific steps from .steps.js file]`;
+• Step definitions that should pass:
+  • ${stepRefs}
+• Test command: ${verification.command}
+• Scenario: ${verification.scenarioName}`;
 
-await create('chore', 'Chore Title', description, featureId, 'speed', false);
-// Repeat for each chore
+  await create('chore', chore.title, description, featureId, 'speed', false);
+}
 ```
 
-**Example chore description:**
+**Example chore description (with breadcrumb generators):**
 
 ```
 Build login form component with email/password fields
@@ -270,24 +429,30 @@ Scenario steps addressed:
 • 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()
+• Files to create/modify: src/components/LoginForm.jsx
+• Patterns to follow:
+  • src/components/SignupForm.jsx (Functions: handleSubmit, validateEmail)
+  • lib/validation.js (Functions: validateEmailFormat, validatePassword)
+• Key functions/components needed: EmailInput, PasswordInput, SubmitButton
 
 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
+• Step definitions that should pass:
+  • login.steps.js:15 - "I am on the login page"
+  • login.steps.js:23 - "I enter valid credentials and submit"
+• Test command: npm run test:bdd -- features/login.feature:8
+• Scenario: User successfully logs in with valid credentials
 ```
 
 **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
+Each chore includes automated breadcrumbs from:
+• Step definition parser - Exact file:line references for verification
+• Pattern finder - Similar code patterns to follow
+• Verification command generator - Ready-to-run test commands
+• Scenario steps addressed
+• Implementation guidance with file paths
 
 Ready to start implementation: jettypod work start [first-chore-id]
 ```
@@ -461,4 +626,5 @@ Before completing feature discovery, ensure:
 - [ ] 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])

package/skills-templates/production-mode/SKILL.md

@@ -294,11 +294,23 @@ try {
 
 ### Step 3: Implement Production Chore
 
-**For all scenarios:** Implement the current production chore.
+**For all scenarios:** Implement the current production chore with test-driven iteration.
 
 ```javascript
 const { getCurrentWork } = require('../../lib/current-work');
+const { getDb } = require('../../lib/database');
+const {
+  MAX_ITERATIONS,
+  TEST_TIMEOUT,
+  runBddTestWithTimeout,
+  runBddScenarioWithTimeout,
+  getScenarioLineByName,
+  parseTestProgress,
+  extractErrors,
+  findNewlyPassingSteps
+} = require('../../.claude/skills/speed-mode/test-runner');
 const fs = require('fs');
+const path = require('path');
 
 try {
   const currentWork = getCurrentWork();
@@ -306,16 +318,122 @@ try {
   console.log(`\n🚀 Implementing: ${currentWork.title}`);
   console.log(`Description: ${currentWork.description}`);
 
-  // Parse chore to understand which standard to implement
-  // Implementation follows the acceptance criteria from the standard
+  // Get parent feature and scenario file
+  const db = getDb();
+  const feature = await new Promise((resolve, reject) => {
+    db.get('SELECT * FROM work_items WHERE id = ?', [currentWork.parent_id], (err, row) => {
+      if (err) reject(err);
+      resolve(row);
+    });
+  });
+
+  if (!feature.scenario_file) {
+    console.error('❌ Feature has no scenario file.');
+    return;
+  }
+
+  // Identify which production scenario this chore addresses
+  // Parse from chore description (e.g., "Scenario: Rate limiting on login")
+  const scenarioMatch = currentWork.description.match(/Scenario:\s*(.+?)(?:\n|$)/i);
+  if (!scenarioMatch) {
+    console.error('❌ Cannot identify target scenario from chore description.');
+    console.log('Suggestion: Update chore description to reference specific scenario.');
+    return;
+  }
+
+  const targetScenarioName = scenarioMatch[1].trim();
+  const scenarioLine = getScenarioLineByName(feature.scenario_file, targetScenarioName);
+
+  if (!scenarioLine) {
+    console.error(`❌ Cannot find scenario "${targetScenarioName}" in ${feature.scenario_file}`);
+    return;
+  }
+
+  console.log(`\n📋 Target scenario: ${targetScenarioName} (line ${scenarioLine})`);
+
+  // RED→GREEN iteration loop for production implementation
+  let iteration = 0;
+  let scenarioPasses = false;
+  let previousResult = null;
+
+  console.log('\n🔴 Establishing RED baseline...\n');
+  const baselineResult = await runBddScenarioWithTimeout(feature.scenario_file, scenarioLine, TEST_TIMEOUT);
+
+  if (!baselineResult.timedOut) {
+    const baselineProgress = parseTestProgress(baselineResult.stdout + baselineResult.stderr);
+    console.log(`RED Baseline: ${baselineProgress.total - baselineProgress.passed} of ${baselineProgress.total} steps failing\n`);
+  }
+
+  while (!scenarioPasses && iteration < MAX_ITERATIONS) {
+    iteration++;
+    console.log(`\n━━━ Iteration ${iteration}/${MAX_ITERATIONS} ━━━`);
+
+    // 1. Implement production hardening based on standard
+    console.log('✍️  Implementing production hardening...');
+    // [Claude Code uses Edit/Write tools to implement standard requirements]
+
+    // 2. Run target scenario only
+    console.log('🧪 Running target scenario...');
+    const result = await runBddScenarioWithTimeout(feature.scenario_file, scenarioLine, TEST_TIMEOUT);
+
+    if (result.timedOut) {
+      console.error('❌ Tests timed out');
+      break;
+    }
+
+    const currentResult = parseTestProgress(result.stdout + result.stderr);
+    const newlyPassing = previousResult ? findNewlyPassingSteps(previousResult, currentResult) : [];
+
+    console.log(`\n📊 Progress: ${currentResult.passed}/${currentResult.total} steps passing`);
+
+    if (newlyPassing.length > 0) {
+      console.log(`\n✅ Newly passing:`);
+      newlyPassing.forEach(step => console.log(`  • ${step}`));
+    }
+
+    // Check if target scenario passes
+    if (currentResult.passed === currentResult.total && currentResult.total > 0) {
+      console.log('\n✅ Target scenario passing!');
+
+      // Run full verification (all scenarios) once for regression detection
+      console.log('\n🔍 Running full verification (all scenarios)...');
+      const fullResult = await runBddTestWithTimeout(feature.scenario_file, TEST_TIMEOUT);
+
+      if (fullResult.timedOut) {
+        console.log('⚠️  Full verification timed out');
+      } else if (fullResult.exitCode !== 0) {
+        const fullProgress = parseTestProgress(fullResult.stdout + fullResult.stderr);
+        console.log(`⚠️  Full verification found regressions: ${fullProgress.total - fullProgress.passed} scenarios failing`);
+        console.log('Continuing iterations to fix regressions...');
+        scenarioPasses = false;
+      } else {
+        console.log('✅ Full verification passed - all scenarios passing!');
+        scenarioPasses = true;
+      }
+    } else {
+      console.log(`\n❌ ${currentResult.total - currentResult.passed} steps still failing`);
+
+      const errors = extractErrors(result.stdout + result.stderr);
+      if (errors.errors.length > 0) {
+        console.log('\n🔧 Next failure to address:');
+        const firstError = errors.errors[0];
+        console.log(`  Step: ${firstError.step}`);
+        console.log(`  Error: ${firstError.message}`);
+      }
+    }
+
+    previousResult = currentResult;
+  }
+
+  if (!scenarioPasses) {
+    console.error(`\n❌ Maximum iterations (${MAX_ITERATIONS}) reached without passing scenario`);
+    console.log('Review implementation against production standard acceptance criteria.');
+    return;
+  }
 
-  // Example: If chore is about TLS enforcement
-  // 1. Read the standard's acceptance criteria
-  // 2. Implement code that satisfies the criteria
-  // 3. Add tests based on scenario steps
+  console.log('\n✅ Production chore implementation complete');
+  console.log('All scenarios passing with production standards enforced.');
 
-  console.log('\n✅ Implementation complete');
-  console.log('Run: npx cucumber-js to verify scenarios pass');
 } catch (err) {
   console.error('❌ Implementation failed:', err.message);
   return;