jettypod 4.4.120 → 4.4.121

package/cucumber-test.cjs

@@ -0,0 +1,6 @@
+module.exports = {
+  default: {
+    require: ['features/step_definitions/claude-cli-subprocess-env.steps.js'],
+    format: ['progress'],
+  }
+};

package/jettypod.js

@@ -565,6 +565,39 @@ Be direct and opinionated. Skip hedging, apologies, and excessive politeness. Le
     // Default for missing project name
     const projectName = config.name || 'unknown-project';
 
+    // Design system context injection
+    let designSystemSection = '';
+    const designSystemDir = config.designSystemDir;
+    if (designSystemDir && typeof designSystemDir === 'string' && fs.existsSync(designSystemDir)) {
+      const allowedExts = ['.css', '.scss', '.less', '.ts', '.tsx', '.js', '.jsx', '.json', '.md', '.txt'];
+      const files = fs.readdirSync(designSystemDir).filter(f => {
+        const ext = path.extname(f).toLowerCase();
+        return allowedExts.includes(ext);
+      }).sort();
+
+      if (files.length > 0) {
+        let fileContents = '';
+        for (const file of files) {
+          const filePath = path.join(designSystemDir, file);
+          try {
+            const stat = fs.statSync(filePath);
+            if (stat.isFile()) {
+              const content = fs.readFileSync(filePath, 'utf-8');
+              fileContents += `\n### ${file}\n\`\`\`\n${content}\n\`\`\`\n`;
+            }
+          } catch (e) {
+            // Skip unreadable files
+          }
+        }
+        if (fileContents) {
+          designSystemSection = `
+<design_system>
+## Design System Reference
+${fileContents}</design_system>`;
+        }
+      }
+    }
+
     return `<claude_context project="${projectName}">
 ${currentWorkSection}
 <project_state>
@@ -573,7 +606,7 @@ ${projectState} - ${projectStateDescription}
 <tech_stack>
 ${techStack}
 </tech_stack>${modeTag}
-</claude_context>${jettypodEssentials}
+</claude_context>${designSystemSection}${jettypodEssentials}
 ${communicationStyle}
 ${outputRules}`;
   },
@@ -671,8 +704,58 @@ async function generateClaude(options = {}) {
   }
 }
 
+/**
+ * Sync Claude hook files from claude-hooks/ source templates to .jettypod/hooks/
+ * Uses content hashing — only copies when source differs from installed.
+ * Called on every CLI invocation via ensureClaudeHooks().
+ */
+function syncClaudeHookFiles() {
+  const sourceDir = path.join(__dirname, 'claude-hooks');
+  const destDir = path.join('.jettypod', 'hooks');
+
+  if (!fs.existsSync(sourceDir) || !fs.existsSync('.jettypod')) {
+    return; // No source hooks or no jettypod project
+  }
+
+  if (!fs.existsSync(destDir)) {
+    fs.mkdirSync(destDir, { recursive: true });
+  }
+
+  // Only sync the 3 hooks that are installed by init
+  const hooksToSync = [
+    'global-guardrails.js',
+    'protect-claude-md.js',
+    'enforce-skill-activation.js'
+  ];
+
+  const crypto = require('crypto');
+  const hash = (content) => crypto.createHash('md5').update(content).digest('hex');
+
+  for (const hookFile of hooksToSync) {
+    const sourcePath = path.join(sourceDir, hookFile);
+    const destPath = path.join(destDir, hookFile);
+
+    if (!fs.existsSync(sourcePath)) continue;
+
+    const sourceContent = fs.readFileSync(sourcePath, 'utf-8');
+
+    // Skip if installed hook is already up to date
+    if (fs.existsSync(destPath)) {
+      const destContent = fs.readFileSync(destPath, 'utf-8');
+      if (hash(sourceContent) === hash(destContent)) continue;
+    }
+
+    fs.copyFileSync(sourcePath, destPath);
+    fs.chmodSync(destPath, 0o755);
+  }
+}
+
 // Ensure Claude Code hooks are up to date (called on every jettypod launch)
 function ensureClaudeHooks() {
+  // Sync hook FILES from claude-hooks/ source templates to .jettypod/hooks/
+  // Uses content hashing — only copies when source differs from installed
+  syncClaudeHookFiles();
+
   // Create .claude directory if needed
   if (!fs.existsSync('.claude')) {
     fs.mkdirSync('.claude', { recursive: true });
@@ -1233,6 +1316,15 @@ if (fs.existsSync('.git')) {
 // Runs independently of .git check since subdirectories don't have .git files
 ensureJettypodSymlink();
 
+// Sync Claude Code hook files and settings on every CLI invocation
+if (fs.existsSync('.jettypod')) {
+  try {
+    ensureClaudeHooks();
+  } catch (err) {
+    // Don't fail CLI if hook sync fails
+  }
+}
+
 if (!commandsWithoutDb.includes(command) && fs.existsSync('.jettypod')) {
   try {
     const { validateOnStartup } = require('./lib/database');
@@ -1250,7 +1342,8 @@ if (!commandsWithoutDb.includes(command) && fs.existsSync('.jettypod')) {
         console.log(`🧹 Cleaned ${cleaned} stale merge lock(s) from previous session`);
       }
     } catch (lockCleanupErr) {
-      // Non-fatal: don't block CLI startup if cleanup fails
+      // Non-fatal: don't block CLI startup, but log so failures are visible
+      console.warn(`Warning: Merge lock cleanup failed: ${lockCleanupErr.message}`);
     }
   } catch (err) {
     console.error('');
@@ -1384,12 +1477,11 @@ switch (command) {
       const workCommands = require('./lib/work-commands/index.js');
       try {
         // Parse merge flags and optional work item ID from args
-        const withTransition = args.includes('--with-transition');
         const releaseLock = args.includes('--release-lock');
         // Find numeric arg that isn't a flag
         const workItemId = args.find(a => /^\d+$/.test(a)) ? parseInt(args.find(a => /^\d+$/.test(a))) : null;
 
-        await workCommands.mergeWork({ withTransition, releaseLock, workItemId });
+        await workCommands.mergeWork({ releaseLock, workItemId });
       } catch (err) {
         console.error(`Error: ${err.message}`);
         process.exit(1);

package/lib/bdd-preflight.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function checkCucumberInstalled(projectRoot) {
+  const cucumberPath = path.join(projectRoot, 'node_modules', '@cucumber', 'cucumber');
+  const exists = fs.existsSync(cucumberPath);
+  return {
+    id: 'cucumber-installed',
+    label: '@cucumber/cucumber installed',
+    passed: exists,
+    error: exists ? null : '@cucumber/cucumber is not installed. Run: npm install --save-dev @cucumber/cucumber',
+  };
+}
+
+function checkTestBddScript(projectRoot) {
+  const pkgPath = path.join(projectRoot, 'package.json');
+  let hasScript = false;
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+      hasScript = !!(pkg.scripts && pkg.scripts['test:bdd']);
+    } catch (_) {
+      // Corrupt or unreadable package.json — treat as missing script
+    }
+  }
+  return {
+    id: 'test-bdd-script',
+    label: 'test:bdd script in package.json',
+    passed: hasScript,
+    error: hasScript ? null : 'Missing "test:bdd" script in package.json. Add: "test:bdd": "NODE_ENV=test cucumber-js"',
+  };
+}
+
+function checkCucumberConfig(projectRoot) {
+  const configPath = path.join(projectRoot, 'cucumber.js');
+  const exists = fs.existsSync(configPath);
+  return {
+    id: 'cucumber-config',
+    label: 'cucumber.js config file',
+    passed: exists,
+    error: exists ? null : 'Missing cucumber.js configuration file in project root',
+  };
+}
+
+function checkFeaturesDirectory(projectRoot) {
+  const featuresDir = path.join(projectRoot, 'features');
+  const stepDefsDir = path.join(projectRoot, 'features', 'step_definitions');
+  const exists = fs.existsSync(featuresDir) && fs.existsSync(stepDefsDir);
+  return {
+    id: 'features-directory',
+    label: 'features/ directory with step_definitions/',
+    passed: exists,
+    error: exists ? null : 'Missing features/ directory or features/step_definitions/ subdirectory',
+  };
+}
+
+function checkSupportDirectory(projectRoot) {
+  const supportDir = path.join(projectRoot, 'features', 'support');
+  const hooksFile = path.join(supportDir, 'hooks.js');
+  const exists = fs.existsSync(supportDir) && fs.existsSync(hooksFile);
+  return {
+    id: 'support-hooks',
+    label: 'features/support/hooks.js',
+    passed: exists,
+    error: exists ? null : 'Missing features/support/hooks.js file',
+  };
+}
+
+function buildSetupPrompt(projectRoot, failedChecks) {
+  const missing = failedChecks.map(c => `- ${c.label}: ${c.error}`).join('\n');
+  return `The following BDD test infrastructure is missing in this project:\n\n${missing}\n\nPlease set up the missing BDD test infrastructure so tests can run.`;
+}
+
+function checkBddPrerequisites(projectRoot) {
+  const checks = [
+    checkCucumberInstalled(projectRoot),
+    checkTestBddScript(projectRoot),
+    checkCucumberConfig(projectRoot),
+    checkFeaturesDirectory(projectRoot),
+    checkSupportDirectory(projectRoot),
+  ];
+
+  const ready = checks.every(c => c.passed);
+  const failed = checks.filter(c => !c.passed);
+
+  const result = { ready, checks };
+  if (!ready) {
+    result.setupPrompt = buildSetupPrompt(projectRoot, failed);
+  }
+
+  return result;
+}
+
+module.exports = { checkBddPrerequisites };