jettypod 4.4.8 → 4.4.10

package/claude-hooks/enforce-skill-activation.js

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+/**
+ * Claude Code PreToolUse Hook
+ *
+ * Prevents bypassing the feature-planning skill by detecting direct chore
+ * creation under unplanned features.
+ */
+
+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', () => {
+  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 || '';
+
+    // Check for chore creation under a parent feature
+    const parentId = extractParentFeatureId(command);
+    if (!parentId) {
+      // Not a chore creation with --parent, allow
+      allow();
+      return;
+    }
+
+    // Check if feature-planning skill is active
+    // Look for skill markers in the session or transcript
+    if (isSkillActive(hookInput)) {
+      allow();
+      return;
+    }
+
+    // Query database to check if feature is planned
+    checkFeaturePlanned(cwd, parentId)
+      .then(isPlanned => {
+        if (isPlanned) {
+          allow();
+        } else {
+          deny(
+            'Cannot create chores under unplanned feature',
+            'Invoke the feature-planning skill first to plan this feature before creating chores.'
+          );
+        }
+      })
+      .catch(err => {
+        // On error, allow (fail open) but log
+        console.error('Hook error:', err.message);
+        allow();
+      });
+
+  } catch (err) {
+    // If we can't parse input, allow the action (fail open)
+    console.error('Hook error:', err.message);
+    allow();
+  }
+});
+
+/**
+ * Extract parent feature ID from chore creation command
+ * @param {string} command - The bash command
+ * @returns {number|null} The parent feature ID or null
+ */
+function extractParentFeatureId(command) {
+  // Match: jettypod work create chore "..." "..." --parent=123
+  // or: jettypod work create chore "..." "..." --parent 123
+  const match = command.match(/work\s+create\s+chore\s+.*--parent[=\s]+(\d+)/);
+  return match ? parseInt(match[1], 10) : null;
+}
+
+/**
+ * Check if feature-planning skill is currently active
+ * @param {Object} hookInput - The hook input object
+ * @returns {boolean} True if skill is active
+ */
+function isSkillActive(hookInput) {
+  // Check for skill activation markers
+  // The skill system may set active_skill in context
+  if (hookInput.active_skill === 'feature-planning') {
+    return true;
+  }
+
+  // Check transcript for recent skill activation
+  const transcriptPath = hookInput.transcript_path;
+  if (transcriptPath && fs.existsSync(transcriptPath)) {
+    try {
+      const transcript = fs.readFileSync(transcriptPath, 'utf8');
+      // Look for recent feature-planning skill activation
+      // The skill adds markers like "feature-planning skill is active"
+      const lines = transcript.split('\n').slice(-100); // Last 100 lines
+      for (const line of lines) {
+        if (line.includes('feature-planning') &&
+            (line.includes('skill is active') || line.includes('skill activated'))) {
+          return true;
+        }
+      }
+    } catch (err) {
+      // Ignore read errors
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Check if a feature has been planned (has scenario_file and discovery_rationale)
+ * @param {string} cwd - Current working directory
+ * @param {number} featureId - The feature ID to check
+ * @returns {Promise<boolean>} True if feature is planned
+ */
+async function checkFeaturePlanned(cwd, featureId) {
+  // Find the database path
+  const dbPath = findDatabasePath(cwd);
+  if (!dbPath) {
+    // No database found, allow (not a jettypod project)
+    return true;
+  }
+
+  // Use better-sqlite3 for synchronous queries if available,
+  // otherwise fall back to spawning sqlite3 CLI
+  try {
+    const sqlite3 = require('better-sqlite3');
+    const db = sqlite3(dbPath, { readonly: true });
+    const row = db.prepare(
+      `SELECT scenario_file, discovery_rationale FROM work_items WHERE id = ? AND type = 'feature'`
+    ).get(featureId);
+    db.close();
+
+    if (!row) return false;
+    const hasScenario = Boolean(row.scenario_file && row.scenario_file.trim());
+    const hasRationale = Boolean(row.discovery_rationale && row.discovery_rationale.trim());
+    return hasScenario && hasRationale;
+  } catch (err) {
+    // better-sqlite3 not available, use CLI
+    return checkFeaturePlannedCLI(dbPath, featureId);
+  }
+}
+
+/**
+ * Check if feature is planned using sqlite3 CLI
+ * @param {string} dbPath - Path to database
+ * @param {number} featureId - Feature ID
+ * @returns {Promise<boolean>} True if planned
+ */
+function checkFeaturePlannedCLI(dbPath, featureId) {
+  return new Promise((resolve) => {
+    const { spawnSync } = require('child_process');
+    const result = spawnSync('sqlite3', [
+      dbPath,
+      `SELECT scenario_file, discovery_rationale FROM work_items WHERE id = ${featureId} AND type = 'feature'`
+    ], { encoding: 'utf-8' });
+
+    if (result.error || result.status !== 0) {
+      resolve(true); // On error, allow
+      return;
+    }
+
+    const output = result.stdout.trim();
+    if (!output) {
+      resolve(false); // Feature not found
+      return;
+    }
+
+    // SQLite output is pipe-delimited
+    const [scenarioFile, rationale] = output.split('|');
+    const hasScenario = Boolean(scenarioFile && scenarioFile.trim());
+    const hasRationale = Boolean(rationale && rationale.trim());
+    resolve(hasScenario && hasRationale);
+  });
+}
+
+/**
+ * Find the jettypod database path
+ * @param {string} cwd - Starting directory
+ * @returns {string|null} Database path or null
+ */
+function findDatabasePath(cwd) {
+  let dir = 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, suggestion) {
+  const reason = `❌ ${message}\n\n💡 Hint: ${suggestion}`;
+
+  console.log(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "deny",
+      permissionDecisionReason: reason
+    }
+  }));
+  process.exit(0);
+}

package/jettypod.js

@@ -756,6 +756,14 @@ async function initializeProject() {
     console.log('🔒 Claude Code hook installed');
   }
 
+  // Install enforce-skill-activation hook
+  const enforceHookSource = path.join(__dirname, 'claude-hooks', 'enforce-skill-activation.js');
+  const enforceHookDest = path.join('.jettypod', 'hooks', 'enforce-skill-activation.js');
+  if (fs.existsSync(enforceHookSource)) {
+    fs.copyFileSync(enforceHookSource, enforceHookDest);
+    fs.chmodSync(enforceHookDest, 0o755);
+  }
+
   // Create Claude Code settings
   if (!fs.existsSync('.claude')) {
     fs.mkdirSync('.claude', { recursive: true });
@@ -776,6 +784,10 @@ async function initializeProject() {
           {
             matcher: 'Write',
             hooks: [{ type: 'command', command: '.jettypod/hooks/protect-claude-md.js' }]
+          },
+          {
+            matcher: 'Bash',
+            hooks: [{ type: 'command', command: '.jettypod/hooks/enforce-skill-activation.js' }]
           }
         ]
       }

package/lib/planning-status.js

@@ -0,0 +1,68 @@
+/**
+ * Planning status helpers for checking if features have been through feature-planning
+ */
+
+const { getDb } = require('./database');
+
+/**
+ * Check if a feature has been planned (has scenario_file and discovery_rationale)
+ * @param {number} featureId - The work item ID to check
+ * @returns {Promise<boolean>} True if feature has been planned
+ */
+function isFeaturePlanned(featureId) {
+  return new Promise((resolve, reject) => {
+    const db = getDb();
+
+    db.get(
+      `SELECT scenario_file, discovery_rationale
+       FROM work_items
+       WHERE id = ? AND type = 'feature'`,
+      [featureId],
+      (err, row) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+
+        if (!row) {
+          // Feature doesn't exist
+          resolve(false);
+          return;
+        }
+
+        // Feature is planned if both fields are non-null and non-empty
+        const hasScenario = Boolean(row.scenario_file && row.scenario_file.trim());
+        const hasRationale = Boolean(row.discovery_rationale && row.discovery_rationale.trim());
+
+        resolve(hasScenario && hasRationale);
+      }
+    );
+  });
+}
+
+/**
+ * Get the parent feature ID for a chore
+ * @param {string} command - The jettypod command being executed
+ * @returns {number|null} The parent feature ID or null if not a chore creation
+ */
+function extractParentFeatureId(command) {
+  // Match: jettypod work create chore "..." "..." --parent=123
+  const match = command.match(/work\s+create\s+chore\s+.*--parent[=\s]+(\d+)/);
+  return match ? parseInt(match[1], 10) : null;
+}
+
+/**
+ * Check if a file path looks like a feature scenario file
+ * @param {string} filePath - The file path to check
+ * @returns {boolean} True if it's a .feature file in the features directory
+ */
+function isFeatureFile(filePath) {
+  if (!filePath) return false;
+  return filePath.includes('/features/') && filePath.endsWith('.feature');
+}
+
+module.exports = {
+  isFeaturePlanned,
+  extractParentFeatureId,
+  isFeatureFile
+};

package/package.json

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