jettypod 4.4.45 → 4.4.47

package/jettypod.js

@@ -1303,6 +1303,23 @@ switch (command) {
         console.error(`Error: ${err.message}`);
         process.exit(1);
       }
+    } else if (subcommand === 'tests') {
+      // Create worktree for writing BDD tests
+      const featureId = parseInt(args[1]);
+      if (!featureId) {
+        console.log('Usage: jettypod work tests <feature-id>');
+        console.log('');
+        console.log('Creates a worktree for writing BDD tests for a feature.');
+        console.log('Tests are written in isolation, then merged with: jettypod work merge');
+        process.exit(1);
+      }
+      const workCommands = require('./lib/work-commands/index.js');
+      try {
+        await workCommands.testsWork(featureId);
+      } catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
     } else {
       // CRITICAL SAFETY CHECK: Prevent work status changes from within a worktree
       // This prevents cleanup failures and orphaned worktrees
@@ -2303,76 +2320,127 @@ Quick commands:
     const workflowSubcommand = args[0];
 
     if (workflowSubcommand === 'status') {
+      // workflow status <work-item-id> - shows skill execution history for a work item
+      const workItemId = args[1] ? parseInt(args[1]) : null;
       const { getDb, waitForMigrations } = require('./lib/database');
-      const { getCurrentBranch } = require('./lib/workflow-checkpoint');
 
       try {
         const db = getDb();
         await waitForMigrations();
-        const currentBranch = getCurrentBranch();
 
-        const checkpoints = await new Promise((resolve, reject) => {
-          db.all(
-            `SELECT * FROM workflow_checkpoints ORDER BY updated_at DESC`,
-            [],
-            (err, rows) => {
-              if (err) reject(err);
-              else resolve(rows || []);
+        if (workItemId) {
+          // Show skill executions for specific work item
+          const executions = await new Promise((resolve, reject) => {
+            db.all(
+              `SELECT * FROM skill_executions WHERE work_item_id = ? ORDER BY started_at ASC`,
+              [workItemId],
+              (err, rows) => {
+                if (err) reject(err);
+                else resolve(rows || []);
+              }
+            );
+          });
+
+          const gates = await new Promise((resolve, reject) => {
+            db.all(
+              `SELECT * FROM workflow_gates WHERE work_item_id = ?`,
+              [workItemId],
+              (err, rows) => {
+                if (err) reject(err);
+                else resolve(rows || []);
+              }
+            );
+          });
+
+          console.log(`Workflow Status for #${workItemId}`);
+          console.log('─'.repeat(50));
+          console.log('');
+          console.log('Skill Executions:');
+          if (executions.length === 0) {
+            console.log('  (none)');
+          } else {
+            for (const exec of executions) {
+              console.log(`  ${exec.skill_name}: ${exec.status}`);
             }
-          );
-        });
+          }
 
-        if (checkpoints.length === 0) {
-          console.log('No interrupted workflows found.');
-        } else {
-          console.log('Interrupted Workflows');
-          console.log('─'.repeat(90));
           console.log('');
-          console.log(
-            'ID'.padEnd(4) +
-            'Skill'.padEnd(18) +
-            'Step'.padEnd(10) +
-            'Work Item'.padEnd(12) +
-            'Branch'.padEnd(38) +
-            'Last Active'
-          );
-          console.log('─'.repeat(90));
-
-          for (const cp of checkpoints) {
-            const stepInfo = cp.total_steps
-              ? `${cp.current_step}/${cp.total_steps}`
-              : `${cp.current_step}`;
-            const isCurrent = cp.branch_name === currentBranch;
-            const branchDisplay = cp.branch_name.length > 35
-              ? cp.branch_name.substring(0, 32) + '...'
-              : cp.branch_name;
-            const branchWithMarker = branchDisplay + (isCurrent ? ' *' : '');
-
-            // Format time ago
-            const updatedAt = new Date(cp.updated_at);
-            const now = new Date();
-            const diffMs = now - updatedAt;
-            const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
-            const diffDays = Math.floor(diffHours / 24);
-            const timeAgo = diffDays > 0 ? `${diffDays}d ago` : diffHours > 0 ? `${diffHours}h ago` : 'just now';
+          console.log('Gates:');
+          if (gates.length === 0) {
+            console.log('  (none)');
+          } else {
+            for (const gate of gates) {
+              console.log(`  ${gate.gate_name}: ${gate.passed_at ? 'PASSED' : 'NOT PASSED'}`);
+            }
+          }
+        } else {
+          // No ID - show all interrupted workflows (legacy behavior)
+          const { getCurrentBranch } = require('./lib/workflow-checkpoint');
+          const currentBranch = getCurrentBranch();
 
+          const checkpoints = await new Promise((resolve, reject) => {
+            db.all(
+              `SELECT * FROM workflow_checkpoints ORDER BY updated_at DESC`,
+              [],
+              (err, rows) => {
+                if (err) reject(err);
+                else resolve(rows || []);
+              }
+            );
+          });
+
+          if (checkpoints.length === 0) {
+            console.log('No interrupted workflows found.');
+          } else {
+            console.log('Interrupted Workflows');
+            console.log('─'.repeat(90));
+            console.log('');
             console.log(
-              String(cp.id).padEnd(4) +
-              cp.skill_name.padEnd(18) +
-              stepInfo.padEnd(10) +
-              `#${cp.work_item_id || '-'}`.padEnd(12) +
-              branchWithMarker.padEnd(38) +
-              timeAgo
+              'ID'.padEnd(4) +
+              'Skill'.padEnd(18) +
+              'Step'.padEnd(10) +
+              'Work Item'.padEnd(12) +
+              'Branch'.padEnd(38) +
+              'Last Active'
             );
-          }
+            console.log('─'.repeat(90));
+
+            for (const cp of checkpoints) {
+              const stepInfo = cp.total_steps
+                ? `${cp.current_step}/${cp.total_steps}`
+                : `${cp.current_step}`;
+              const isCurrent = cp.branch_name === currentBranch;
+              const branchDisplay = cp.branch_name.length > 35
+                ? cp.branch_name.substring(0, 32) + '...'
+                : cp.branch_name;
+              const branchWithMarker = branchDisplay + (isCurrent ? ' *' : '');
+
+              // Format time ago
+              const updatedAt = new Date(cp.updated_at);
+              const now = new Date();
+              const diffMs = now - updatedAt;
+              const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+              const diffDays = Math.floor(diffHours / 24);
+              const timeAgo = diffDays > 0 ? `${diffDays}d ago` : diffHours > 0 ? `${diffHours}h ago` : 'just now';
+
+              console.log(
+                String(cp.id).padEnd(4) +
+                cp.skill_name.padEnd(18) +
+                stepInfo.padEnd(10) +
+                `#${cp.work_item_id || '-'}`.padEnd(12) +
+                branchWithMarker.padEnd(38) +
+                timeAgo
+              );
+            }
 
-          console.log('');
-          console.log(`${checkpoints.length} interrupted workflow(s)`);
-          console.log('');
-          console.log('Commands:');
-          console.log('  jettypod workflow show <id>     Show workflow details');
-          console.log('  jettypod workflow resume <id>   Resume a workflow');
-          console.log('  jettypod workflow abort <id>    Abort and clean up a workflow');
+            console.log('');
+            console.log(`${checkpoints.length} interrupted workflow(s)`);
+            console.log('');
+            console.log('Commands:');
+            console.log('  jettypod workflow show <id>     Show workflow details');
+            console.log('  jettypod workflow resume <id>   Resume a workflow');
+            console.log('  jettypod workflow abort <id>    Abort and clean up a workflow');
+          }
         }
       } catch (err) {
         console.error(`Error: ${err.message}`);
@@ -2435,73 +2503,44 @@ Quick commands:
         process.exit(1);
       }
     } else if (workflowSubcommand === 'resume') {
+      // workflow resume - finds interrupted workflows (in-progress skill executions)
       const { getDb, waitForMigrations } = require('./lib/database');
-      const { getCheckpoint, getCurrentBranch } = require('./lib/workflow-checkpoint');
 
       try {
         const db = getDb();
         await waitForMigrations();
-        const currentBranch = getCurrentBranch();
-        const workflowId = args[1] ? parseInt(args[1]) : null;
 
-        let checkpoint;
-
-        if (workflowId) {
-          // Resume by ID - fetch specific workflow
-          checkpoint = await new Promise((resolve, reject) => {
-            db.get(
-              `SELECT * FROM workflow_checkpoints WHERE id = ?`,
-              [workflowId],
-              (err, row) => {
-                if (err) reject(err);
-                else resolve(row);
-              }
-            );
-          });
+        // Find all in-progress skill executions
+        const inProgressExecutions = await new Promise((resolve, reject) => {
+          db.all(
+            `SELECT se.*, wi.title as work_item_title
+             FROM skill_executions se
+             LEFT JOIN work_items wi ON se.work_item_id = wi.id
+             WHERE se.status = 'in_progress'
+             ORDER BY se.started_at DESC`,
+            [],
+            (err, rows) => {
+              if (err) reject(err);
+              else resolve(rows || []);
+            }
+          );
+        });
 
-          if (!checkpoint) {
-            console.log(`Error: No workflow found with ID ${workflowId}`);
-            console.log('');
-            console.log('Use "jettypod workflow status" to see available workflows.');
-            process.exit(1);
-          }
+        if (inProgressExecutions.length === 0) {
+          console.log('No interrupted workflow found');
         } else {
-          // No ID - check current branch
-          checkpoint = await getCheckpoint(db, currentBranch);
-
-          if (!checkpoint) {
-            console.log('No interrupted workflow on current branch.');
+          for (const exec of inProgressExecutions) {
+            console.log('Found interrupted workflow:');
+            console.log(`  Skill: ${exec.skill_name}`);
+            console.log(`  Work Item: #${exec.work_item_id}${exec.work_item_title ? ` - ${exec.work_item_title}` : ''}`);
+            console.log(`  Step ${exec.step_reached}`);
+            console.log(`  Started: ${exec.started_at}`);
+            if (exec.context_json) {
+              console.log(`  Context: ${exec.context_json}`);
+            }
             console.log('');
-            console.log('Use "jettypod workflow status" to see workflows on other branches,');
-            console.log('or specify an ID: "jettypod workflow resume <id>"');
-            process.exit(0);
           }
         }
-
-        // Display resume info
-        const stepInfo = checkpoint.total_steps
-          ? `Step ${checkpoint.current_step} of ${checkpoint.total_steps}`
-          : `Step ${checkpoint.current_step}`;
-
-        const needsBranchSwitch = checkpoint.branch_name !== currentBranch;
-
-        console.log('Resuming Workflow');
-        console.log('─'.repeat(50));
-        console.log('');
-        console.log(`  Skill:      ${checkpoint.skill_name}`);
-        console.log(`  Progress:   ${stepInfo}`);
-        console.log(`  Work Item:  ${checkpoint.work_item_id ? '#' + checkpoint.work_item_id : '-'}`);
-        console.log(`  Branch:     ${checkpoint.branch_name}`);
-        console.log('');
-
-        if (needsBranchSwitch) {
-          console.log(`Switching to branch: ${checkpoint.branch_name}`);
-          console.log('');
-        }
-
-        console.log('[Triggering skill continuation]');
-        // Note: Actual skill triggering would be implemented here
-        // For now, this displays the intent to continue the workflow
       } catch (err) {
         console.error(`Error: ${err.message}`);
         process.exit(1);
@@ -2580,14 +2619,343 @@ Quick commands:
         console.error(`Error: ${err.message}`);
         process.exit(1);
       }
+    } else if (workflowSubcommand === 'start') {
+      // workflow start <skill> <work-item-id>
+      // Validates gates, creates skill execution record
+      const skillName = args[1];
+      const workItemId = parseInt(args[2]);
+
+      if (!skillName || !workItemId) {
+        console.log('Usage: jettypod workflow start <skill> <work-item-id>');
+        console.log('');
+        console.log('Starts a skill for a work item after validating prerequisite gates.');
+        console.log('');
+        console.log('Example: jettypod workflow start speed-mode 42');
+        process.exit(1);
+      }
+
+      const { getDb, waitForMigrations } = require('./lib/database');
+
+      try {
+        const db = getDb();
+        await waitForMigrations();
+
+        // Define gate requirements for each skill
+        const gateRequirements = {
+          'speed-mode': ['feature_planning_complete'],
+          'stable-mode': ['speed_mode_complete'],
+          'production-mode': ['stable_mode_complete'],
+          'feature-planning': [],
+          'epic-planning': []
+        };
+
+        const requiredGates = gateRequirements[skillName] || [];
+
+        // Check prerequisite gates
+        const passedGates = await new Promise((resolve, reject) => {
+          db.all(
+            `SELECT gate_name FROM workflow_gates WHERE work_item_id = ? AND passed_at IS NOT NULL`,
+            [workItemId],
+            (err, rows) => {
+              if (err) reject(err);
+              else resolve(rows ? rows.map(r => r.gate_name) : []);
+            }
+          );
+        });
+
+        const missingGates = requiredGates.filter(g => !passedGates.includes(g));
+
+        if (missingGates.length > 0) {
+          console.log(`Gate validation failed: ${missingGates.join(', ')}`);
+          process.exit(1);
+        }
+
+        // Create skill execution record
+        await new Promise((resolve, reject) => {
+          db.run(
+            `INSERT INTO skill_executions (work_item_id, skill_name, status, step_reached)
+             VALUES (?, ?, 'in_progress', 1)`,
+            [workItemId, skillName],
+            (err) => {
+              if (err) reject(err);
+              else resolve();
+            }
+          );
+        });
+
+        console.log(`Started ${skillName} for #${workItemId}`);
+      } catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    } else if (workflowSubcommand === 'complete') {
+      // workflow complete <skill> <work-item-id>
+      // Marks skill execution as completed, passes output gate
+      const skillName = args[1];
+      const workItemId = parseInt(args[2]);
+
+      if (!skillName || !workItemId) {
+        console.log('Usage: jettypod workflow complete <skill> <work-item-id>');
+        console.log('');
+        console.log('Completes a skill and marks its output gate as passed.');
+        console.log('');
+        console.log('Example: jettypod workflow complete speed-mode 42');
+        process.exit(1);
+      }
+
+      const { getDb, waitForMigrations } = require('./lib/database');
+
+      try {
+        const db = getDb();
+        await waitForMigrations();
+
+        // Check if skill is in progress
+        const execution = await new Promise((resolve, reject) => {
+          db.get(
+            `SELECT * FROM skill_executions WHERE work_item_id = ? AND skill_name = ? AND status = 'in_progress'`,
+            [workItemId, skillName],
+            (err, row) => {
+              if (err) reject(err);
+              else resolve(row);
+            }
+          );
+        });
+
+        if (!execution) {
+          console.log(`No in-progress execution found for ${skillName} on #${workItemId}`);
+          process.exit(1);
+        }
+
+        // Update skill execution to completed
+        await new Promise((resolve, reject) => {
+          db.run(
+            `UPDATE skill_executions SET status = 'completed', completed_at = datetime('now')
+             WHERE work_item_id = ? AND skill_name = ? AND status = 'in_progress'`,
+            [workItemId, skillName],
+            (err) => {
+              if (err) reject(err);
+              else resolve();
+            }
+          );
+        });
+
+        // Mark output gate as passed
+        const outputGate = `${skillName.replace(/-/g, '_')}_complete`;
+        await new Promise((resolve, reject) => {
+          db.run(
+            `INSERT OR REPLACE INTO workflow_gates (work_item_id, gate_name, passed_at)
+             VALUES (?, ?, datetime('now'))`,
+            [workItemId, outputGate],
+            (err) => {
+              if (err) reject(err);
+              else resolve();
+            }
+          );
+        });
+
+        console.log(`Completed ${skillName} for #${workItemId}`);
+      } catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    } else if (workflowSubcommand === 'checkpoint') {
+      // workflow checkpoint <work-item-id> --step=N [--context='{"key":"value"}']
+      // Updates step progress and optionally stores context
+      const workItemId = parseInt(args[1]);
+      const stepArg = args.find(a => a.startsWith('--step='));
+      const contextArg = args.find(a => a.startsWith('--context='));
+
+      if (!workItemId) {
+        console.log('Usage: jettypod workflow checkpoint <work-item-id> --step=N [--context=JSON]');
+        console.log('');
+        console.log('Updates checkpoint progress for an in-progress skill execution.');
+        console.log('');
+        console.log('Example: jettypod workflow checkpoint 42 --step=3');
+        console.log('Example: jettypod workflow checkpoint 42 --step=2 --context=\'{"iteration":5}\'');
+        process.exit(1);
+      }
+
+      const { getDb, waitForMigrations } = require('./lib/database');
+
+      try {
+        const db = getDb();
+        await waitForMigrations();
+
+        // Find in-progress skill execution
+        const execution = await new Promise((resolve, reject) => {
+          db.get(
+            `SELECT * FROM skill_executions WHERE work_item_id = ? AND status = 'in_progress'`,
+            [workItemId],
+            (err, row) => {
+              if (err) reject(err);
+              else resolve(row);
+            }
+          );
+        });
+
+        if (!execution) {
+          console.log(`No in-progress skill execution found for #${workItemId}`);
+          process.exit(1);
+        }
+
+        // Build update query
+        const updates = [];
+        const values = [];
+
+        if (stepArg) {
+          const step = parseInt(stepArg.split('=')[1]);
+          updates.push('step_reached = ?');
+          values.push(step);
+        }
+
+        if (contextArg) {
+          const contextJson = contextArg.split('=').slice(1).join('=').replace(/^'|'$/g, '');
+          updates.push('context_json = ?');
+          values.push(contextJson);
+        }
+
+        if (updates.length === 0) {
+          console.log('No updates specified. Use --step=N and/or --context=JSON');
+          process.exit(1);
+        }
+
+        values.push(workItemId);
+
+        await new Promise((resolve, reject) => {
+          db.run(
+            `UPDATE skill_executions SET ${updates.join(', ')} WHERE work_item_id = ? AND status = 'in_progress'`,
+            values,
+            (err) => {
+              if (err) reject(err);
+              else resolve();
+            }
+          );
+        });
+
+        console.log(`Checkpoint updated for #${workItemId}`);
+      } catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    } else if (workflowSubcommand === 'gate') {
+      // workflow gate pass <work-item-id> <gate-name>
+      // workflow gate check <work-item-id>
+      const gateAction = args[1];
+      const workItemId = parseInt(args[2]);
+
+      if (!gateAction || !workItemId) {
+        console.log('Usage: jettypod workflow gate <action> <work-item-id> [gate-name]');
+        console.log('');
+        console.log('Actions:');
+        console.log('  pass <id> <gate>   Mark a gate as passed');
+        console.log('  check <id>         Show all gates for a work item');
+        console.log('');
+        console.log('Example: jettypod workflow gate pass 42 feature_planning_complete');
+        console.log('Example: jettypod workflow gate check 42');
+        process.exit(1);
+      }
+
+      const { getDb, waitForMigrations } = require('./lib/database');
+
+      try {
+        const db = getDb();
+        await waitForMigrations();
+
+        if (gateAction === 'pass') {
+          const gateName = args[3];
+
+          if (!gateName) {
+            console.log('Usage: jettypod workflow gate pass <work-item-id> <gate-name>');
+            process.exit(1);
+          }
+
+          await new Promise((resolve, reject) => {
+            db.run(
+              `INSERT OR REPLACE INTO workflow_gates (work_item_id, gate_name, passed_at)
+               VALUES (?, ?, datetime('now'))`,
+              [workItemId, gateName],
+              (err) => {
+                if (err) reject(err);
+                else resolve();
+              }
+            );
+          });
+
+          console.log(`Gate passed: ${gateName}`);
+        } else if (gateAction === 'check') {
+          // Get all known gates for this skill workflow
+          const knownGates = [
+            'feature_planning_complete',
+            'speed_mode_complete',
+            'stable_mode_complete',
+            'production_mode_complete'
+          ];
+
+          const passedGates = await new Promise((resolve, reject) => {
+            db.all(
+              `SELECT gate_name, passed_at FROM workflow_gates WHERE work_item_id = ?`,
+              [workItemId],
+              (err, rows) => {
+                if (err) reject(err);
+                else resolve(rows || []);
+              }
+            );
+          });
+
+          const passedGateMap = {};
+          for (const g of passedGates) {
+            passedGateMap[g.gate_name] = g.passed_at;
+          }
+
+          console.log(`Gates for #${workItemId}:`);
+          console.log('');
+
+          for (const gateName of knownGates) {
+            if (passedGateMap[gateName]) {
+              console.log(`${gateName}: PASSED`);
+            } else {
+              console.log(`${gateName}: NOT PASSED`);
+            }
+          }
+
+          // Also show any custom gates
+          const customGates = passedGates.filter(g => !knownGates.includes(g.gate_name));
+          for (const g of customGates) {
+            console.log(`${g.gate_name}: PASSED`);
+          }
+        } else {
+          console.log(`Unknown gate action: ${gateAction}`);
+          console.log('Use "pass" or "check"');
+          process.exit(1);
+        }
+      } catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    } else if (workflowSubcommand === '--help') {
+      console.log('Usage: jettypod workflow <command>');
+      console.log('');
+      console.log('Commands:');
+      console.log('  start <skill> <id>       Start a skill for a work item (validates gates)');
+      console.log('  complete <skill> <id>    Complete a skill (marks gates passed)');
+      console.log('  checkpoint <id>          Update checkpoint progress');
+      console.log('  gate <action> <id>       Manage workflow gates');
+      console.log('  resume                   Find interrupted workflows');
+      console.log('  status <id>              Show workflow status for a work item');
+      console.log('');
+      console.log('Legacy Commands:');
+      console.log('  show <id>                Show checkpoint details');
+      console.log('  abort <id>               Abort a checkpoint');
     } else {
       console.log('Usage: jettypod workflow <command>');
       console.log('');
       console.log('Commands:');
-      console.log('  status          List all interrupted workflows');
-      console.log('  show <id>       Show workflow details');
-      console.log('  resume [id]     Resume a workflow');
-      console.log('  abort <id>      Abort and clean up a workflow');
+      console.log('  start <skill> <id>       Start a skill for a work item (validates gates)');
+      console.log('  complete <skill> <id>    Complete a skill (marks gates passed)');
+      console.log('  checkpoint <id>          Update checkpoint progress');
+      console.log('  gate <action> <id>       Manage workflow gates');
+      console.log('  resume                   Find interrupted workflows');
+      console.log('  status <id>              Show workflow status for a work item');
     }
     break;
   }