jettypod 4.4.10 → 4.4.12

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/workflow-checkpoint.js

@@ -0,0 +1,204 @@
+/**
+ * Workflow Checkpoint - Persistence for Session Resume
+ *
+ * This module provides checkpoint creation, update, and retrieval for workflow
+ * state persistence. Enables resuming interrupted workflows across sessions.
+ *
+ * Core principles:
+ * - Branch-aware: checkpoints are tied to specific git branch context
+ * - Atomic updates: each step transition updates the checkpoint
+ * - Context preservation: stores full workflow state as JSON
+ * - Auto-cleanup: checkpoints are deleted on successful completion
+ */
+
+const { execSync } = require('child_process');
+
+/**
+ * Get the current git branch name
+ *
+ * @returns {string} Current branch name
+ */
+function getCurrentBranch() {
+  try {
+    return execSync('git branch --show-current', { encoding: 'utf8' }).trim();
+  } catch (err) {
+    return 'unknown';
+  }
+}
+
+/**
+ * Create a new workflow checkpoint
+ *
+ * @param {Object} db - SQLite database connection
+ * @param {Object} options - Checkpoint options
+ * @param {string} options.skillName - Name of the skill (e.g., 'feature-planning')
+ * @param {number} options.currentStep - Current step number (1-indexed)
+ * @param {number} [options.totalSteps] - Total number of steps (optional)
+ * @param {Object} [options.context] - Workflow context to preserve (optional)
+ * @param {string} [options.branchName] - Git branch name (defaults to current branch)
+ * @param {number} [options.workItemId] - Associated work item ID (optional)
+ * @returns {Promise<Object>} Created checkpoint with id
+ */
+async function createCheckpoint(db, options) {
+  if (!db) {
+    throw new Error('Database connection required');
+  }
+
+  const {
+    skillName,
+    currentStep,
+    totalSteps = null,
+    context = {},
+    branchName = getCurrentBranch(),
+    workItemId = null
+  } = options;
+
+  const contextJson = JSON.stringify(context);
+
+  return new Promise((resolve, reject) => {
+    db.run(
+      `INSERT INTO workflow_checkpoints
+       (skill_name, current_step, total_steps, context_json, branch_name, work_item_id)
+       VALUES (?, ?, ?, ?, ?, ?)`,
+      [skillName, currentStep, totalSteps, contextJson, branchName, workItemId],
+      function(err) {
+        if (err) {
+          reject(err);
+        } else {
+          resolve({
+            id: this.lastID,
+            skill_name: skillName,
+            current_step: currentStep,
+            total_steps: totalSteps,
+            context_json: contextJson,
+            branch_name: branchName,
+            work_item_id: workItemId
+          });
+        }
+      }
+    );
+  });
+}
+
+/**
+ * Update an existing workflow checkpoint
+ *
+ * @param {Object} db - SQLite database connection
+ * @param {string} branchName - Git branch name to identify checkpoint
+ * @param {Object} updates - Fields to update
+ * @param {number} [updates.currentStep] - New step number
+ * @param {number} [updates.totalSteps] - New total steps
+ * @param {Object} [updates.context] - New context (merged with existing)
+ * @returns {Promise<void>}
+ */
+async function updateCheckpoint(db, branchName, updates) {
+  const fields = [];
+  const values = [];
+
+  if (updates.currentStep !== undefined) {
+    fields.push('current_step = ?');
+    values.push(updates.currentStep);
+  }
+
+  if (updates.totalSteps !== undefined) {
+    fields.push('total_steps = ?');
+    values.push(updates.totalSteps);
+  }
+
+  if (updates.context !== undefined) {
+    fields.push('context_json = ?');
+    values.push(JSON.stringify(updates.context));
+  }
+
+  // Always update the updated_at timestamp
+  fields.push('updated_at = CURRENT_TIMESTAMP');
+
+  values.push(branchName);
+
+  return new Promise((resolve, reject) => {
+    db.run(
+      `UPDATE workflow_checkpoints SET ${fields.join(', ')} WHERE branch_name = ?`,
+      values,
+      (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      }
+    );
+  });
+}
+
+/**
+ * Get checkpoint for a specific branch
+ *
+ * @param {Object} db - SQLite database connection
+ * @param {string} [branchName] - Git branch name (defaults to current branch)
+ * @returns {Promise<Object|null>} Checkpoint or null if not found
+ */
+async function getCheckpoint(db, branchName = getCurrentBranch()) {
+  return new Promise((resolve, reject) => {
+    db.get(
+      `SELECT * FROM workflow_checkpoints WHERE branch_name = ?`,
+      [branchName],
+      (err, row) => {
+        if (err) {
+          reject(err);
+        } else if (!row) {
+          resolve(null);
+        } else {
+          // Parse context_json back to object
+          resolve({
+            ...row,
+            context: row.context_json ? JSON.parse(row.context_json) : {}
+          });
+        }
+      }
+    );
+  });
+}
+
+/**
+ * Delete checkpoint for a specific branch (on successful completion)
+ *
+ * @param {Object} db - SQLite database connection
+ * @param {string} [branchName] - Git branch name (defaults to current branch)
+ * @returns {Promise<void>}
+ */
+async function deleteCheckpoint(db, branchName = getCurrentBranch()) {
+  return new Promise((resolve, reject) => {
+    db.run(
+      `DELETE FROM workflow_checkpoints WHERE branch_name = ?`,
+      [branchName],
+      (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      }
+    );
+  });
+}
+
+/**
+ * Check if a checkpoint exists for the current branch
+ *
+ * @param {Object} db - SQLite database connection
+ * @param {string} [branchName] - Git branch name (defaults to current branch)
+ * @returns {Promise<boolean>} True if checkpoint exists
+ */
+async function hasCheckpoint(db, branchName = getCurrentBranch()) {
+  const checkpoint = await getCheckpoint(db, branchName);
+  return checkpoint !== null;
+}
+
+module.exports = {
+  createCheckpoint,
+  updateCheckpoint,
+  getCheckpoint,
+  deleteCheckpoint,
+  hasCheckpoint,
+  getCurrentBranch
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jettypod",
-  "version": "4.4.10",
+  "version": "4.4.12",
   "description": "AI-powered development workflow manager with TDD, BDD, and automatic test generation",
   "main": "jettypod.js",
   "bin": {
@@ -34,10 +34,14 @@
     "test:unit": "NODE_ENV=test jest",
     "test:unit:watch": "NODE_ENV=test jest --watch",
     "test:cleanup": "node scripts/test-cleanup.js",
-    "prepublishOnly": "echo '🔄 Syncing skills to templates...' && cp -r .claude/skills/* skills-templates/ && echo '✅ Skills synced'"
+    "prepublishOnly": "echo '🔄 Syncing skills to templates...' && cp -r .claude/skills/* skills-templates/ && echo '✅ Skills synced'",
+    "dashboard": "npm run dev --prefix apps/dashboard",
+    "dashboard:build": "npm run build --prefix apps/dashboard",
+    "dashboard:start": "npm run start --prefix apps/dashboard"
   },
   "devDependencies": {
     "@cucumber/cucumber": "^10.0.1",
+    "@types/better-sqlite3": "^7.6.13",
     "chai": "^6.0.1",
     "jest": "^30.1.3"
   },
@@ -54,6 +58,7 @@
     "coverageDirectory": "coverage"
   },
   "dependencies": {
+    "better-sqlite3": "^12.5.0",
     "chalk": "^4.1.2",
     "sqlite3": "^5.1.7"
   },

package/skills-templates/chore-mode/SKILL.md

@@ -304,6 +304,9 @@ git add .
 git commit -m "chore: [brief description]"
 git push
 
+# Switch to main repo before merging (merge cannot run from inside worktree)
+cd $(git rev-parse --git-common-dir)/..
+
 # Merge to main (auto-marks chore done)
 jettypod work merge
 ```