jettypod 4.4.9 → 4.4.11

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' }]
           }
         ]
       }
@@ -2171,6 +2183,47 @@ Quick commands:
     break;
   }
 
+  case 'workflow': {
+    const workflowSubcommand = args[0];
+
+    if (workflowSubcommand === 'resume') {
+      const { getDb } = require('./lib/database');
+      const { getCheckpoint, getCurrentBranch } = require('./lib/workflow-checkpoint');
+
+      try {
+        const db = getDb();
+        const branchName = getCurrentBranch();
+        const checkpoint = await getCheckpoint(db, branchName);
+
+        if (!checkpoint) {
+          console.log('No interrupted workflow found');
+        } else {
+          const stepInfo = checkpoint.total_steps
+            ? `Step ${checkpoint.current_step} of ${checkpoint.total_steps}`
+            : `Step ${checkpoint.current_step}`;
+
+          console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+          console.log('Found interrupted workflow');
+          console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+          console.log(`Skill: ${checkpoint.skill_name}`);
+          console.log(stepInfo);
+          if (checkpoint.work_item_id) {
+            console.log(`Work Item: #${checkpoint.work_item_id}`);
+          }
+        }
+      } catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    } else {
+      console.log('Usage: jettypod workflow resume');
+      console.log('');
+      console.log('Commands:');
+      console.log('  resume    Check for and resume interrupted workflows');
+    }
+    break;
+  }
+
   default:
     // Smart mode: auto-initialize if needed, otherwise show guidance
     if (!fs.existsSync('.jettypod')) {

package/lib/current-work.js

@@ -34,34 +34,26 @@ async function getCurrentWork() {
     // Not in a git repo or other git error - that's ok
   }
 
-  // Query for in_progress work item
+  // If no work item ID from branch, we're on main - return null
+  // Current work only applies within worktrees, not root/main branch
+  if (!workItemId) {
+    return null;
+  }
+
+  // Query for the specific in_progress work item matching our branch
   let row;
   try {
     row = await new Promise((resolve, reject) => {
-      const query = workItemId
-        ? // If we have an ID from branch name, get that specific item
-          `SELECT
+      const query = `SELECT
             wi.id, wi.title, wi.type, wi.status, wi.parent_id, wi.epic_id,
             parent.title as parent_title,
             epic.title as epic_title
            FROM work_items wi
            LEFT JOIN work_items parent ON wi.parent_id = parent.id
            LEFT JOIN work_items epic ON wi.epic_id = epic.id
-           WHERE wi.id = ? AND wi.status = 'in_progress'`
-        : // Otherwise get any in_progress item (for main branch)
-          `SELECT
-            wi.id, wi.title, wi.type, wi.status, wi.parent_id, wi.epic_id,
-            parent.title as parent_title,
-            epic.title as epic_title
-           FROM work_items wi
-           LEFT JOIN work_items parent ON wi.parent_id = parent.id
-           LEFT JOIN work_items epic ON wi.epic_id = epic.id
-           WHERE wi.status = 'in_progress'
-           LIMIT 1`;
-
-      const params = workItemId ? [workItemId] : [];
+           WHERE wi.id = ? AND wi.status = 'in_progress'`;
 
-      db.get(query, params, (err, row) => {
+      db.get(query, [workItemId], (err, row) => {
         if (err) {
           return reject(err);
         }

package/lib/migrations/016-workflow-checkpoints-table.js

@@ -0,0 +1,70 @@
+/**
+ * Migration: Create workflow_checkpoints table
+ *
+ * Purpose: Enable persistence of workflow state across sessions so interrupted
+ * workflows can be resumed. Stores skill name, current step, and context JSON.
+ *
+ * Why this is critical:
+ * - Crash recovery - resume workflows after unexpected session termination
+ * - Branch-aware - checkpoints are tied to specific worktree/branch context
+ * - Context preservation - stores full workflow state as JSON for resume
+ */
+
+module.exports = {
+  id: '016-workflow-checkpoints-table',
+  description: 'Create workflow_checkpoints table for session resume capability',
+
+  async up(db) {
+    return new Promise((resolve, reject) => {
+      db.run(`
+        CREATE TABLE IF NOT EXISTS workflow_checkpoints (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          skill_name TEXT NOT NULL,
+          current_step INTEGER NOT NULL,
+          total_steps INTEGER,
+          context_json TEXT,
+          branch_name TEXT NOT NULL,
+          work_item_id INTEGER,
+          created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+          updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+        )
+      `, (err) => {
+        if (err) {
+          return reject(err);
+        }
+
+        // Create index on branch_name for quick lookup by current branch
+        db.run(`
+          CREATE INDEX IF NOT EXISTS idx_workflow_checkpoints_branch
+          ON workflow_checkpoints(branch_name)
+        `, (err) => {
+          if (err) {
+            return reject(err);
+          }
+
+          resolve();
+        });
+      });
+    });
+  },
+
+  async down(db) {
+    return new Promise((resolve, reject) => {
+      // Drop index first
+      db.run('DROP INDEX IF EXISTS idx_workflow_checkpoints_branch', (err) => {
+        if (err) {
+          return reject(err);
+        }
+
+        // Drop table
+        db.run('DROP TABLE IF EXISTS workflow_checkpoints', (err) => {
+          if (err) {
+            return reject(err);
+          }
+
+          resolve();
+        });
+      });
+    });
+  }
+};

package/lib/migrations/017-backfill-epic-id.js

@@ -0,0 +1,54 @@
+/**
+ * Migration 017: Backfill epic_id field
+ *
+ * The epic_id field provides a direct reference to the top-level epic,
+ * avoiding tree traversal when querying items by epic.
+ *
+ * This migration backfills epic_id for existing items:
+ * - Features: epic_id = parent_id (where parent is an epic)
+ * - Chores: epic_id = parent's epic_id (inherit from parent)
+ */
+
+module.exports = {
+  id: '017-backfill-epic-id',
+
+  up: (db) => {
+    return new Promise((resolve, reject) => {
+      db.serialize(() => {
+        // Backfill epic_id for features (parent is epic)
+        db.run(`
+          UPDATE work_items
+          SET epic_id = parent_id
+          WHERE type = 'feature'
+            AND parent_id IS NOT NULL
+            AND epic_id IS NULL
+            AND (SELECT type FROM work_items p WHERE p.id = work_items.parent_id) = 'epic'
+        `, (err) => {
+          if (err) return reject(err);
+
+          // Backfill epic_id for chores (inherit from parent)
+          db.run(`
+            UPDATE work_items
+            SET epic_id = (SELECT epic_id FROM work_items p WHERE p.id = work_items.parent_id)
+            WHERE type = 'chore'
+              AND parent_id IS NOT NULL
+              AND epic_id IS NULL
+          `, (err) => {
+            if (err) return reject(err);
+            resolve();
+          });
+        });
+      });
+    });
+  },
+
+  down: (db) => {
+    return new Promise((resolve, reject) => {
+      // Clear all epic_id values
+      db.run(`UPDATE work_items SET epic_id = NULL`, (err) => {
+        if (err) return reject(err);
+        resolve();
+      });
+    });
+  }
+};

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
+};