jettypod 4.4.62 → 4.4.63

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

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+/**
+ * Production Mode Guardrails Hook
+ *
+ * Blocks merge of the last production-mode chore until:
+ * 1. All BDD scenarios pass
+ * 2. Production standards validation passes
+ *
+ * This ensures production hardening is complete before deployment.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+// Test mode: allows tests to control pass/fail state
+const TEST_MODE = process.env.PRODUCTION_GUARDRAIL_TEST_MODE === '1';
+const TEST_BDD_PASS = process.env.PRODUCTION_GUARDRAIL_BDD_PASS === '1';
+const TEST_STANDARDS_PASS = process.env.PRODUCTION_GUARDRAIL_STANDARDS_PASS === '1';
+const TEST_HAS_STANDARDS = process.env.PRODUCTION_GUARDRAIL_HAS_STANDARDS === '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 checkProductionModeGuardrail(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 checkProductionModeGuardrail(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 'production', allow
+    if (chore.mode !== 'production') {
+      db.close();
+      return { allowed: true };
+    }
+
+    // Feature is in production 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 production-mode chore
+    const scenarioFile = chore.scenario_file;
+    db.close();
+
+    // Check 1: BDD tests must pass
+    if (scenarioFile) {
+      const testsPass = await runBddTests(scenarioFile, cwd);
+      if (!testsPass) {
+        return {
+          allowed: false,
+          message: 'Cannot merge last production-mode chore: BDD scenarios must pass',
+          hint: 'Run tests and fix failures before merging.'
+        };
+      }
+    }
+
+    // Check 2: Production standards validation must pass
+    const standardsPass = await validateProductionStandards(cwd);
+    if (!standardsPass) {
+      return {
+        allowed: false,
+        message: 'Cannot merge last production-mode chore: Production standards validation must pass',
+        hint: 'Run production standards validation and fix any gaps.'
+      };
+    }
+
+    // All checks pass
+    return { allowed: true };
+
+  } 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)) {
+      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
+    });
+
+    return result.status === 0;
+  } catch (err) {
+    return true;
+  }
+}
+
+/**
+ * Validate production standards
+ */
+async function validateProductionStandards(cwd) {
+  // In test mode, use environment variable to control pass/fail
+  if (TEST_MODE) {
+    // If no standards file in test mode, allow
+    if (!TEST_HAS_STANDARDS) {
+      return true;
+    }
+    return TEST_STANDARDS_PASS;
+  }
+
+  try {
+    // Check if production standards file exists
+    const standardsPath = path.join(cwd, '.jettypod', 'production-standards.json');
+    if (!fs.existsSync(standardsPath)) {
+      // No standards file = allow (nothing to validate)
+      return true;
+    }
+
+    // Read and validate standards
+    const standards = JSON.parse(fs.readFileSync(standardsPath, 'utf-8'));
+
+    // If no standards defined, allow
+    if (!standards.standards || standards.standards.length === 0) {
+      return true;
+    }
+
+    // Check if all standards are satisfied
+    // For now, we just check if the file exists and has standards
+    // More sophisticated validation would check each standard against implementation
+    return true;
+  } catch (err) {
+    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/claude-hooks/speed-mode-guardrails.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+/**
+ * Speed Mode Guardrails Hook
+ *
+ * Blocks merge of the last speed-mode chore until stable-mode transition happens.
+ * This ensures the speed→stable handoff is not skipped.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// 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 checkSpeedModeGuardrail(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 checkSpeedModeGuardrail(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
+      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 'speed', allow
+    if (chore.mode !== 'speed') {
+      db.close();
+      return { allowed: true };
+    }
+
+    // Feature is in speed 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);
+
+    db.close();
+
+    // If there are other incomplete chores, allow this merge
+    if (incompleteChores.count > 1) {
+      return { allowed: true };
+    }
+
+    // This is the last speed-mode chore - block!
+    return {
+      allowed: false,
+      message: 'Cannot merge last speed-mode chore while feature is in speed mode',
+      hint: 'Generate stable-mode chores first. Use the speed-mode skill to complete the handoff.'
+    };
+
+  } catch (err) {
+    // Fail open
+    return { allowed: 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/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/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.63",
   "description": "AI-powered development workflow manager with TDD, BDD, and automatic test generation",
   "main": "jettypod.js",
   "bin": {