jettypod 4.1.2 → 4.1.4

package/lib/worktree-manager.js

@@ -0,0 +1,636 @@
+/**
+ * Worktree Manager - Database as Single Source of Truth
+ *
+ * This module manages all worktree operations with the database as the single
+ * source of truth. All state is persisted BEFORE any git/filesystem operations.
+ *
+ * Core principles:
+ * - Database is the source of truth (not git or filesystem)
+ * - All operations are transactional (rollback on failure)
+ * - Branch names are ALWAYS stored in DB (never lost)
+ * - Operations are idempotent (safe to retry)
+ */
+
+// Database will be required lazily when implementing actual functions
+// const getDb = require('./database');
+
+/**
+ * Valid worktree statuses
+ */
+const VALID_STATUSES = ['active', 'merging', 'cleanup_pending', 'corrupted'];
+
+/**
+ * Create a worktree for a work item
+ *
+ * @param {Object} workItem - Work item from database (must have id and title)
+ * @param {Object} options - Optional configuration
+ * @param {string} options.repoPath - Path to git repository (defaults to process.cwd())
+ * @param {Object} options.db - Database connection (defaults to global database)
+ * @returns {Promise<Object>} Worktree record with id, work_item_id, branch_name, worktree_path, status
+ */
+async function createWorktree(workItem, options = {}) {
+  if (!workItem || !workItem.id) {
+    return Promise.reject(new Error('Invalid work item: must have id'));
+  }
+
+  const fs = require('fs');
+  const path = require('path');
+  const { execSync } = require('child_process');
+  const { slugify } = require('./git');
+
+  // CRITICAL SAFETY: repoPath MUST be provided - never auto-detect from cwd
+  // Auto-detection from worktrees causes catastrophic repo corruption
+  if (!options.repoPath) {
+    return Promise.reject(new Error('SAFETY: repoPath must be explicitly provided to createWorktree'));
+  }
+
+  const gitRoot = options.repoPath;
+
+  // SAFETY CHECK: Verify gitRoot is actually the main repository
+  try {
+    const gitRootCheck = execSync('git rev-parse --show-toplevel', {
+      cwd: gitRoot,
+      encoding: 'utf8'
+    }).trim();
+
+    // Resolve both paths to handle /var vs /private/var symlink on macOS
+    const resolvedGitRoot = fs.realpathSync(gitRoot);
+    const resolvedGitRootCheck = fs.realpathSync(gitRootCheck);
+
+    if (resolvedGitRootCheck !== resolvedGitRoot) {
+      return Promise.reject(new Error(`SAFETY: Provided repoPath ${gitRoot} does not match git root ${gitRootCheck}`));
+    }
+
+    // Verify .jettypod exists in the git root
+    const jettypodPath = path.join(gitRoot, '.jettypod');
+    if (!fs.existsSync(jettypodPath)) {
+      return Promise.reject(new Error(`SAFETY: .jettypod directory not found in ${gitRoot} - refusing to proceed`));
+    }
+  } catch (err) {
+    return Promise.reject(new Error(`SAFETY: Failed to verify git root: ${err.message}`));
+  }
+
+  const { getDb } = require('./database');
+  const db = options.db || getDb();
+
+  // Generate branch name and worktree path
+  const titleSlug = slugify(workItem.title || 'item');
+  const branchName = `feature/work-${workItem.id}-${titleSlug}`;
+  const worktreeBasePath = path.join(gitRoot, '.jettypod-work');
+  const worktreePath = path.join(worktreeBasePath, `${workItem.id}-${titleSlug}`);
+
+  let worktreeId = null;
+  let branchCreated = false;
+  let worktreeCreated = false;
+
+  try {
+    // Step 1: Create database entry with status='active'
+    // Note: We use 'active' from the start because if anything fails,
+    // we'll delete the entire entry during rollback
+    worktreeId = await new Promise((resolve, reject) => {
+      db.run(
+        `INSERT INTO worktrees (work_item_id, branch_name, worktree_path, status)
+         VALUES (?, ?, ?, 'active')`,
+        [workItem.id, branchName, worktreePath],
+        function(err) {
+          if (err) reject(err);
+          else resolve(this.lastID);
+        }
+      );
+    });
+
+    // Step 2: Create git worktree
+    // Always branch from 'main' to avoid nested worktrees
+    try {
+      execSync(`git worktree add -b "${branchName}" "${worktreePath}" main`, {
+        cwd: gitRoot,
+        stdio: 'pipe'
+      });
+      worktreeCreated = true;
+      branchCreated = true;
+    } catch (gitErr) {
+      throw new Error(`Failed to create git worktree: ${gitErr.message}`);
+    }
+
+    // Step 3: Verify directory exists
+    if (!fs.existsSync(worktreePath)) {
+      throw new Error(`Worktree directory was not created: ${worktreePath}`);
+    }
+
+    // Step 4: Create .jettypod symlink
+    // CRITICAL: Git creates .jettypod directory because snapshots are tracked
+    // We must remove it first to create the symlink to the shared database
+    const jettypodLink = path.join(worktreePath, '.jettypod');
+    const jettypodTarget = path.join(gitRoot, '.jettypod');
+    try {
+      // Remove the git-created .jettypod directory if it exists
+      if (fs.existsSync(jettypodLink)) {
+        const stats = fs.lstatSync(jettypodLink);
+        if (stats.isSymbolicLink()) {
+          // Already a symlink - verify it points to the right place
+          const linkTarget = fs.readlinkSync(jettypodLink);
+          const resolvedLink = path.resolve(path.dirname(jettypodLink), linkTarget);
+          const resolvedTarget = path.resolve(jettypodTarget);
+          if (resolvedLink === resolvedTarget) {
+            // Symlink already correct - nothing to do
+          } else {
+            // Wrong target - remove and recreate
+            fs.unlinkSync(jettypodLink);
+            fs.symlinkSync(jettypodTarget, jettypodLink, 'dir');
+          }
+        } else {
+          // It's a directory - remove it and create symlink
+          fs.rmSync(jettypodLink, { recursive: true, force: true });
+          fs.symlinkSync(jettypodTarget, jettypodLink, 'dir');
+        }
+      } else {
+        // Doesn't exist - create symlink
+        fs.symlinkSync(jettypodTarget, jettypodLink, 'dir');
+      }
+    } catch (symlinkErr) {
+      // Symlink failure is CRITICAL - the worktree won't have access to the database
+      throw new Error(`Failed to create .jettypod symlink: ${symlinkErr.message}`);
+    }
+
+    // Step 5: Return the created worktree record
+    const worktree = await new Promise((resolve, reject) => {
+      db.get('SELECT * FROM worktrees WHERE id = ?', [worktreeId], (err, row) => {
+        if (err) reject(err);
+        else resolve(row);
+      });
+    });
+
+    return worktree;
+
+  } catch (err) {
+    // Transaction rollback
+    console.error(`Worktree creation failed, rolling back: ${err.message}`);
+
+    // Cleanup database entry
+    if (worktreeId) {
+      try {
+        await new Promise((resolve, reject) => {
+          db.run('DELETE FROM worktrees WHERE id = ?', [worktreeId], (err) => {
+            if (err) reject(err);
+            else resolve();
+          });
+        });
+      } catch (dbErr) {
+        console.error(`Failed to rollback database entry: ${dbErr.message}`);
+      }
+    }
+
+    // Cleanup git worktree
+    if (worktreeCreated) {
+      try {
+        execSync(`git worktree remove --force "${worktreePath}"`, {
+          cwd: gitRoot,
+          stdio: 'pipe'
+        });
+      } catch (gitErr) {
+        console.error(`Failed to cleanup git worktree: ${gitErr.message}`);
+      }
+    }
+
+    // Cleanup branch (only if we created it)
+    if (branchCreated && !worktreeCreated) {
+      try {
+        execSync(`git branch -D "${branchName}"`, {
+          cwd: gitRoot,
+          stdio: 'pipe'
+        });
+      } catch (gitErr) {
+        console.error(`Failed to cleanup branch: ${gitErr.message}`);
+      }
+    }
+
+    // Cleanup directory
+    if (fs.existsSync(worktreePath)) {
+      try {
+        fs.rmSync(worktreePath, { recursive: true, force: true });
+      } catch (fsErr) {
+        console.error(`Failed to cleanup worktree directory: ${fsErr.message}`);
+      }
+    }
+
+    throw new Error(`Worktree creation failed: ${err.message}`);
+  }
+}
+
+/**
+ * Get the worktree for a work item
+ *
+ * @param {number} workItemId - Work item ID
+ * @param {Object} options - Optional configuration
+ * @param {Object} options.db - Database connection (defaults to global database)
+ * @returns {Promise<Object|null>} Worktree record or null if not found
+ */
+async function getWorktreeForWorkItem(workItemId, options = {}) {
+  if (!workItemId || typeof workItemId !== 'number') {
+    return Promise.reject(new Error('Invalid work item ID: must be a number'));
+  }
+
+  const { getDb } = require('./database');
+  const db = options.db || getDb();
+
+  return new Promise((resolve, reject) => {
+    db.get(
+      'SELECT * FROM worktrees WHERE work_item_id = ? ORDER BY created_at DESC LIMIT 1',
+      [workItemId],
+      (err, row) => {
+        if (err) reject(err);
+        else resolve(row || null);
+      }
+    );
+  });
+}
+
+/**
+ * Get all active worktrees
+ *
+ * @param {Object} options - Optional configuration
+ * @param {Object} options.db - Database connection (defaults to global database)
+ * @returns {Promise<Array>} Array of worktree records with status='active'
+ */
+async function getAllActiveWorktrees(options = {}) {
+  const { getDb } = require('./database');
+  const db = options.db || getDb();
+
+  return new Promise((resolve, reject) => {
+    db.all(
+      'SELECT * FROM worktrees WHERE status = ? ORDER BY created_at DESC',
+      ['active'],
+      (err, rows) => {
+        if (err) reject(err);
+        else resolve(rows || []);
+      }
+    );
+  });
+}
+
+/**
+ * Mark worktree status
+ *
+ * @param {number} worktreeId - Worktree ID
+ * @param {string} status - New status (active|merging|cleanup_pending|corrupted)
+ * @param {Object} options - Optional configuration
+ * @param {Object} options.db - Database connection (defaults to global database)
+ * @returns {Promise<void>}
+ */
+async function markWorktreeStatus(worktreeId, status, options = {}) {
+  if (!worktreeId || typeof worktreeId !== 'number') {
+    return Promise.reject(new Error('Invalid worktree ID: must be a number'));
+  }
+
+  if (!VALID_STATUSES.includes(status)) {
+    return Promise.reject(new Error(`Invalid status: must be one of ${VALID_STATUSES.join(', ')}`));
+  }
+
+  const { getDb } = require('./database');
+  const db = options.db || getDb();
+
+  return new Promise((resolve, reject) => {
+    db.run(
+      'UPDATE worktrees SET status = ?, updated_at = datetime(\'now\') WHERE id = ?',
+      [status, worktreeId],
+      function(err) {
+        if (err) reject(err);
+        else if (this.changes === 0) reject(new Error(`Worktree not found: ${worktreeId}`));
+        else resolve();
+      }
+    );
+  });
+}
+
+/**
+ * Manual recursive directory deletion (last resort fallback)
+ * Walks directory tree and deletes files individually
+ *
+ * @param {string} dirPath - Directory to delete
+ * @returns {Promise<void>}
+ */
+async function manualRecursiveDelete(dirPath) {
+  const fs = require('fs');
+  const path = require('path');
+
+  if (!fs.existsSync(dirPath)) {
+    return;
+  }
+
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+
+    if (entry.isDirectory()) {
+      await manualRecursiveDelete(fullPath);
+    } else {
+      try {
+        fs.unlinkSync(fullPath);
+      } catch (err) {
+        // Try changing permissions and retry
+        try {
+          fs.chmodSync(fullPath, 0o666);
+          fs.unlinkSync(fullPath);
+        } catch (retryErr) {
+          throw new Error(`Cannot delete file ${fullPath}: ${retryErr.message}`);
+        }
+      }
+    }
+  }
+
+  // Delete the now-empty directory
+  fs.rmdirSync(dirPath);
+}
+
+/**
+ * Resilient directory removal with multi-stage escalation strategy
+ * Implements conditional verbosity: silent on success, detailed on escalation
+ *
+ * Stage 1: Standard git worktree remove
+ * Stage 2: Forced git worktree remove --force
+ * Stage 3: Filesystem fs.rmSync() with force
+ * Stage 4: Manual recursive directory deletion (fallback)
+ *
+ * @param {string} dirPath - Absolute path to directory to remove
+ * @param {string} gitRoot - Path to git repository root
+ * @returns {Promise<void>}
+ */
+async function removeDirectoryResilient(dirPath, gitRoot) {
+  const fs = require('fs');
+  const { execSync } = require('child_process');
+
+  // Stage 1: Try standard git worktree remove (silent)
+  try {
+    execSync(`git worktree remove "${dirPath}"`, {
+      cwd: gitRoot,
+      stdio: 'pipe'
+    });
+    return; // Success - exit silently
+  } catch (stage1Err) {
+    // Stage 1 failed - escalate with logging
+    console.log(`⚠️  Standard removal failed, escalating to forced removal...`);
+  }
+
+  // Stage 2: Try forced git worktree remove
+  try {
+    execSync(`git worktree remove --force "${dirPath}"`, {
+      cwd: gitRoot,
+      stdio: 'pipe'
+    });
+    console.log(`✓ Forced git removal succeeded`);
+    return;
+  } catch (stage2Err) {
+    console.log(`⚠️  Forced git removal failed, escalating to filesystem removal...`);
+  }
+
+  // Stage 3: Try filesystem removal with force
+  if (fs.existsSync(dirPath)) {
+    try {
+      fs.rmSync(dirPath, { recursive: true, force: true });
+      console.log(`✓ Filesystem removal succeeded`);
+
+      // Clean up git metadata
+      try {
+        execSync('git worktree prune', { cwd: gitRoot, stdio: 'pipe' });
+      } catch (pruneErr) {
+        // Non-fatal
+      }
+      return;
+    } catch (stage3Err) {
+      console.log(`⚠️  Filesystem removal failed, escalating to manual deletion...`);
+    }
+  }
+
+  // Stage 4: Manual recursive deletion (last resort)
+  try {
+    await manualRecursiveDelete(dirPath);
+    console.log(`✓ Manual recursive deletion succeeded`);
+
+    // Clean up git metadata
+    try {
+      execSync('git worktree prune', { cwd: gitRoot, stdio: 'pipe' });
+    } catch (pruneErr) {
+      // Non-fatal
+    }
+  } catch (stage4Err) {
+    throw new Error(`All removal strategies failed: ${stage4Err.message}`);
+  }
+}
+
+/**
+ * Cleanup a worktree (remove from filesystem and update DB)
+ *
+ * @param {number} worktreeId - Worktree ID
+ * @param {Object} options - Optional configuration
+ * @param {string} options.repoPath - Path to git repository (defaults to process.cwd())
+ * @param {Object} options.db - Database connection (defaults to global database)
+ * @param {boolean} options.deleteBranch - Whether to delete the branch (defaults to false)
+ * @returns {Promise<void>}
+ */
+async function cleanupWorktree(worktreeId, options = {}) {
+  if (!worktreeId || typeof worktreeId !== 'number') {
+    return Promise.reject(new Error('Invalid worktree ID: must be a number'));
+  }
+
+  const fs = require('fs');
+  const path = require('path');
+  const { execSync } = require('child_process');
+
+  // CRITICAL SAFETY: repoPath MUST be provided - never auto-detect from cwd
+  // Auto-detection from worktrees causes catastrophic repo corruption
+  if (!options.repoPath) {
+    return Promise.reject(new Error('SAFETY: repoPath must be explicitly provided to cleanupWorktree'));
+  }
+
+  const gitRoot = options.repoPath;
+  const { getDb } = require('./database');
+  const db = options.db || getDb();
+  const deleteBranch = options.deleteBranch || false;
+
+  // SAFETY CHECK 1: Verify we're not running from within a worktree
+  try {
+    const currentGitDir = execSync('git rev-parse --git-dir', {
+      cwd: process.cwd(),
+      encoding: 'utf8'
+    }).trim();
+
+    if (currentGitDir.includes('.jettypod-work') || currentGitDir !== '.git') {
+      return Promise.reject(new Error('SAFETY: Cannot run cleanup from within a worktree'));
+    }
+  } catch (err) {
+    // Ignore - might not be in a git repo
+  }
+
+  // SAFETY CHECK 2: Verify gitRoot is actually the main repository
+  try {
+    const gitRootCheck = execSync('git rev-parse --show-toplevel', {
+      cwd: gitRoot,
+      encoding: 'utf8'
+    }).trim();
+
+    // Resolve both paths to handle /var vs /private/var symlink on macOS
+    const resolvedGitRoot = fs.realpathSync(gitRoot);
+    const resolvedGitRootCheck = fs.realpathSync(gitRootCheck);
+
+    if (resolvedGitRootCheck !== resolvedGitRoot) {
+      return Promise.reject(new Error(`SAFETY: Provided repoPath ${gitRoot} does not match git root ${gitRootCheck}`));
+    }
+
+    // Verify .jettypod exists in the git root
+    const jettypodPath = path.join(gitRoot, '.jettypod');
+    if (!fs.existsSync(jettypodPath)) {
+      return Promise.reject(new Error(`SAFETY: .jettypod directory not found in ${gitRoot} - refusing to proceed`));
+    }
+  } catch (err) {
+    return Promise.reject(new Error(`SAFETY: Failed to verify git root: ${err.message}`));
+  }
+
+  // CRITICAL SAFETY: Create automatic backup of .jettypod before cleanup
+  const { createBackup } = require('./jettypod-backup');
+  const backupResult = await createBackup(gitRoot, `cleanup-worktree-${worktreeId}`);
+  if (!backupResult.success) {
+    console.warn(`⚠️  Warning: Could not create backup: ${backupResult.error}`);
+    console.warn(`   Proceeding anyway, but .jettypod is not backed up!`);
+  } else {
+    console.log(`💾 Created backup: ${path.basename(backupResult.backupPath)}`);
+  }
+
+  try {
+    // Step 1: Get worktree details from database
+    const worktree = await new Promise((resolve, reject) => {
+      db.get('SELECT * FROM worktrees WHERE id = ?', [worktreeId], (err, row) => {
+        if (err) reject(err);
+        else if (!row) reject(new Error(`Worktree not found: ${worktreeId}`));
+        else resolve(row);
+      });
+    });
+
+    // Step 2: Mark as cleanup_pending
+    await new Promise((resolve, reject) => {
+      db.run(
+        'UPDATE worktrees SET status = ?, updated_at = datetime(\'now\') WHERE id = ?',
+        ['cleanup_pending', worktreeId],
+        (err) => {
+          if (err) reject(err);
+          else resolve();
+        }
+      );
+    });
+
+    // Step 2.5: Smart conflict detection and auto-commit
+    const { checkForConflicts } = require('./smart-conflict-detection');
+
+    try {
+      const conflictCheck = checkForConflicts(gitRoot);
+
+      // Check for recoverable errors
+      if (conflictCheck.error) {
+        if (conflictCheck.error.category === 'DETACHED_HEAD') {
+          console.warn(`⚠️  ${conflictCheck.error.message} - skipping auto-commit`);
+        } else {
+          console.warn(`⚠️  Conflict detection issue: ${conflictCheck.error.message}`);
+        }
+        // Continue with cleanup even if conflict detection had issues
+      }
+      // If no conflicts but uncommitted changes exist, auto-commit
+      else if (!conflictCheck.hasConflicts && conflictCheck.status.trim() !== '') {
+        try {
+          execSync('git add .', { cwd: gitRoot, stdio: 'pipe' });
+          execSync(`git commit -m "Merge work item #${worktree.work_item_id}"`, {
+            cwd: gitRoot,
+            stdio: 'pipe'
+          });
+          console.log(`✅ Auto-committed clean merge for work item #${worktree.work_item_id}`);
+        } catch (commitErr) {
+          // Non-fatal - log warning but continue
+          console.warn(`Warning: Could not auto-commit: ${commitErr.message}`);
+        }
+      } else if (conflictCheck.hasConflicts) {
+        console.warn(`⚠️  Conflicts detected in ${conflictCheck.conflictFiles.length} file(s)`);
+        console.warn(`   Files: ${conflictCheck.conflictFiles.join(', ')}`);
+      }
+    } catch (conflictErr) {
+      // Fatal errors from checkForConflicts (invalid repo, permission denied)
+      // These should stop the cleanup process
+      console.error(`❌ Fatal error during conflict detection: ${conflictErr.message}`);
+      throw conflictErr;
+    }
+
+    // Step 2.5: Terminate background processes in worktree directory
+    const { findProcessesInDirectory, terminateProcessGracefully } = require('./process-manager');
+
+    try {
+      const processes = await findProcessesInDirectory(worktree.worktree_path);
+
+      if (processes.length > 0) {
+        console.log(`🔄 Found ${processes.length} background process(es) in worktree...`);
+
+        for (const proc of processes) {
+          const result = await terminateProcessGracefully(proc.pid, 2000);
+          console.log(`   Terminated ${result.name} (PID ${result.pid})... ${result.method}`);
+        }
+      }
+    } catch (processErr) {
+      // Non-fatal - log warning but continue with cleanup
+      console.warn(`⚠️  Warning: Process termination failed: ${processErr.message}`);
+    }
+
+    // Step 3: Remove directory with resilient multi-stage strategy
+    await removeDirectoryResilient(worktree.worktree_path, gitRoot);
+
+    // Step 4: Optionally delete branch
+    if (deleteBranch) {
+      try {
+        execSync(`git branch -D "${worktree.branch_name}"`, {
+          cwd: gitRoot,
+          stdio: 'pipe'
+        });
+      } catch (branchErr) {
+        // Non-fatal - log warning but continue
+        console.warn(`Warning: Could not delete branch: ${branchErr.message}`);
+      }
+    }
+
+    // Step 5: Mark as corrupted (we never delete DB entries)
+    // Using 'corrupted' as the final state for cleaned up worktrees
+    // This preserves the audit trail
+    await new Promise((resolve, reject) => {
+      db.run(
+        'UPDATE worktrees SET status = ?, updated_at = datetime(\'now\') WHERE id = ?',
+        ['corrupted', worktreeId],
+        (err) => {
+          if (err) reject(err);
+          else resolve();
+        }
+      );
+    });
+
+  } catch (err) {
+    // On any failure, mark as corrupted
+    try {
+      await new Promise((resolve, reject) => {
+        db.run(
+          'UPDATE worktrees SET status = ?, updated_at = datetime(\'now\') WHERE id = ?',
+          ['corrupted', worktreeId],
+          (err) => {
+            if (err) reject(err);
+            else resolve();
+          }
+        );
+      });
+    } catch (dbErr) {
+      console.error(`Failed to mark worktree as corrupted: ${dbErr.message}`);
+    }
+
+    throw new Error(`Worktree cleanup failed: ${err.message}`);
+  }
+}
+
+module.exports = {
+  createWorktree,
+  getWorktreeForWorkItem,
+  getAllActiveWorktrees,
+  markWorktreeStatus,
+  cleanupWorktree
+};