jettypod 4.4.34 → 4.4.36

package/hooks/pre-commit

@@ -1,30 +1,61 @@
 #!/usr/bin/env node
 
-const { exportAll } = require('jettypod/lib/db-export');
+// JettyPod pre-commit hook: Block direct commits to main branch
+// This is the standalone version used for BDD testing
+// The production version is in lib/git-hooks/pre-commit
+
 const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
 
-(async () => {
+// Check if direct commits to main should be blocked
+function checkBranchRestriction() {
   try {
-    // Export databases to JSON
-    await exportAll();
-
-    // Stage the JSON files
-    try {
-      execSync('git add .jettypod/snapshots/work.json', { stdio: 'inherit' });
-      execSync('git add .jettypod/snapshots/database.json', { stdio: 'inherit' });
-    } catch (gitErr) {
-      // Log warning but don't block commit
-      console.error('Pre-commit hook warning: Failed to stage snapshot files');
-      console.error(`  ${gitErr.message}`);
-      console.error('  Commit will proceed but snapshots may not be included');
+    // Get current branch name
+    const branch = execSync('git symbolic-ref --short HEAD', {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    }).trim();
+
+    // Only restrict main/master branches
+    if (branch !== 'main' && branch !== 'master') {
+      return true; // Allow commits on feature branches
     }
 
-    // Always exit successfully to allow commit to proceed
-    process.exit(0);
+    // Check if this is a merge commit (MERGE_HEAD exists)
+    const gitDir = execSync('git rev-parse --git-dir', {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    }).trim();
+
+    if (fs.existsSync(path.join(gitDir, 'MERGE_HEAD'))) {
+      return true; // Allow merge commits on main
+    }
+
+    // Block direct commits to main
+    console.error('');
+    console.error('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.error('❌ Direct commits to main are not allowed');
+    console.error('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.error('');
+    console.error('Use the JettyPod workflow instead:');
+    console.error('');
+    console.error('  jettypod work start <work-item-id>');
+    console.error('');
+    console.error('This creates a feature branch where you can commit freely.');
+    console.error('When done, use \'jettypod work done\' to merge back to main.');
+    console.error('');
+    return false;
   } catch (err) {
-    // Log warning but don't block commit
-    console.error('Pre-commit hook warning:', err.message);
-    console.error('  Commit will proceed but snapshots were not updated');
-    process.exit(0);
+    // If we can't determine branch (detached HEAD, etc.), allow the commit
+    return true;
   }
-})();
+}
+
+// Check branch restriction first
+if (!checkBranchRestriction()) {
+  process.exit(1);
+}
+
+// Allow commit
+process.exit(0);

package/jettypod.js

@@ -257,6 +257,11 @@ Skills auto-activate and MUST complete their full workflow:
 ❌ DO NOT manually create chores when a skill should generate them
 ✅ ALWAYS let skills complete autonomously before taking manual actions
 
+## 🔄 Session Start: Check for Interrupted Workflows
+On session start, run: \`jettypod workflow resume\`
+If an interrupted workflow is found, ASK the user if they want to resume it.
+Do not assume - the user may want to start fresh or work on something else.
+
 ## Basic Commands (for non-workflow operations)
 jettypod work create epic "<title>"
 jettypod work create feature "<title>" --parent=<id>
@@ -2297,40 +2302,292 @@ Quick commands:
   case 'workflow': {
     const workflowSubcommand = args[0];
 
-    if (workflowSubcommand === 'resume') {
-      const { getDb } = require('./lib/database');
-      const { getCheckpoint, getCurrentBranch } = require('./lib/workflow-checkpoint');
+    if (workflowSubcommand === 'status') {
+      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 (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(
+              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');
+        }
+      } catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    } else if (workflowSubcommand === 'show') {
+      const workflowId = parseInt(args[1]);
+
+      if (!workflowId) {
+        console.log('Usage: jettypod workflow show <id>');
+        console.log('');
+        console.log('Use "jettypod workflow status" to see available workflow IDs.');
+        process.exit(1);
+      }
+
+      const { getDb, waitForMigrations } = require('./lib/database');
 
       try {
         const db = getDb();
-        const branchName = getCurrentBranch();
-        const checkpoint = await getCheckpoint(db, branchName);
+        await waitForMigrations();
+
+        const checkpoint = await new Promise((resolve, reject) => {
+          db.get(
+            `SELECT * FROM workflow_checkpoints WHERE id = ?`,
+            [workflowId],
+            (err, row) => {
+              if (err) reject(err);
+              else resolve(row);
+            }
+          );
+        });
 
         if (!checkpoint) {
-          console.log('No interrupted workflow found');
+          console.log(`Error: No workflow found with ID ${workflowId}`);
+          console.log('');
+          console.log('Use "jettypod workflow status" to see available workflows.');
+          process.exit(1);
+        }
+
+        const stepInfo = checkpoint.total_steps
+          ? `Step ${checkpoint.current_step} of ${checkpoint.total_steps}`
+          : `Step ${checkpoint.current_step}`;
+
+        console.log('Workflow Details');
+        console.log('─'.repeat(50));
+        console.log('');
+        console.log(`  ID:         ${checkpoint.id}`);
+        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(`  Started:    ${checkpoint.created_at}`);
+        console.log(`  Last Active: ${checkpoint.updated_at}`);
+        console.log('');
+        console.log('Actions:');
+        console.log(`  jettypod workflow resume ${workflowId}   Continue this workflow`);
+        console.log(`  jettypod workflow abort ${workflowId}    Cancel and clean up`);
+      } catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    } else if (workflowSubcommand === 'resume') {
+      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);
+              }
+            );
+          });
+
+          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);
+          }
         } else {
-          const stepInfo = checkpoint.total_steps
-            ? `Step ${checkpoint.current_step} of ${checkpoint.total_steps}`
-            : `Step ${checkpoint.current_step}`;
+          // No ID - check current branch
+          checkpoint = await getCheckpoint(db, currentBranch);
 
-          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}`);
+          if (!checkpoint) {
+            console.log('No interrupted workflow on current branch.');
+            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);
+      }
+    } else if (workflowSubcommand === 'abort') {
+      const workflowId = parseInt(args[1]);
+
+      if (!workflowId) {
+        console.log('Usage: jettypod workflow abort <id>');
+        console.log('');
+        console.log('Use "jettypod workflow status" to see workflow IDs.');
+        process.exit(1);
+      }
+
+      const { getDb, waitForMigrations } = require('./lib/database');
+
+      try {
+        const db = getDb();
+        await waitForMigrations();
+
+        // First fetch the checkpoint to display info
+        const checkpoint = await new Promise((resolve, reject) => {
+          db.get(
+            `SELECT * FROM workflow_checkpoints WHERE id = ?`,
+            [workflowId],
+            (err, row) => {
+              if (err) reject(err);
+              else resolve(row);
+            }
+          );
+        });
+
+        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);
+        }
+
+        // Delete the checkpoint
+        await new Promise((resolve, reject) => {
+          db.run(
+            `DELETE FROM workflow_checkpoints WHERE id = ?`,
+            [workflowId],
+            (err) => {
+              if (err) reject(err);
+              else resolve();
+            }
+          );
+        });
+
+        // Display abort confirmation
+        const stepInfo = checkpoint.total_steps
+          ? `Step ${checkpoint.current_step} of ${checkpoint.total_steps}`
+          : `Step ${checkpoint.current_step}`;
+
+        console.log('Abort 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('');
+        console.log('This will:');
+        console.log('  - Delete the checkpoint from the database');
+        console.log('  - NOT delete the branch or any code changes');
+        console.log('  - Allow you to restart the skill fresh');
+        console.log('');
+        console.log('Checkpoint deleted. Workflow aborted.');
+        console.log('');
+        if (checkpoint.work_item_id) {
+          console.log(`To restart: jettypod work start ${checkpoint.work_item_id}`);
+        }
       } catch (err) {
         console.error(`Error: ${err.message}`);
         process.exit(1);
       }
     } else {
-      console.log('Usage: jettypod workflow resume');
+      console.log('Usage: jettypod workflow <command>');
       console.log('');
       console.log('Commands:');
-      console.log('  resume    Check for and resume interrupted workflows');
+      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');
     }
     break;
   }

package/lib/git-hooks/pre-commit

@@ -1,11 +1,60 @@
 #!/usr/bin/env node
 
-// Pre-commit hook: Run tests before allowing commit
+// Pre-commit hook: Block direct commits to main + run tests
 
 const { execSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 
+// Check if direct commits to main should be blocked
+function checkBranchRestriction() {
+  try {
+    // Get current branch name
+    const branch = execSync('git symbolic-ref --short HEAD', {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    }).trim();
+
+    // Only restrict main/master branches
+    if (branch !== 'main' && branch !== 'master') {
+      return true; // Allow commits on feature branches
+    }
+
+    // Check if this is a merge commit (MERGE_HEAD exists)
+    const gitDir = execSync('git rev-parse --git-dir', {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    }).trim();
+
+    if (fs.existsSync(path.join(gitDir, 'MERGE_HEAD'))) {
+      return true; // Allow merge commits on main
+    }
+
+    // Block direct commits to main
+    console.error('');
+    console.error('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.error('❌ Direct commits to main are not allowed');
+    console.error('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.error('');
+    console.error('Use the JettyPod workflow instead:');
+    console.error('');
+    console.error('  jettypod work start <work-item-id>');
+    console.error('');
+    console.error('This creates a feature branch where you can commit freely.');
+    console.error('When done, use \'jettypod work done\' to merge back to main.');
+    console.error('');
+    return false;
+  } catch (err) {
+    // If we can't determine branch (detached HEAD, etc.), allow the commit
+    return true;
+  }
+}
+
+// First check branch restriction
+if (!checkBranchRestriction()) {
+  process.exit(1);
+}
+
 // Check if we're in a real project (not a test directory)
 const packageJsonPath = path.join(process.cwd(), 'package.json');
 if (!fs.existsSync(packageJsonPath)) {

package/package.json

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