jettypod 4.1.2 → 4.1.4

package/lib/smart-fetch-rebase.js

@@ -0,0 +1,614 @@
+/**
+ * Smart Fetch & Rebase Module
+ *
+ * Automatically fetches latest changes from origin and rebases feature branches
+ * on updated main before merging. Implements retry strategy with exponential
+ * backoff to handle concurrent merge operations.
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Smart fetch and rebase operation for merging feature branches
+ *
+ * @param {string} repoPath - Path to git repository
+ * @param {string} featureBranch - Name of feature branch to merge
+ * @param {Object} options - Optional configuration
+ * @param {number} options.maxRetries - Maximum retry attempts (default: 3)
+ * @param {number} options.initialDelay - Initial retry delay in ms (default: 1000)
+ * @param {boolean} options.cleanupWorktree - Cleanup worktree after successful merge (default: true)
+ * @param {Object} options.db - Database connection for worktree cleanup (optional)
+ * @returns {Promise<Object>} Result object with operation status flags
+ * @throws {Error} If operation fails or divergence detected
+ */
+async function smartFetchAndRebase(repoPath, featureBranch, options = {}) {
+  const maxRetries = options.maxRetries || 3;
+  const initialDelay = options.initialDelay || 1000;
+  const cleanupWorktree = options.cleanupWorktree !== false; // Default true
+
+  const result = {
+    fetchedFromOrigin: false,
+    mainFastForwarded: false,
+    rebaseCompleted: false,
+    mergeCompleted: false,
+    pushedToOrigin: false,
+    retryAttempted: false,
+    succeededOnRetry: false,
+    divergenceDetected: false,
+    aborted: false,
+    worktreeCleaned: false,
+    error: null
+  };
+
+  try {
+    // Pre-flight validation: check git repository health
+    await validateGitRepo(repoPath);
+
+    // Fetch latest changes from origin
+    await fetchOrigin(repoPath);
+    result.fetchedFromOrigin = true;
+
+    // Detect if main has diverged (cannot be fast-forwarded)
+    const diverged = await detectDivergence(repoPath);
+    if (diverged) {
+      result.divergenceDetected = true;
+      result.aborted = true;
+      result.error = 'Local main has diverged from origin/main. Cannot fast-forward. Manual intervention required.';
+      throw new Error(result.error);
+    }
+
+    // Fast-forward local main to match origin/main
+    await fastForwardMain(repoPath);
+    result.mainFastForwarded = true;
+
+    // Rebase feature branch onto updated main
+    await rebaseFeatureBranch(repoPath, featureBranch);
+    result.rebaseCompleted = true;
+
+    // Merge feature branch to main
+    await mergeFeatureBranch(repoPath, featureBranch);
+    result.mergeCompleted = true;
+
+    // Push to origin with retry logic
+    let retryCount = 0;
+    const retryAttempts = [];
+
+    while (retryCount <= maxRetries) {
+      try {
+        await pushToOrigin(repoPath);
+        result.pushedToOrigin = true;
+        if (retryCount > 0) {
+          result.succeededOnRetry = true;
+        }
+
+        // Cleanup worktree after successful merge and push
+        if (cleanupWorktree) {
+          try {
+            // Extract work item ID from branch name (format: feature/work-{id}-{slug})
+            const branchMatch = featureBranch.match(/work-(\d+)-/);
+            if (branchMatch) {
+              const workItemId = parseInt(branchMatch[1]);
+
+              // Get database connection
+              const { getDb } = require('./database');
+              const db = options.db || getDb();
+
+              // Find worktree for this work item
+              const worktree = await new Promise((resolve, reject) => {
+                db.get(
+                  'SELECT * FROM worktrees WHERE work_item_id = ? AND status = ?',
+                  [workItemId, 'active'],
+                  (err, row) => {
+                    if (err) reject(err);
+                    else resolve(row);
+                  }
+                );
+              });
+
+              if (worktree) {
+                // Cleanup using worktree-facade
+                const worktreeFacade = require('./worktree-facade');
+                const cleanupResult = await worktreeFacade.stopWork(worktree.id, {
+                  repoPath: repoPath,
+                  db: db,
+                  deleteBranch: true  // Delete branch after successful merge
+                });
+
+                if (cleanupResult.success) {
+                  result.worktreeCleaned = true;
+                }
+              }
+            }
+          } catch (cleanupErr) {
+            // Non-fatal - log warning but don't fail the merge
+            console.warn(`Warning: Worktree cleanup failed: ${cleanupErr.message}`);
+          }
+        }
+
+        break;
+      } catch (pushErr) {
+        // Log retry attempt with details
+        retryAttempts.push({
+          attempt: retryCount + 1,
+          error: pushErr.message,
+          timestamp: new Date().toISOString()
+        });
+
+        if (retryCount === maxRetries) {
+          // Build detailed error message for retry exhaustion
+          const attemptsLog = retryAttempts.map((a, i) =>
+            `  Attempt ${a.attempt}/${maxRetries + 1}: ${a.error}`
+          ).join('\n');
+
+          const errorMessage = [
+            `Push to origin failed after ${maxRetries + 1} attempts.`,
+            '',
+            'Retry attempts:',
+            attemptsLog,
+            '',
+            'Possible causes:',
+            '  • Another instance is continuously pushing changes',
+            '  • Network connectivity issues',
+            '  • Git server is under heavy load or unavailable',
+            '  • Repository has been locked or has restrictions',
+            '',
+            'Manual resolution steps:',
+            '  1. Check if other instances are running: ps aux | grep jettypod',
+            '  2. Verify network connectivity: git fetch origin',
+            '  3. Check remote repository status on GitHub/GitLab',
+            '  4. Wait a few minutes and try merging again',
+            '  5. If issue persists, push manually: git push origin main'
+          ].join('\n');
+
+          throw new Error(errorMessage);
+        }
+
+        // Retry with exponential backoff
+        retryCount++;
+        result.retryAttempted = true;
+        const delay = initialDelay * Math.pow(2, retryCount - 1);
+
+        console.log(`Push failed (attempt ${retryCount}/${maxRetries + 1}), retrying in ${delay}ms...`);
+        await sleep(delay);
+
+        // Re-fetch and rebase before retry
+        await fetchOrigin(repoPath);
+        await fastForwardMain(repoPath);
+        await rebaseFeatureBranch(repoPath, featureBranch);
+      }
+    }
+
+    return result;
+  } catch (err) {
+    if (!result.error) {
+      result.error = err.message;
+    }
+    throw err;
+  }
+}
+
+/**
+ * Fetch latest changes from origin
+ *
+ * @param {string} repoPath - Path to git repository
+ * @returns {Promise<void>}
+ * @throws {Error} If fetch fails
+ */
+async function fetchOrigin(repoPath) {
+  try {
+    execSync('git fetch origin', { cwd: repoPath, stdio: 'pipe' });
+  } catch (err) {
+    // Detect specific network error types
+    const errorMsg = err.message.toLowerCase();
+
+    // DNS/hostname resolution failures
+    if (errorMsg.includes('could not resolve host') ||
+        errorMsg.includes('temporary failure in name resolution') ||
+        errorMsg.includes('nodename nor servname provided')) {
+      throw new Error([
+        'Network error: Unable to resolve remote repository hostname.',
+        '',
+        'Possible causes:',
+        '  • No internet connection',
+        '  • DNS server is unavailable',
+        '  • Hostname is incorrect',
+        '',
+        'Resolution steps:',
+        '  1. Check internet connection: ping 8.8.8.8',
+        '  2. Verify DNS: nslookup github.com',
+        '  3. Check remote URL: git remote -v',
+        '  4. Try using mobile hotspot or different network'
+      ].join('\n'));
+    }
+
+    // Connection refused / timeout
+    if (errorMsg.includes('connection refused') ||
+        errorMsg.includes('connection timed out') ||
+        errorMsg.includes('failed to connect')) {
+      throw new Error([
+        'Network error: Cannot connect to remote repository.',
+        '',
+        'Possible causes:',
+        '  • Git server is down or unreachable',
+        '  • Firewall blocking git protocol',
+        '  • Network timeout',
+        '  • VPN or proxy issues',
+        '',
+        'Resolution steps:',
+        '  1. Check server status (e.g., https://www.githubstatus.com/)',
+        '  2. Try using HTTPS instead of SSH: git remote set-url origin https://...',
+        '  3. Check firewall settings',
+        '  4. Disable VPN temporarily and retry'
+      ].join('\n'));
+    }
+
+    // Authentication failures
+    if (errorMsg.includes('authentication failed') ||
+        errorMsg.includes('permission denied') ||
+        errorMsg.includes('could not read from remote')) {
+      throw new Error([
+        'Network error: Authentication to remote repository failed.',
+        '',
+        'Possible causes:',
+        '  • SSH key not configured or expired',
+        '  • Invalid credentials',
+        '  • Token expired',
+        '  • Insufficient repository permissions',
+        '',
+        'Resolution steps:',
+        '  1. Check SSH key: ssh -T git@github.com',
+        '  2. Verify credentials are current',
+        '  3. Regenerate personal access token if needed',
+        '  4. Ensure you have push access to repository'
+      ].join('\n'));
+    }
+
+    // Generic network error
+    throw new Error([
+      `Failed to fetch from origin: ${err.message}`,
+      '',
+      'This may be a network connectivity issue.',
+      '',
+      'Try:',
+      '  1. Check internet connection',
+      '  2. Verify git remote: git remote -v',
+      '  3. Test fetch manually: git fetch origin',
+      '  4. Check git server status'
+    ].join('\n'));
+  }
+}
+
+/**
+ * Fast-forward local main to match origin/main
+ *
+ * @param {string} repoPath - Path to git repository
+ * @returns {Promise<void>}
+ * @throws {Error} If fast-forward fails
+ */
+async function fastForwardMain(repoPath) {
+  try {
+    // Checkout main
+    execSync('git checkout main', { cwd: repoPath, stdio: 'pipe' });
+
+    // Fast-forward merge from origin/main
+    execSync('git merge --ff-only origin/main', { cwd: repoPath, stdio: 'pipe' });
+  } catch (err) {
+    throw new Error(`Failed to fast-forward main: ${err.message}`);
+  }
+}
+
+/**
+ * Rebase feature branch onto main
+ *
+ * @param {string} repoPath - Path to git repository
+ * @param {string} featureBranch - Name of feature branch
+ * @returns {Promise<void>}
+ * @throws {Error} If rebase fails
+ */
+async function rebaseFeatureBranch(repoPath, featureBranch) {
+  try {
+    // Checkout feature branch
+    execSync(`git checkout ${featureBranch}`, { cwd: repoPath, stdio: 'pipe' });
+
+    // Rebase onto main
+    execSync('git rebase main', { cwd: repoPath, stdio: 'pipe' });
+  } catch (err) {
+    const errorMsg = err.message.toLowerCase();
+
+    // Detect conflict state
+    const isConflict = errorMsg.includes('conflict') ||
+                      errorMsg.includes('merge conflict') ||
+                      errorMsg.includes('needs merge');
+
+    // Check if rebase is in progress
+    let rebaseInProgress = false;
+    try {
+      const gitDir = execSync('git rev-parse --git-dir', { cwd: repoPath, encoding: 'utf-8' }).trim();
+      const rebaseDir = path.join(repoPath, gitDir, 'rebase-merge');
+      rebaseInProgress = fs.existsSync(rebaseDir) || fs.existsSync(path.join(repoPath, gitDir, 'rebase-apply'));
+    } catch (checkErr) {
+      // Ignore errors checking for rebase state
+    }
+
+    if (isConflict && rebaseInProgress) {
+      // Get list of conflicted files
+      let conflictedFiles = [];
+      try {
+        const status = execSync('git status --porcelain', { cwd: repoPath, encoding: 'utf-8' });
+        conflictedFiles = status
+          .split('\n')
+          .filter(line => line.startsWith('UU ') || line.startsWith('AA ') || line.startsWith('DD '))
+          .map(line => line.substring(3).trim());
+      } catch (statusErr) {
+        // Ignore status errors
+      }
+
+      const filesMsg = conflictedFiles.length > 0
+        ? `\nConflicted files:\n${conflictedFiles.map(f => `  • ${f}`).join('\n')}`
+        : '';
+
+      // Abort rebase to clean state
+      try {
+        execSync('git rebase --abort', { cwd: repoPath, stdio: 'pipe' });
+      } catch (abortErr) {
+        // Continue even if abort fails
+      }
+
+      throw new Error([
+        'Rebase conflict detected: Feature branch has changes that conflict with main.',
+        filesMsg,
+        '',
+        'Your work has been preserved - the rebase was aborted and your feature branch is intact.',
+        '',
+        'Resolution steps:',
+        '  1. Manually rebase in the repository:',
+        `     cd ${repoPath}`,
+        `     git checkout ${featureBranch}`,
+        '     git rebase main',
+        '',
+        '  2. Resolve each conflict:',
+        '     • Edit conflicted files (marked with <<<<<<< and >>>>>>>)',
+        '     • Choose which changes to keep',
+        '     • Stage resolved files: git add <file>',
+        '     • Continue: git rebase --continue',
+        '',
+        '  3. After resolving all conflicts:',
+        '     • Verify tests still pass',
+        '     • Push the rebased branch: git push --force-with-lease',
+        '',
+        '  4. Then retry the merge operation',
+        '',
+        'Tip: Use a merge tool for easier conflict resolution: git mergetool'
+      ].join('\n'));
+    }
+
+    // Other rebase errors - still abort to clean state
+    try {
+      execSync('git rebase --abort', { cwd: repoPath, stdio: 'pipe' });
+    } catch (abortErr) {
+      // Ignore abort errors
+    }
+
+    throw new Error([
+      `Failed to rebase feature branch: ${err.message}`,
+      '',
+      'The rebase was aborted and your feature branch is intact.',
+      '',
+      'Possible causes:',
+      '  • Commits cannot be automatically applied',
+      '  • Invalid git state',
+      '  • Repository corruption',
+      '',
+      'Try:',
+      '  1. Manually rebase: git checkout ${featureBranch} && git rebase main',
+      '  2. Check git status: git status',
+      '  3. Verify repository health: git fsck'
+    ].join('\n'));
+  }
+}
+
+/**
+ * Merge feature branch to main
+ *
+ * @param {string} repoPath - Path to git repository
+ * @param {string} featureBranch - Name of feature branch
+ * @returns {Promise<void>}
+ * @throws {Error} If merge fails
+ */
+async function mergeFeatureBranch(repoPath, featureBranch) {
+  try {
+    // Checkout main
+    execSync('git checkout main', { cwd: repoPath, stdio: 'pipe' });
+
+    // Merge feature branch with --no-ff to preserve merge history
+    execSync(`git merge --no-ff ${featureBranch} -m "Merge ${featureBranch}"`, { cwd: repoPath, stdio: 'pipe' });
+  } catch (err) {
+    throw new Error(`Failed to merge feature branch: ${err.message}`);
+  }
+}
+
+/**
+ * Push to origin
+ *
+ * @param {string} repoPath - Path to git repository
+ * @returns {Promise<void>}
+ * @throws {Error} If push fails
+ */
+async function pushToOrigin(repoPath) {
+  try {
+    execSync('git push origin main', { cwd: repoPath, stdio: 'pipe' });
+  } catch (err) {
+    throw new Error(`Failed to push to origin: ${err.message}`);
+  }
+}
+
+/**
+ * Detect if local main has diverged from origin/main
+ *
+ * @param {string} repoPath - Path to git repository
+ * @returns {Promise<boolean>} True if branches have diverged
+ */
+async function detectDivergence(repoPath) {
+  try {
+    // Get merge-base between main and origin/main
+    const mergeBase = execSync('git merge-base main origin/main', { cwd: repoPath, encoding: 'utf-8' }).trim();
+
+    // Get current commit of local main
+    const localMain = execSync('git rev-parse main', { cwd: repoPath, encoding: 'utf-8' }).trim();
+
+    // If merge-base is not equal to local main, then main has commits that origin doesn't
+    // Check if we can fast-forward
+    if (mergeBase !== localMain) {
+      // Local main has commits that origin/main doesn't have
+      return true;
+    }
+
+    return false;
+  } catch (err) {
+    throw new Error(`Failed to detect divergence: ${err.message}`);
+  }
+}
+
+/**
+ * Validate git repository health before operations
+ *
+ * @param {string} repoPath - Path to git repository
+ * @returns {Promise<void>}
+ * @throws {Error} If repository is invalid or corrupted
+ */
+async function validateGitRepo(repoPath) {
+  // Check if path exists
+  if (!fs.existsSync(repoPath)) {
+    throw new Error([
+      'Git repository path does not exist.',
+      '',
+      `Path: ${repoPath}`,
+      '',
+      'Ensure the repository path is correct.'
+    ].join('\n'));
+  }
+
+  // Check if it's a git repository
+  try {
+    execSync('git rev-parse --git-dir', { cwd: repoPath, stdio: 'pipe' });
+  } catch (err) {
+    throw new Error([
+      'Not a valid git repository.',
+      '',
+      `Path: ${repoPath}`,
+      '',
+      'Initialize a git repository first:',
+      '  git init'
+    ].join('\n'));
+  }
+
+  // Check for ongoing git operations that would block our operations
+  const gitDir = execSync('git rev-parse --git-dir', { cwd: repoPath, encoding: 'utf-8' }).trim();
+  const gitDirPath = path.isAbsolute(gitDir) ? gitDir : path.join(repoPath, gitDir);
+
+  const blockingFiles = [
+    'rebase-merge',
+    'rebase-apply',
+    'MERGE_HEAD',
+    'CHERRY_PICK_HEAD',
+    'REVERT_HEAD',
+    'BISECT_LOG'
+  ];
+
+  for (const file of blockingFiles) {
+    const filePath = path.join(gitDirPath, file);
+    if (fs.existsSync(filePath)) {
+      const operation = file.replace(/[-_]/g, ' ').toLowerCase();
+      throw new Error([
+        `Git repository has an ongoing ${operation} operation.`,
+        '',
+        'Complete or abort the current operation first:',
+        '  • For rebase: git rebase --abort or git rebase --continue',
+        '  • For merge: git merge --abort or complete the merge',
+        '  • For cherry-pick: git cherry-pick --abort',
+        '  • For revert: git revert --abort',
+        '',
+        'Then retry the merge operation.'
+      ].join('\n'));
+    }
+  }
+
+  // Run git fsck to check for corruption
+  try {
+    const fsckOutput = execSync('git fsck --no-progress 2>&1', {
+      cwd: repoPath,
+      encoding: 'utf-8',
+      stdio: 'pipe'
+    });
+
+    // Check for critical errors (ignore warnings)
+    if (fsckOutput.includes('error:') || fsckOutput.includes('fatal:')) {
+      throw new Error([
+        'Git repository corruption detected.',
+        '',
+        'Repository integrity check failed:',
+        fsckOutput.split('\n').filter(line => line.includes('error:') || line.includes('fatal:')).join('\n'),
+        '',
+        'Recovery steps:',
+        '  1. Backup your work immediately',
+        '  2. Try: git fsck --full',
+        '  3. Attempt recovery: git reflog',
+        '  4. If needed, clone fresh from origin',
+        '',
+        'WARNING: Repository may need manual repair or re-cloning.'
+      ].join('\n'));
+    }
+  } catch (err) {
+    // fsck failed to run
+    if (err.message.includes('error:') || err.message.includes('fatal:')) {
+      throw new Error([
+        'Git repository validation failed.',
+        '',
+        `Error: ${err.message}`,
+        '',
+        'The repository may be corrupted or in an invalid state.',
+        '',
+        'Try:',
+        '  1. Check repository status: git status',
+        '  2. Verify repository: git fsck',
+        '  3. If needed, clone fresh from origin'
+      ].join('\n'));
+    }
+    // Ignore other fsck errors (exit code != 0 but no critical errors)
+  }
+
+  // Check if remote 'origin' exists
+  try {
+    execSync('git remote get-url origin', { cwd: repoPath, stdio: 'pipe' });
+  } catch (err) {
+    throw new Error([
+      'Git remote "origin" is not configured.',
+      '',
+      'Configure the remote first:',
+      '  git remote add origin <repository-url>',
+      '',
+      'Or verify existing remotes:',
+      '  git remote -v'
+    ].join('\n'));
+  }
+}
+
+/**
+ * Sleep for specified milliseconds
+ *
+ * @param {number} ms - Milliseconds to sleep
+ * @returns {Promise<void>}
+ */
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+module.exports = {
+  smartFetchAndRebase,
+  fetchOrigin,
+  fastForwardMain,
+  rebaseFeatureBranch,
+  detectDivergence
+};

package/lib/step-definition-parser.js

@@ -0,0 +1,76 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Parse a step definition file to extract step definitions with their line numbers
+ * @param {string} filePath - Absolute path to step definition file
+ * @returns {Map} Map of step text to {file, lineNumber}
+ */
+function parseStepDefinitions(filePath) {
+  const stepMap = new Map();
+
+  if (!fs.existsSync(filePath)) {
+    return stepMap;
+  }
+
+  const content = fs.readFileSync(filePath, 'utf8');
+  const lines = content.split('\n');
+
+  // Regex to match Given/When/Then/And statements
+  // Matches: Given('step text'), When("step text"), etc.
+  const stepRegex = /(?:Given|When|Then|And|But)\s*\(\s*['"](.+?)['"]/;
+
+  lines.forEach((line, index) => {
+    const lineNumber = index + 1; // Line numbers start at 1
+
+    // Skip comments
+    if (line.trim().startsWith('//') || line.trim().startsWith('/*')) {
+      return;
+    }
+
+    const match = line.match(stepRegex);
+    if (match) {
+      const stepText = match[1];
+      stepMap.set(stepText, {
+        file: filePath,
+        lineNumber: lineNumber
+      });
+    }
+  });
+
+  return stepMap;
+}
+
+/**
+ * Parse all step definition files in a directory
+ * @param {string} dirPath - Path to step_definitions directory
+ * @returns {Map} Combined map of all step definitions
+ */
+function parseAllStepDefinitions(dirPath) {
+  const combinedMap = new Map();
+
+  if (!fs.existsSync(dirPath)) {
+    return combinedMap;
+  }
+
+  const files = fs.readdirSync(dirPath);
+
+  files.forEach(file => {
+    if (file.endsWith('.steps.js')) {
+      const filePath = path.join(dirPath, file);
+      const fileSteps = parseStepDefinitions(filePath);
+
+      // Merge into combined map
+      fileSteps.forEach((value, key) => {
+        combinedMap.set(key, value);
+      });
+    }
+  });
+
+  return combinedMap;
+}
+
+module.exports = {
+  parseStepDefinitions,
+  parseAllStepDefinitions
+};