jettypod 4.4.62 → 4.4.64

package/claude-hooks/stable-mode-guardrails.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+/**
+ * Stable Mode Guardrails Hook
+ *
+ * Blocks merge of the last stable-mode chore until all BDD scenarios pass.
+ * This ensures error handling coverage is complete before completing stable mode.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+// Test mode: allows tests to control BDD pass/fail state
+const TEST_MODE = process.env.STABLE_GUARDRAIL_TEST_MODE === '1';
+const TEST_BDD_PASS = process.env.STABLE_GUARDRAIL_BDD_PASS === '1';
+
+// Read hook input from stdin
+let input = '';
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', async () => {
+  try {
+    const hookInput = JSON.parse(input);
+    const { tool_name, tool_input, cwd } = hookInput;
+
+    // Only check Bash commands
+    if (tool_name !== 'Bash') {
+      allow();
+      return;
+    }
+
+    const command = tool_input.command || '';
+
+    // Only check jettypod work merge commands
+    if (!/jettypod\s+work\s+merge/.test(command)) {
+      allow();
+      return;
+    }
+
+    // Extract chore ID from command
+    const choreIdMatch = command.match(/jettypod\s+work\s+merge\s+(\d+)/);
+    if (!choreIdMatch) {
+      // No explicit ID - allow (might be merging current work)
+      allow();
+      return;
+    }
+
+    const choreId = parseInt(choreIdMatch[1]);
+    const result = await checkStableModeGuardrail(choreId, cwd);
+
+    if (result.allowed) {
+      allow();
+    } else {
+      deny(result.message, result.hint);
+    }
+  } catch (err) {
+    // Fail open on errors
+    allow();
+  }
+});
+
+/**
+ * Check if this merge should be blocked
+ */
+async function checkStableModeGuardrail(choreId, cwd) {
+  const dbPath = findDatabasePath(cwd);
+  if (!dbPath) {
+    return { allowed: true };
+  }
+
+  try {
+    const sqlite3 = require('better-sqlite3');
+    const db = sqlite3(dbPath, { readonly: true });
+
+    // Get the chore and its parent feature
+    const chore = db.prepare(`
+      SELECT wi.id, wi.parent_id, parent.mode, parent.type as parent_type, parent.scenario_file
+      FROM work_items wi
+      LEFT JOIN work_items parent ON wi.parent_id = parent.id
+      WHERE wi.id = ?
+    `).get(choreId);
+
+    if (!chore) {
+      db.close();
+      return { allowed: true };
+    }
+
+    // If no parent or parent isn't a feature, allow
+    if (!chore.parent_id || chore.parent_type !== 'feature') {
+      db.close();
+      return { allowed: true };
+    }
+
+    // If feature mode isn't 'stable', allow
+    if (chore.mode !== 'stable') {
+      db.close();
+      return { allowed: true };
+    }
+
+    // Feature is in stable mode - check if this is the last chore
+    const incompleteChores = db.prepare(`
+      SELECT COUNT(*) as count
+      FROM work_items
+      WHERE parent_id = ? AND type = 'chore' AND status NOT IN ('done', 'cancelled')
+    `).get(chore.parent_id);
+
+    // If there are other incomplete chores, allow this merge
+    if (incompleteChores.count > 1) {
+      db.close();
+      return { allowed: true };
+    }
+
+    // This is the last stable-mode chore - check if BDD tests pass
+    const scenarioFile = chore.scenario_file;
+    db.close();
+
+    // If no scenario file, allow (nothing to test)
+    if (!scenarioFile) {
+      return { allowed: true };
+    }
+
+    // Run BDD tests to check if they pass
+    const testsPass = await runBddTests(scenarioFile, cwd);
+
+    if (testsPass) {
+      return { allowed: true };
+    }
+
+    // Tests are failing - block!
+    return {
+      allowed: false,
+      message: 'Cannot merge last stable-mode chore: BDD scenarios must pass',
+      hint: 'Run tests and fix failures before merging. All error handling scenarios must pass.'
+    };
+
+  } catch (err) {
+    // Fail open
+    return { allowed: true };
+  }
+}
+
+/**
+ * Run BDD tests and return whether they pass
+ */
+async function runBddTests(scenarioFile, cwd) {
+  // In test mode, use environment variable to control pass/fail
+  if (TEST_MODE) {
+    return TEST_BDD_PASS;
+  }
+
+  try {
+    const scenarioPath = path.resolve(cwd, scenarioFile);
+
+    // Check if scenario file exists
+    if (!fs.existsSync(scenarioPath)) {
+      // No scenario file = pass (nothing to test)
+      return true;
+    }
+
+    // Run cucumber-js with the scenario file
+    const result = spawnSync('npx', ['cucumber-js', scenarioPath, '--format', 'summary'], {
+      cwd: cwd,
+      encoding: 'utf-8',
+      timeout: 60000 // 60 second timeout
+    });
+
+    // Check exit code - 0 means all tests passed
+    return result.status === 0;
+  } catch (err) {
+    // On error running tests, fail open (allow merge)
+    return true;
+  }
+}
+
+/**
+ * Find the jettypod database path
+ */
+function findDatabasePath(cwd) {
+  let dir = cwd || process.cwd();
+  while (dir !== path.dirname(dir)) {
+    const dbPath = path.join(dir, '.jettypod', 'work.db');
+    if (fs.existsSync(dbPath)) {
+      return dbPath;
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+/**
+ * Allow the action
+ */
+function allow() {
+  console.log(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "allow"
+    }
+  }));
+  process.exit(0);
+}
+
+/**
+ * Deny the action with explanation
+ */
+function deny(message, hint) {
+  const reason = `❌ ${message}\n\n💡 Hint: ${hint}`;
+
+  console.log(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "deny",
+      permissionDecisionReason: reason
+    }
+  }));
+  process.exit(0);
+}

package/jettypod.js

@@ -244,11 +244,17 @@ Status: ${currentWork.status}
 <jettypod_essentials>
 JettyPod: Structured workflow system with skills that guide complex workflows.
 
+## ⚠️ CRITICAL: All Work Requires a Work Item
+**Claude CANNOT write code directly to main branch.**
+- All work requires: \`work create\` → \`work start\` → skill workflow → \`work merge\`
+- If user asks to implement something without a work item, create one first and invoke the matching skill
+- Pre-commit hooks block direct commits to main
+
 ## ⚠️ CRITICAL: Skills are MANDATORY for workflows
 Skills auto-activate and MUST complete their full workflow:
 - epic-planning: Guides architectural decisions
 - feature-planning: Guides UX discovery + BDD scenarios
-- speed-mode: Implements happy path, THEN auto-generates stable chores
+- speed-mode: Implements happy path, THEN auto-invokes stable-mode
 - stable-mode: Adds error handling to speed implementation
 - external-transition: Guides launch preparation
 
@@ -260,10 +266,14 @@ Skills auto-activate and MUST complete their full workflow:
 ## Basic Commands (for non-workflow operations)
 jettypod work create epic "<title>"
 jettypod work create feature "<title>" --parent=<id>
-jettypod work start <id>
+jettypod work create chore "<title>" --parent=<id>
+jettypod work start <id>              # Creates worktree branch
+jettypod work merge                   # Merges worktree back to main
+jettypod work tests <feature-id>      # Create test worktree for BDD
+jettypod work tests merge <id>        # Merge tests to main
 jettypod work status <id> cancelled
 jettypod backlog
-jettypod impact <file>    # Show tests/features affected by changing a file
+jettypod impact <file>                # Show tests/features affected
 
 ## Advanced Commands
 For mode management, decisions, project state: docs/COMMAND_REFERENCE.md

package/lib/work-commands/index.js

@@ -1353,11 +1353,13 @@ async function mergeWork(options = {}) {
     console.log(`Branch: ${currentBranch}`);
   
     // Step 1: Push feature branch to remote
+    // NOTE: Use ['pipe', 'inherit', 'inherit'] instead of 'inherit' to avoid stealing stdin
+    // from Claude Code's shell. Using 'inherit' for stdin breaks the shell when run interactively.
     try {
       console.log('Pushing feature branch to remote...');
       execSync(`git push -u origin ${currentBranch}`, {
         cwd: gitRoot,
-        stdio: 'inherit'
+        stdio: ['pipe', 'inherit', 'inherit']
       });
     } catch (err) {
       const errorMsg = err.message.toLowerCase();
@@ -1409,7 +1411,7 @@ async function mergeWork(options = {}) {
       console.log(`Checking out ${defaultBranch}...`);
       execSync(`git checkout ${defaultBranch}`, {
         cwd: gitRoot,
-        stdio: 'inherit'
+        stdio: ['pipe', 'inherit', 'inherit']
       });
     } catch (err) {
       return Promise.reject(new Error(`Failed to checkout ${defaultBranch}: ${err.message}`));
@@ -1448,7 +1450,7 @@ async function mergeWork(options = {}) {
       console.log(`Updating ${defaultBranch} from remote...`);
       execSync(`git pull origin ${defaultBranch}`, {
         cwd: gitRoot,
-        stdio: 'inherit'
+        stdio: ['pipe', 'inherit', 'inherit']
       });
     } catch (err) {
       const errorMsg = err.message.toLowerCase();
@@ -1485,12 +1487,12 @@ async function mergeWork(options = {}) {
       return Promise.reject(new Error(`Failed to pull ${defaultBranch}: ${err.message}`));
     }
   
-    // Step 4: Merge feature branch into default branch
+    // Step 5: Merge feature branch into default branch
     try {
       console.log(`Merging ${currentBranch} into ${defaultBranch}...`);
       execSync(`git merge --no-ff ${currentBranch} -m "Merge work item #${currentWork.id}"`, {
         cwd: gitRoot,
-        stdio: 'inherit'
+        stdio: ['pipe', 'inherit', 'inherit']
       });
     } catch (err) {
       // Check if merge failed due to conflicts
@@ -1531,12 +1533,12 @@ async function mergeWork(options = {}) {
       return Promise.reject(new Error(`Failed to merge ${currentBranch}: ${err.message}`));
     }
   
-    // Step 5: Push default branch to remote
+    // Step 6: Push default branch to remote
     try {
       console.log(`Pushing ${defaultBranch} to remote...`);
       execSync(`git push origin ${defaultBranch}`, {
         cwd: gitRoot,
-        stdio: 'inherit'
+        stdio: ['pipe', 'inherit', 'inherit']
       });
     } catch (err) {
       const errorMsg = err.message.toLowerCase();

package/package.json

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