jettypod 4.1.4 → 4.1.6

package/cucumber.js

@@ -1,6 +1,5 @@
 module.exports = {
   default: {
-    paths: ['features/**/*.feature'],
     require: ['features/**/steps.js', 'features/**/simple-steps.js', 'features/**/*.steps.js'],
     format: ['progress'],
     publishQuiet: true

package/lib/current-work.js

@@ -1,5 +1,7 @@
 const fs = require('fs');
 const path = require('path');
+const { getDb } = require('./database');
+const { getSessionByWorktreePath, getAllActiveSessions } = require('./worktree-sessions');
 
 /**
  * Get path to current-work.json file
@@ -10,37 +12,100 @@ function getCurrentWorkPath() {
 }
 
 /**
- * Get current work item from file
+ * Get current work item from worktree session database
  * @returns {Object|null} Current work item or null if not set
- * @throws {Error} If file exists but cannot be read due to permissions
  */
-function getCurrentWork() {
-  const currentWorkPath = getCurrentWorkPath();
+async function getCurrentWork() {
+  const worktreePath = process.cwd();
+  const db = getDb();
 
-  if (!fs.existsSync(currentWorkPath)) {
+  // Query worktree session and join with work_items
+  let row;
+  try {
+    row = await new Promise((resolve, reject) => {
+      db.get(
+        `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 worktree_sessions ws
+         JOIN work_items wi ON ws.work_item_id = wi.id
+         LEFT JOIN work_items parent ON wi.parent_id = parent.id
+         LEFT JOIN work_items epic ON wi.epic_id = epic.id
+         WHERE ws.worktree_path = ?`,
+        [worktreePath],
+        (err, row) => {
+          if (err) {
+            return reject(err);
+          }
+          resolve(row);
+        }
+      );
+    });
+  } catch (dbErr) {
+    // Handle database errors gracefully - log but don't crash
+    console.error('Database error querying current work:', dbErr.message);
+    // Return null instead of throwing - graceful degradation
     return null;
   }
 
-  try {
-    const content = fs.readFileSync(currentWorkPath, 'utf-8');
-    const workItem = JSON.parse(content);
-
+  if (row) {
     // Validate required fields
-    if (!workItem.id || !workItem.title || !workItem.type) {
-      console.warn('Warning: Current work file is missing required fields, ignoring');
+    if (!row.id || !row.title || !row.type) {
+      console.warn('Warning: Work item is missing required fields, ignoring');
       return null;
     }
+    return row;
+  }
 
-    return workItem;
-  } catch (err) {
-    if (err.code === 'EACCES') {
-      throw new Error(`No read permission for current work file: ${currentWorkPath}`);
+  // No session found - check if we should warn about main branch
+  try {
+    const allSessions = await getAllActiveSessions();
+    if (allSessions.length > 0) {
+      // Get all work items in ONE query using IN clause
+      const ids = allSessions.map(s => s.work_item_id);
+      const placeholders = ids.map(() => '?').join(',');
+
+      let workItems;
+      try {
+        workItems = await new Promise((resolve, reject) => {
+          db.all(
+            `SELECT id, title FROM work_items WHERE id IN (${placeholders})`,
+            ids,
+            (err, rows) => {
+              if (err) reject(err);
+              else resolve(rows || []);
+            }
+          );
+        });
+      } catch (workItemErr) {
+        // Database error getting work items - log but continue
+        console.error('Database error getting work items:', workItemErr.message);
+        workItems = [];
+      }
+
+      // Create map of id -> title
+      const titleMap = {};
+      for (const wi of workItems) {
+        titleMap[wi.id] = wi.title;
+      }
+
+      // Display warnings
+      console.warn('No active work in main branch');
+      console.warn('\nActive work in other worktrees:');
+      for (const session of allSessions) {
+        const title = titleMap[session.work_item_id];
+        if (title) {
+          console.warn(`  • ${title} (${session.worktree_path})`);
+        }
+      }
     }
-
-    // Corrupted JSON - warn but don't throw
-    console.warn(`Warning: Corrupted current work file: ${err.message}`);
-    return null;
+  } catch (listErr) {
+    // Ignore listing errors - gracefully fail
+    console.error('Error listing active sessions:', listErr.message);
   }
+
+  return null;
 }
 
 /**
@@ -71,54 +136,41 @@ function validateWorkItem(workItem) {
 }
 
 /**
- * Set current work item to file
+ * Set current work item in worktree session database
  * @param {Object} workItem - Work item to set as current
- * @throws {Error} If workItem is invalid or file cannot be written
+ * @throws {Error} If workItem is invalid
  */
-function setCurrentWork(workItem) {
+async function setCurrentWork(workItem) {
   validateWorkItem(workItem);
 
-  const currentWorkPath = getCurrentWorkPath();
-  const jettypodDir = path.dirname(currentWorkPath);
+  const { createOrUpdateSession } = require('./worktree-sessions');
+  const { execSync } = require('child_process');
+  const worktreePath = process.cwd();
 
+  // Get current branch name
+  let branchName;
   try {
-    // Ensure .jettypod directory exists
-    if (!fs.existsSync(jettypodDir)) {
-      fs.mkdirSync(jettypodDir, { recursive: true });
-    }
-
-    // Check write permission
-    if (fs.existsSync(jettypodDir)) {
-      fs.accessSync(jettypodDir, fs.constants.W_OK);
-    }
-
-    fs.writeFileSync(currentWorkPath, JSON.stringify(workItem, null, 2));
+    branchName = execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim();
   } catch (err) {
-    if (err.code === 'EACCES') {
-      throw new Error(`No write permission for directory: ${jettypodDir}`);
-    }
-    throw new Error(`Failed to write current work file: ${err.message}`);
+    branchName = 'unknown';
   }
+
+  // Create or update worktree session in database
+  await createOrUpdateSession(worktreePath, workItem.id, branchName);
 }
 
 /**
- * Clear current work item file
- * @throws {Error} If file cannot be deleted due to permissions
+ * Clear current work item from worktree session database
+ * @throws {Error} If session cannot be deleted
  */
-function clearCurrentWork() {
-  const currentWorkPath = getCurrentWorkPath();
-
-  if (!fs.existsSync(currentWorkPath)) {
-    return;
-  }
+async function clearCurrentWork() {
+  const { deleteSession } = require('./worktree-sessions');
+  const worktreePath = process.cwd();
 
   try {
-    fs.unlinkSync(currentWorkPath);
+    await deleteSession(worktreePath);
   } catch (err) {
-    if (err.code === 'EACCES') {
-      throw new Error(`No permission to delete current work file: ${currentWorkPath}`);
-    }
-    throw new Error(`Failed to clear current work file: ${err.message}`);
+    throw new Error(`Failed to clear current work session: ${err.message}`);
   }
 }
 

package/lib/migrations/016-worktree-sessions-table.js

@@ -0,0 +1,84 @@
+/**
+ * Migration: Create worktree_sessions table
+ *
+ * Purpose: Track which work item is active in each worktree to support multiple
+ * concurrent Claude Code instances working on different features simultaneously.
+ *
+ * Why this is critical:
+ * - Enable true concurrent development with multiple worktrees
+ * - Prevent confusion when Claude switches between worktrees
+ * - Provide centralized visibility of what's active where
+ * - Support automatic cleanup when work items are completed
+ */
+
+module.exports = {
+  id: '016-worktree-sessions-table',
+  description: 'Create worktree_sessions table for multi-worktree current work tracking',
+
+  async up(db) {
+    return new Promise((resolve, reject) => {
+      db.run(`
+        CREATE TABLE IF NOT EXISTS worktree_sessions (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          worktree_path TEXT UNIQUE NOT NULL,
+          work_item_id INTEGER NOT NULL,
+          branch_name TEXT NOT NULL,
+          last_activity DATETIME DEFAULT CURRENT_TIMESTAMP,
+          FOREIGN KEY (work_item_id) REFERENCES work_items(id)
+        )
+      `, (err) => {
+        if (err) {
+          return reject(err);
+        }
+
+        // Create index on worktree_path for fast lookups
+        db.run(`
+          CREATE INDEX IF NOT EXISTS idx_worktree_sessions_path
+          ON worktree_sessions(worktree_path)
+        `, (err) => {
+          if (err) {
+            return reject(err);
+          }
+
+          // Create index on work_item_id for reverse lookups
+          db.run(`
+            CREATE INDEX IF NOT EXISTS idx_worktree_sessions_work_item
+            ON worktree_sessions(work_item_id)
+          `, (err) => {
+            if (err) {
+              return reject(err);
+            }
+
+            resolve();
+          });
+        });
+      });
+    });
+  },
+
+  async down(db) {
+    return new Promise((resolve, reject) => {
+      // Drop indexes first
+      db.run('DROP INDEX IF EXISTS idx_worktree_sessions_work_item', (err) => {
+        if (err) {
+          return reject(err);
+        }
+
+        db.run('DROP INDEX IF EXISTS idx_worktree_sessions_path', (err) => {
+          if (err) {
+            return reject(err);
+          }
+
+          // Drop table
+          db.run('DROP TABLE IF EXISTS worktree_sessions', (err) => {
+            if (err) {
+              return reject(err);
+            }
+
+            resolve();
+          });
+        });
+      });
+    });
+  }
+};

package/lib/worktree-manager.js

@@ -100,9 +100,34 @@ async function createWorktree(workItem, options = {}) {
     });
 
     // Step 2: Create git worktree
-    // Always branch from 'main' to avoid nested worktrees
+    // Branch from the default branch (main, master, etc.) to avoid nested worktrees
     try {
-      execSync(`git worktree add -b "${branchName}" "${worktreePath}" main`, {
+      // Detect the default branch name
+      let defaultBranch;
+      try {
+        // Try to get the default branch from git config
+        defaultBranch = execSync('git symbolic-ref refs/remotes/origin/HEAD', {
+          cwd: gitRoot,
+          encoding: 'utf8',
+          stdio: ['pipe', 'pipe', 'pipe']
+        }).trim().replace('refs/remotes/origin/', '');
+      } catch {
+        // Fallback: check which common branch names exist
+        try {
+          execSync('git rev-parse --verify main', { cwd: gitRoot, stdio: 'pipe' });
+          defaultBranch = 'main';
+        } catch {
+          try {
+            execSync('git rev-parse --verify master', { cwd: gitRoot, stdio: 'pipe' });
+            defaultBranch = 'master';
+          } catch {
+            // Last resort: use HEAD
+            defaultBranch = 'HEAD';
+          }
+        }
+      }
+
+      execSync(`git worktree add -b "${branchName}" "${worktreePath}" ${defaultBranch}`, {
         cwd: gitRoot,
         stdio: 'pipe'
       });

package/lib/worktree-sessions.js

@@ -0,0 +1,186 @@
+/**
+ * Worktree Session Management
+ *
+ * CRUD operations for tracking which work item is active in each worktree.
+ * Enables multiple concurrent Claude Code instances working in different worktrees.
+ */
+
+const { getDb } = require('./database');
+
+/**
+ * Create or update a worktree session
+ *
+ * @param {string} worktreePath - Absolute path to the worktree
+ * @param {number} workItemId - ID of the work item
+ * @param {string} branchName - Git branch name
+ * @returns {Promise<void>}
+ */
+function createOrUpdateSession(worktreePath, workItemId, branchName) {
+  const db = getDb();
+
+  return new Promise((resolve, reject) => {
+    db.run(
+      `INSERT OR REPLACE INTO worktree_sessions
+       (worktree_path, work_item_id, branch_name, last_activity)
+       VALUES (?, ?, ?, datetime('now'))`,
+      [worktreePath, workItemId, branchName],
+      (err) => {
+        if (err) {
+          // Provide user-friendly error messages based on error type
+          if (err.code === 'SQLITE_BUSY') {
+            return reject(new Error('Database is locked by another process. Please try again in a moment.'));
+          } else if (err.code === 'SQLITE_CORRUPT') {
+            return reject(new Error('Database is corrupted. Please run: jettypod init --reset'));
+          } else if (err.code === 'SQLITE_CANTOPEN') {
+            return reject(new Error('Cannot open database. Check file permissions or run: jettypod init'));
+          } else if (err.code === 'SQLITE_READONLY') {
+            return reject(new Error('Database is read-only. Check file permissions.'));
+          }
+          // Generic database error
+          console.error('Database error in createOrUpdateSession:', err);
+          return reject(new Error(`Failed to create/update worktree session: ${err.message}`));
+        }
+        resolve();
+      }
+    );
+  });
+}
+
+/**
+ * Get session by worktree path
+ *
+ * @param {string} worktreePath - Absolute path to the worktree
+ * @returns {Promise<object|null>} Session object or null if not found
+ */
+function getSessionByWorktreePath(worktreePath) {
+  const db = getDb();
+
+  return new Promise((resolve, reject) => {
+    db.get(
+      `SELECT * FROM worktree_sessions WHERE worktree_path = ?`,
+      [worktreePath],
+      (err, row) => {
+        if (err) {
+          // Provide user-friendly error messages
+          if (err.code === 'SQLITE_BUSY') {
+            return reject(new Error('Database is locked. Please try again in a moment.'));
+          } else if (err.code === 'SQLITE_CORRUPT') {
+            return reject(new Error('Database is corrupted. Please run: jettypod init --reset'));
+          } else if (err.code === 'SQLITE_CANTOPEN') {
+            return reject(new Error('Cannot open database. Run: jettypod init'));
+          }
+          console.error('Database error in getSessionByWorktreePath:', err);
+          return reject(new Error(`Failed to get worktree session: ${err.message}`));
+        }
+        resolve(row || null);
+      }
+    );
+  });
+}
+
+/**
+ * Get all active worktree sessions
+ *
+ * @returns {Promise<Array>} Array of session objects
+ */
+function getAllActiveSessions() {
+  const db = getDb();
+
+  return new Promise((resolve, reject) => {
+    db.all(
+      `SELECT * FROM worktree_sessions ORDER BY last_activity DESC`,
+      [],
+      (err, rows) => {
+        if (err) {
+          // Provide user-friendly error messages
+          if (err.code === 'SQLITE_BUSY') {
+            return reject(new Error('Database is locked. Please try again in a moment.'));
+          } else if (err.code === 'SQLITE_CORRUPT') {
+            return reject(new Error('Database is corrupted. Please run: jettypod init --reset'));
+          } else if (err.code === 'SQLITE_CANTOPEN') {
+            return reject(new Error('Cannot open database. Run: jettypod init'));
+          }
+          console.error('Database error in getAllActiveSessions:', err);
+          return reject(new Error(`Failed to get active sessions: ${err.message}`));
+        }
+        resolve(rows || []);
+      }
+    );
+  });
+}
+
+/**
+ * Delete session by worktree path
+ *
+ * @param {string} worktreePath - Absolute path to the worktree
+ * @returns {Promise<void>}
+ */
+function deleteSession(worktreePath) {
+  const db = getDb();
+
+  return new Promise((resolve, reject) => {
+    db.run(
+      `DELETE FROM worktree_sessions WHERE worktree_path = ?`,
+      [worktreePath],
+      (err) => {
+        if (err) {
+          // Provide user-friendly error messages
+          if (err.code === 'SQLITE_BUSY') {
+            return reject(new Error('Database is locked. Please try again in a moment.'));
+          } else if (err.code === 'SQLITE_CORRUPT') {
+            return reject(new Error('Database is corrupted. Please run: jettypod init --reset'));
+          } else if (err.code === 'SQLITE_CANTOPEN') {
+            return reject(new Error('Cannot open database. Run: jettypod init'));
+          } else if (err.code === 'SQLITE_READONLY') {
+            return reject(new Error('Database is read-only. Check file permissions.'));
+          }
+          console.error('Database error in deleteSession:', err);
+          return reject(new Error(`Failed to delete worktree session: ${err.message}`));
+        }
+        resolve();
+      }
+    );
+  });
+}
+
+/**
+ * Delete session by work item ID
+ *
+ * @param {number} workItemId - ID of the work item
+ * @returns {Promise<void>}
+ */
+function deleteSessionByWorkItem(workItemId) {
+  const db = getDb();
+
+  return new Promise((resolve, reject) => {
+    db.run(
+      `DELETE FROM worktree_sessions WHERE work_item_id = ?`,
+      [workItemId],
+      (err) => {
+        if (err) {
+          // Provide user-friendly error messages
+          if (err.code === 'SQLITE_BUSY') {
+            return reject(new Error('Database is locked. Please try again in a moment.'));
+          } else if (err.code === 'SQLITE_CORRUPT') {
+            return reject(new Error('Database is corrupted. Please run: jettypod init --reset'));
+          } else if (err.code === 'SQLITE_CANTOPEN') {
+            return reject(new Error('Cannot open database. Run: jettypod init'));
+          } else if (err.code === 'SQLITE_READONLY') {
+            return reject(new Error('Database is read-only. Check file permissions.'));
+          }
+          console.error('Database error in deleteSessionByWorkItem:', err);
+          return reject(new Error(`Failed to delete session by work item: ${err.message}`));
+        }
+        resolve();
+      }
+    );
+  });
+}
+
+module.exports = {
+  createOrUpdateSession,
+  getSessionByWorktreePath,
+  getAllActiveSessions,
+  deleteSession,
+  deleteSessionByWorkItem
+};

package/package.json

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