jettypod 4.2.11 → 4.4.0

package/lib/current-work.js

@@ -1,7 +1,6 @@
 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
@@ -12,35 +11,62 @@ function getCurrentWorkPath() {
 }
 
 /**
- * Get current work item from worktree session database
+ * Get current work item based on status='in_progress'
+ * Extracts work item ID from worktree branch name if in a worktree,
+ * otherwise returns first in_progress item
  * @returns {Object|null} Current work item or null if not set
  */
 async function getCurrentWork() {
   const worktreePath = process.cwd();
   const db = getDb();
+  const { execSync } = require('child_process');
+
+  // Try to extract work item ID from branch name (worktree naming: "feature/work-123-some-title" or "123-some-title")
+  let workItemId = null;
+  try {
+    const branchName = execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim();
+    // Match either "feature/work-123-" or "123-" at start
+    const match = branchName.match(/(?:feature\/work-|^)(\d+)-/);
+    if (match) {
+      workItemId = parseInt(match[1]);
+    }
+  } catch (err) {
+    // Not in a git repo or other git error - that's ok
+  }
 
-  // Query worktree session and join with work_items
+  // Query for in_progress work item
   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);
+      const query = workItemId
+        ? // If we have an ID from branch name, get that specific item
+          `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] : [];
+
+      db.get(query, params, (err, row) => {
+        if (err) {
+          return reject(err);
         }
-      );
+        resolve(row);
+      });
     });
   } catch (dbErr) {
     // Handle database errors gracefully - log but don't crash
@@ -58,53 +84,6 @@ async function getCurrentWork() {
     return row;
   }
 
-  // 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})`);
-        }
-      }
-    }
-  } catch (listErr) {
-    // Ignore listing errors - gracefully fail
-    console.error('Error listing active sessions:', listErr.message);
-  }
-
   return null;
 }
 
@@ -136,41 +115,75 @@ function validateWorkItem(workItem) {
 }
 
 /**
- * Set current work item in worktree session database
+ * Set current work item by updating status to in_progress
  * @param {Object} workItem - Work item to set as current
  * @throws {Error} If workItem is invalid
  */
 async function setCurrentWork(workItem) {
   validateWorkItem(workItem);
 
-  const { createOrUpdateSession } = require('./worktree-sessions');
-  const { execSync } = require('child_process');
-  const worktreePath = process.cwd();
+  const db = getDb();
 
-  // Get current branch name
-  let branchName;
+  // Update work item status to in_progress
   try {
-    branchName = execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim();
+    await new Promise((resolve, reject) => {
+      db.run(
+        'UPDATE work_items SET status = ? WHERE id = ?',
+        ['in_progress', workItem.id],
+        (err) => {
+          if (err) {
+            return reject(new Error(`Failed to set work item status: ${err.message}`));
+          }
+          resolve();
+        }
+      );
+    });
   } catch (err) {
-    branchName = 'unknown';
+    throw new Error(`Failed to set current work: ${err.message}`);
   }
-
-  // Create or update worktree session in database
-  await createOrUpdateSession(worktreePath, workItem.id, branchName);
 }
 
 /**
- * Clear current work item from worktree session database
- * @throws {Error} If session cannot be deleted
+ * Clear current work item by extracting ID from branch and setting status to backlog
+ * @throws {Error} If work item cannot be found or updated
  */
 async function clearCurrentWork() {
-  const { deleteSession } = require('./worktree-sessions');
-  const worktreePath = process.cwd();
+  const { execSync } = require('child_process');
+  const db = getDb();
 
+  // Extract work item ID from branch name
+  let workItemId = null;
   try {
-    await deleteSession(worktreePath);
+    const branchName = execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim();
+    // Match either "feature/work-123-" or "123-" at start
+    const match = branchName.match(/(?:feature\/work-|^)(\d+)-/);
+    if (match) {
+      workItemId = parseInt(match[1]);
+    }
+  } catch (err) {
+    throw new Error('Cannot determine work item from branch name');
+  }
+
+  if (!workItemId) {
+    throw new Error('Cannot clear current work: no work item ID in branch name');
+  }
+
+  // Update work item status back to backlog
+  try {
+    await new Promise((resolve, reject) => {
+      db.run(
+        'UPDATE work_items SET status = ? WHERE id = ?',
+        ['backlog', workItemId],
+        (err) => {
+          if (err) {
+            return reject(new Error(`Failed to clear work item status: ${err.message}`));
+          }
+          resolve();
+        }
+      );
+    });
   } catch (err) {
-    throw new Error(`Failed to clear current work session: ${err.message}`);
+    throw new Error(`Failed to clear current work: ${err.message}`);
   }
 }
 

package/lib/jettypod-backup.js

@@ -8,16 +8,41 @@
 const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
+const safeDelete = require('./safe-delete');
+
+/**
+ * Get the global backup directory path (in home directory)
+ * @returns {string} Path to global backup directory
+ */
+function getGlobalBackupDir() {
+  const os = require('os');
+  return path.join(os.homedir(), '.jettypod-backups');
+}
+
+/**
+ * Get project-specific identifier for global backups
+ * @param {string} gitRoot - Path to git repository root
+ * @returns {string} Project identifier
+ */
+function getProjectId(gitRoot) {
+  // Use the directory name and a hash of the full path for uniqueness
+  const dirname = path.basename(gitRoot);
+  const hash = require('crypto').createHash('md5').update(gitRoot).digest('hex').slice(0, 8);
+  return `${dirname}-${hash}`;
+}
 
 /**
  * Create a backup of the .jettypod directory
  *
  * @param {string} gitRoot - Absolute path to git repository root
  * @param {string} reason - Human-readable reason for backup (e.g., "cleanup-worktree-1234")
+ * @param {Object} options - Backup options
+ * @param {boolean} options.global - Store backup in home directory (default: false)
  * @returns {Promise<Object>} Result with success status and backup path
  */
-async function createBackup(gitRoot, reason = 'unknown') {
+async function createBackup(gitRoot, reason = 'unknown', options = {}) {
   const jettypodPath = path.join(gitRoot, '.jettypod');
+  const useGlobal = options.global || false;
 
   // Verify .jettypod exists
   if (!fs.existsSync(jettypodPath)) {
@@ -28,8 +53,17 @@ async function createBackup(gitRoot, reason = 'unknown') {
     };
   }
 
+  // Determine backup location
+  let backupBaseDir;
+  if (useGlobal) {
+    const globalDir = getGlobalBackupDir();
+    const projectId = getProjectId(gitRoot);
+    backupBaseDir = path.join(globalDir, projectId);
+  } else {
+    backupBaseDir = path.join(gitRoot, '.git', 'jettypod-backups');
+  }
+
   // Create backup directory if it doesn't exist
-  const backupBaseDir = path.join(gitRoot, '.git', 'jettypod-backups');
   if (!fs.existsSync(backupBaseDir)) {
     fs.mkdirSync(backupBaseDir, { recursive: true });
   }
@@ -89,7 +123,16 @@ async function cleanupOldBackups(backupDir, keepCount = 10) {
     // Delete old backups
     const toDelete = backups.slice(keepCount);
     for (const backup of toDelete) {
-      fs.rmSync(backup.path, { recursive: true, force: true });
+      // SAFETY: Validate backup path before deletion
+      const resolvedPath = path.resolve(backup.path);
+      const isValidBackupPath = (resolvedPath.includes('.git/jettypod-backups') ||
+                                  resolvedPath.includes('.jettypod-backups')) &&
+                                 backup.name.startsWith('jettypod-');
+      if (!isValidBackupPath) {
+        console.warn(`Warning: Skipping suspicious backup path: ${backup.path}`);
+        continue;
+      }
+      fs.rmSync(backup.path, { recursive: true });
     }
   } catch (err) {
     // Non-fatal - just log warning
@@ -98,12 +141,77 @@ async function cleanupOldBackups(backupDir, keepCount = 10) {
 }
 
 /**
- * List available backups
+ * List available backups from both local and global locations
  *
  * @param {string} gitRoot - Absolute path to git repository root
- * @returns {Array} List of backup objects with name, path, timestamp
+ * @param {Object} options - Options
+ * @param {boolean} options.includeGlobal - Include global backups (default: true)
+ * @returns {Array} List of backup objects with name, path, timestamp, location
  */
-function listBackups(gitRoot) {
+function listBackups(gitRoot, options = {}) {
+  const includeGlobal = options.includeGlobal !== false;
+  const allBackups = [];
+
+  // Local backups
+  const localDir = path.join(gitRoot, '.git', 'jettypod-backups');
+  if (fs.existsSync(localDir)) {
+    try {
+      const localBackups = fs.readdirSync(localDir)
+        .filter(name => name.startsWith('jettypod-'))
+        .map(name => {
+          const backupPath = path.join(localDir, name);
+          const stat = fs.statSync(backupPath);
+          return {
+            name: name,
+            path: backupPath,
+            created: stat.mtime,
+            size: getDirectorySize(backupPath),
+            location: 'local'
+          };
+        });
+      allBackups.push(...localBackups);
+    } catch (err) {
+      console.error(`Error reading local backups: ${err.message}`);
+    }
+  }
+
+  // Global backups
+  if (includeGlobal) {
+    const globalDir = getGlobalBackupDir();
+    const projectId = getProjectId(gitRoot);
+    const projectBackupDir = path.join(globalDir, projectId);
+
+    if (fs.existsSync(projectBackupDir)) {
+      try {
+        const globalBackups = fs.readdirSync(projectBackupDir)
+          .filter(name => name.startsWith('jettypod-'))
+          .map(name => {
+            const backupPath = path.join(projectBackupDir, name);
+            const stat = fs.statSync(backupPath);
+            return {
+              name: name,
+              path: backupPath,
+              created: stat.mtime,
+              size: getDirectorySize(backupPath),
+              location: 'global'
+            };
+          });
+        allBackups.push(...globalBackups);
+      } catch (err) {
+        console.error(`Error reading global backups: ${err.message}`);
+      }
+    }
+  }
+
+  // Sort all backups by date, newest first
+  return allBackups.sort((a, b) => b.created - a.created);
+}
+
+/**
+ * List available backups (legacy function for backwards compatibility)
+ * @deprecated Use listBackups with options instead
+ */
+function listBackupsLegacy(gitRoot) {
   const backupBaseDir = path.join(gitRoot, '.git', 'jettypod-backups');
 
   if (!fs.existsSync(backupBaseDir)) {
@@ -182,7 +290,13 @@ async function restoreBackup(gitRoot, backupName = 'latest') {
 
     // Remove current .jettypod
     if (fs.existsSync(jettypodPath)) {
-      fs.rmSync(jettypodPath, { recursive: true, force: true });
+      // SAFETY: Validate jettypod path before deletion
+      const resolvedPath = path.resolve(jettypodPath);
+      const resolvedGitRoot = path.resolve(gitRoot);
+      if (!resolvedPath.startsWith(resolvedGitRoot) || !resolvedPath.endsWith('.jettypod')) {
+        throw new Error(`SAFETY: Refusing to delete ${jettypodPath} - not a valid .jettypod directory`);
+      }
+      fs.rmSync(jettypodPath, { recursive: true });
     }
 
     // Copy backup to .jettypod
@@ -234,5 +348,7 @@ function getDirectorySize(dirPath) {
 module.exports = {
   createBackup,
   listBackups,
-  restoreBackup
+  restoreBackup,
+  getGlobalBackupDir,
+  getProjectId
 };

package/lib/merge-lock.js

@@ -36,11 +36,20 @@ async function acquireMergeLock(db, workItemId, instanceId = null, options = {})
 
   const maxWait = options.maxWait || 60000; // 1 minute default
   const pollInterval = options.pollInterval || 1500; // 1.5 seconds
+  const staleThreshold = options.staleThreshold || 120000; // 2 minutes (reduced from 5 minutes)
   const startTime = Date.now();
 
   // Generate instance identifier
   const lockedBy = instanceId || `${os.hostname()}-${process.pid}`;
 
+  // Proactive cleanup of stale locks before attempting acquisition
+  try {
+    await cleanupStaleLocks(db, staleThreshold);
+  } catch (cleanupErr) {
+    // Log but don't fail - cleanup is best-effort
+    console.warn(`Warning: Failed to cleanup stale locks: ${cleanupErr.message}`);
+  }
+
   while (Date.now() - startTime < maxWait) {
     // Check if lock exists
     const existingLock = await checkExistingLock(db);
@@ -102,6 +111,27 @@ function insertLock(db, workItemId, lockedBy) {
   });
 }
 
+/**
+ * Clean up stale locks that are older than the threshold
+ *
+ * @param {Object} db - SQLite database connection
+ * @param {number} staleThresholdMs - Age threshold in milliseconds (default: 120000 = 2 minutes)
+ * @returns {Promise<void>}
+ */
+function cleanupStaleLocks(db, staleThresholdMs = 120000) {
+  return new Promise((resolve, reject) => {
+    db.run(
+      `DELETE FROM merge_locks
+       WHERE (julianday('now') - julianday(locked_at)) * 86400000 > ?`,
+      [staleThresholdMs],
+      (err) => {
+        if (err) return reject(err);
+        resolve();
+      }
+    );
+  });
+}
+
 /**
  * Create lock handle object with release function
  *