@litmers/cursorflow-orchestrator 0.1.18 → 0.1.26

package/src/utils/git.ts

@@ -3,6 +3,77 @@
  */
 
 import { execSync, spawnSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import { safeJoin } from './path';
+
+/**
+ * Acquire a file-based lock for Git operations
+ */
+function acquireLock(lockName: string, cwd?: string): string | null {
+  const repoRoot = cwd || getRepoRoot();
+  const lockDir = safeJoin(repoRoot, '_cursorflow', 'locks');
+  if (!fs.existsSync(lockDir)) {
+    fs.mkdirSync(lockDir, { recursive: true });
+  }
+  
+  const lockFile = safeJoin(lockDir, `${lockName}.lock`);
+  
+  try {
+    // wx flag ensures atomic creation
+    fs.writeFileSync(lockFile, String(process.pid), { flag: 'wx' });
+    return lockFile;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Release a file-based lock
+ */
+function releaseLock(lockFile: string | null): void {
+  if (lockFile && fs.existsSync(lockFile)) {
+    try {
+      fs.unlinkSync(lockFile);
+    } catch {
+      // Ignore
+    }
+  }
+}
+
+/**
+ * Run Git command with locking
+ */
+async function runGitWithLock<T>(
+  lockName: string,
+  fn: () => T,
+  options: { cwd?: string; maxRetries?: number; retryDelay?: number } = {}
+): Promise<T> {
+  const maxRetries = options.maxRetries ?? 10;
+  const retryDelay = options.retryDelay ?? 500;
+  
+  let retries = 0;
+  let lockFile = null;
+  
+  while (retries < maxRetries) {
+    lockFile = acquireLock(lockName, options.cwd);
+    if (lockFile) break;
+    
+    retries++;
+    const delay = Math.floor(Math.random() * retryDelay) + retryDelay / 2;
+    await new Promise(resolve => setTimeout(resolve, delay));
+  }
+  
+  if (!lockFile) {
+    throw new Error(`Failed to acquire lock: ${lockName}`);
+  }
+  
+  try {
+    return fn();
+  } finally {
+    releaseLock(lockFile);
+  }
+}
 
 export interface GitRunOptions {
   cwd?: string;
@@ -36,6 +107,25 @@ export interface CommitInfo {
   subject: string;
 }
 
+/**
+ * Filter out noisy git stderr messages
+ */
+function filterGitStderr(stderr: string): string {
+  if (!stderr) return '';
+  
+  const lines = stderr.split('\n');
+  const filtered = lines.filter(line => {
+    // GitHub noise
+    if (line.includes('remote: Create a pull request')) return false;
+    if (line.trim().startsWith('remote:') && line.includes('pull/new')) return false;
+    if (line.trim() === 'remote:') return false; // Empty remote lines
+    
+    return true;
+  });
+  
+  return filtered.join('\n');
+}
+
 /**
  * Run git command and return output
  */
@@ -43,12 +133,21 @@ export function runGit(args: string[], options: GitRunOptions = {}): string {
   const { cwd, silent = false } = options;
   
   try {
+    const stdioMode = silent ? 'pipe' : ['inherit', 'inherit', 'pipe'];
+
     const result = spawnSync('git', args, {
       cwd: cwd || process.cwd(),
       encoding: 'utf8',
-      stdio: silent ? 'pipe' : 'inherit',
+      stdio: stdioMode as any,
     });
     
+    if (!silent && result.stderr) {
+      const filteredStderr = filterGitStderr(result.stderr);
+      if (filteredStderr) {
+        process.stderr.write(filteredStderr);
+      }
+    }
+    
     if (result.status !== 0 && !silent) {
       throw new Error(`Git command failed: git ${args.join(' ')}\n${result.stderr || ''}`);
     }
@@ -96,6 +195,24 @@ export function getRepoRoot(cwd?: string): string {
   return runGit(['rev-parse', '--show-toplevel'], { cwd, silent: true });
 }
 
+/**
+ * Get main repository root directory (for worktrees)
+ */
+export function getMainRepoRoot(cwd?: string): string {
+  try {
+    const result = runGitResult(['worktree', 'list', '--porcelain'], { cwd });
+    if (result.success && result.stdout) {
+      const firstLine = result.stdout.split('\n')[0];
+      if (firstLine && firstLine.startsWith('worktree ')) {
+        return firstLine.slice(9).trim();
+      }
+    }
+  } catch {
+    // Fallback to normal repo root
+  }
+  return getRepoRoot(cwd);
+}
+
 /**
  * Check if directory is a git repository
  */
@@ -118,20 +235,64 @@ export function worktreeExists(worktreePath: string, cwd?: string): boolean {
  * Create worktree
  */
 export function createWorktree(worktreePath: string, branchName: string, options: { cwd?: string; baseBranch?: string } = {}): string {
-  const { cwd, baseBranch = 'main' } = options;
+  let { cwd, baseBranch } = options;
   
-  // Check if branch already exists
-  const branchExists = runGitResult(['rev-parse', '--verify', branchName], { cwd }).success;
+  if (!baseBranch) {
+    baseBranch = getCurrentBranch(cwd) || 'refs/heads/main';
+  }
+
+  // Ensure baseBranch is unambiguous (branch name rather than tag)
+  const unambiguousBase = (baseBranch.startsWith('refs/') || baseBranch.includes('/')) 
+    ? baseBranch 
+    : `refs/heads/${baseBranch}`;
+
+  // Use a file-based lock to prevent race conditions during worktree creation
+  const lockDir = safeJoin(cwd || getRepoRoot(), '_cursorflow', 'locks');
+  if (!fs.existsSync(lockDir)) {
+    fs.mkdirSync(lockDir, { recursive: true });
+  }
+  const lockFile = safeJoin(lockDir, 'worktree.lock');
+  
+  let retries = 20;
+  let acquired = false;
+  
+  while (retries > 0 && !acquired) {
+    try {
+      fs.writeFileSync(lockFile, String(process.pid), { flag: 'wx' });
+      acquired = true;
+    } catch {
+      retries--;
+      const delay = Math.floor(Math.random() * 500) + 200;
+      // Use synchronous sleep to keep the function signature synchronous
+      const end = Date.now() + delay;
+      while (Date.now() < end) { /* wait */ }
+    }
+  }
   
-  if (branchExists) {
-    // Branch exists, checkout to worktree
-    runGit(['worktree', 'add', worktreePath, branchName], { cwd });
-  } else {
-    // Create new branch from base
-    runGit(['worktree', 'add', '-b', branchName, worktreePath, baseBranch], { cwd });
+  if (!acquired) {
+    throw new Error('Failed to acquire worktree lock after multiple retries');
   }
   
-  return worktreePath;
+  try {
+    // Check if branch already exists
+    const branchExists = runGitResult(['rev-parse', '--verify', branchName], { cwd }).success;
+    
+    if (branchExists) {
+      // Branch exists, checkout to worktree
+      runGit(['worktree', 'add', worktreePath, branchName], { cwd });
+    } else {
+      // Create new branch from base
+      runGit(['worktree', 'add', '-b', branchName, worktreePath, unambiguousBase], { cwd });
+    }
+    
+    return worktreePath;
+  } finally {
+    try {
+      fs.unlinkSync(lockFile);
+    } catch {
+      // Ignore
+    }
+  }
 }
 
 /**
@@ -362,4 +523,349 @@ export function getLastOperationStats(cwd?: string): string {
   } catch (e) {
     return '';
   }
+}
+
+// ============================================================================
+// Enhanced Git Functions for Robustness
+// ============================================================================
+
+/**
+ * Generate a unique branch name that doesn't conflict with existing branches
+ */
+export function generateUniqueBranchName(baseName: string, options: { cwd?: string; maxAttempts?: number } = {}): string {
+  const { cwd, maxAttempts = 10 } = options;
+  const timestamp = Date.now().toString(36);
+  const random = () => Math.random().toString(36).substring(2, 5);
+  
+  // First attempt: base name with timestamp
+  let candidate = `${baseName}-${timestamp}-${random()}`;
+  
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    if (!branchExists(candidate, { cwd })) {
+      return candidate;
+    }
+    // Try with new random suffix
+    candidate = `${baseName}-${timestamp}-${random()}`;
+  }
+  
+  // Last resort: use full timestamp with random
+  return `${baseName}-${Date.now()}-${random()}`;
+}
+
+/**
+ * Safe merge result
+ */
+export interface SafeMergeResult {
+  success: boolean;
+  conflict: boolean;
+  conflictingFiles: string[];
+  error?: string;
+  aborted: boolean;
+}
+
+/**
+ * Safely merge a branch with conflict detection and auto-abort
+ */
+export function safeMerge(branchName: string, options: { 
+  cwd?: string; 
+  noFf?: boolean; 
+  message?: string | null;
+  abortOnConflict?: boolean;
+  strategy?: 'ours' | 'theirs' | null;
+} = {}): SafeMergeResult {
+  const { cwd, noFf = false, message = null, abortOnConflict = true, strategy = null } = options;
+  
+  const args = ['merge'];
+  
+  if (noFf) {
+    args.push('--no-ff');
+  }
+  
+  if (strategy) {
+    args.push('-X', strategy);
+  }
+  
+  if (message) {
+    args.push('-m', message);
+  }
+  
+  args.push(branchName);
+  
+  const result = runGitResult(args, { cwd });
+  
+  if (result.success) {
+    return {
+      success: true,
+      conflict: false,
+      conflictingFiles: [],
+      aborted: false,
+    };
+  }
+  
+  // Check for conflicts
+  const output = result.stdout + result.stderr;
+  const isConflict = output.includes('CONFLICT') || output.includes('Automatic merge failed');
+  
+  if (isConflict) {
+    // Get conflicting files
+    const conflictingFiles = getConflictingFiles(cwd);
+    
+    if (abortOnConflict) {
+      // Abort the merge
+      runGitResult(['merge', '--abort'], { cwd });
+      
+      return {
+        success: false,
+        conflict: true,
+        conflictingFiles,
+        error: 'Merge conflict detected and aborted',
+        aborted: true,
+      };
+    }
+    
+    return {
+      success: false,
+      conflict: true,
+      conflictingFiles,
+      error: 'Merge conflict - manual resolution required',
+      aborted: false,
+    };
+  }
+  
+  return {
+    success: false,
+    conflict: false,
+    conflictingFiles: [],
+    error: result.stderr || 'Merge failed',
+    aborted: false,
+  };
+}
+
+/**
+ * Get list of conflicting files
+ */
+export function getConflictingFiles(cwd?: string): string[] {
+  const result = runGitResult(['diff', '--name-only', '--diff-filter=U'], { cwd });
+  if (!result.success) return [];
+  
+  return result.stdout.split('\n').filter(f => f.trim());
+}
+
+/**
+ * Check if merge is in progress
+ */
+export function isMergeInProgress(cwd?: string): boolean {
+  const repoRoot = getRepoRoot(cwd);
+  return fs.existsSync(path.join(repoRoot, '.git', 'MERGE_HEAD'));
+}
+
+/**
+ * Abort ongoing merge
+ */
+export function abortMerge(cwd?: string): boolean {
+  const result = runGitResult(['merge', '--abort'], { cwd });
+  return result.success;
+}
+
+/**
+ * Get HEAD commit hash
+ */
+export function getHead(cwd?: string): string {
+  return runGit(['rev-parse', 'HEAD'], { cwd, silent: true });
+}
+
+/**
+ * Get short HEAD commit hash
+ */
+export function getHeadShort(cwd?: string): string {
+  return runGit(['rev-parse', '--short', 'HEAD'], { cwd, silent: true });
+}
+
+/**
+ * Stash changes with optional message
+ */
+export function stash(message?: string, options: { cwd?: string } = {}): boolean {
+  const args = ['stash', 'push'];
+  if (message) {
+    args.push('-m', message);
+  }
+  
+  const result = runGitResult(args, { cwd: options.cwd });
+  return result.success;
+}
+
+/**
+ * Pop stashed changes
+ */
+export function stashPop(options: { cwd?: string } = {}): boolean {
+  const result = runGitResult(['stash', 'pop'], { cwd: options.cwd });
+  return result.success;
+}
+
+/**
+ * Clean worktree (remove untracked files)
+ */
+export function cleanWorktree(options: { cwd?: string; force?: boolean; directories?: boolean } = {}): void {
+  const args = ['clean'];
+  if (options.force) args.push('-f');
+  if (options.directories) args.push('-d');
+  
+  runGit(args, { cwd: options.cwd });
+}
+
+/**
+ * Reset worktree to specific commit/branch
+ */
+export function reset(target: string, options: { cwd?: string; mode?: 'soft' | 'mixed' | 'hard' } = {}): void {
+  const args = ['reset'];
+  if (options.mode) args.push(`--${options.mode}`);
+  args.push(target);
+  
+  runGit(args, { cwd: options.cwd });
+}
+
+/**
+ * Checkout specific commit or branch
+ */
+export function checkout(target: string, options: { cwd?: string; force?: boolean; createBranch?: boolean } = {}): void {
+  const args = ['checkout'];
+  if (options.force) args.push('-f');
+  if (options.createBranch) args.push('-b');
+  args.push(target);
+  
+  runGit(args, { cwd: options.cwd });
+}
+
+/**
+ * Get commits between two refs
+ */
+export function getCommitsBetween(fromRef: string, toRef: string, options: { cwd?: string } = {}): CommitInfo[] {
+  const format = '%H|%h|%an|%ae|%at|%s';
+  const result = runGitResult(['log', '--format=' + format, `${fromRef}..${toRef}`], { cwd: options.cwd });
+  
+  if (!result.success) return [];
+  
+  return result.stdout.split('\n')
+    .filter(line => line.trim())
+    .map(line => {
+      const parts = line.split('|');
+      return {
+        hash: parts[0] || '',
+        shortHash: parts[1] || '',
+        author: parts[2] || '',
+        authorEmail: parts[3] || '',
+        timestamp: parseInt(parts[4] || '0'),
+        subject: parts[5] || '',
+      };
+    });
+}
+
+/**
+ * Enhanced worktree creation with async lock
+ */
+export async function createWorktreeAsync(
+  worktreePath: string, 
+  branchName: string, 
+  options: { cwd?: string; baseBranch?: string; timeout?: number } = {}
+): Promise<string> {
+  let { cwd, baseBranch, timeout = 30000 } = options;
+  
+  if (!baseBranch) {
+    baseBranch = getCurrentBranch(cwd) || 'refs/heads/main';
+  }
+
+  // Ensure baseBranch is unambiguous
+  const unambiguousBase = (baseBranch.startsWith('refs/') || baseBranch.includes('/')) 
+    ? baseBranch 
+    : `refs/heads/${baseBranch}`;
+
+  const { acquireLock, releaseLock } = await import('./lock');
+  const lockDir = safeJoin(cwd || getRepoRoot(), '_cursorflow', 'locks');
+  if (!fs.existsSync(lockDir)) {
+    fs.mkdirSync(lockDir, { recursive: true });
+  }
+  const lockFile = safeJoin(lockDir, 'worktree.lock');
+  
+  const acquired = await acquireLock(lockFile, { 
+    timeoutMs: timeout,
+    operation: `createWorktree:${branchName}`,
+  });
+  
+  if (!acquired) {
+    throw new Error('Failed to acquire worktree lock after timeout');
+  }
+  
+  try {
+    // Check if branch already exists
+    const branchExistsLocal = runGitResult(['rev-parse', '--verify', branchName], { cwd }).success;
+    
+    if (branchExistsLocal) {
+      runGit(['worktree', 'add', worktreePath, branchName], { cwd });
+    } else {
+      runGit(['worktree', 'add', '-b', branchName, worktreePath, unambiguousBase], { cwd });
+    }
+    
+    return worktreePath;
+  } finally {
+    await releaseLock(lockFile);
+  }
+}
+
+/**
+ * Prune orphaned worktrees
+ */
+export function pruneWorktrees(options: { cwd?: string } = {}): void {
+  runGit(['worktree', 'prune'], { cwd: options.cwd });
+}
+
+/**
+ * Get worktree for a specific path
+ */
+export function getWorktreeForPath(targetPath: string, cwd?: string): WorktreeInfo | null {
+  const worktrees = listWorktrees(cwd);
+  return worktrees.find(wt => wt.path === targetPath) || null;
+}
+
+/**
+ * Sync branch with remote (fetch + merge or rebase)
+ */
+export function syncWithRemote(branch: string, options: { 
+  cwd?: string; 
+  strategy?: 'merge' | 'rebase';
+  createIfMissing?: boolean;
+} = {}): { success: boolean; error?: string } {
+  const { cwd, strategy = 'merge', createIfMissing = false } = options;
+  
+  // Fetch the branch
+  const fetchResult = runGitResult(['fetch', 'origin', branch], { cwd });
+  
+  if (!fetchResult.success) {
+    if (createIfMissing && fetchResult.stderr.includes('not found')) {
+      // Branch doesn't exist on remote, nothing to sync
+      return { success: true };
+    }
+    return { success: false, error: fetchResult.stderr };
+  }
+  
+  // Merge or rebase
+  if (strategy === 'rebase') {
+    const result = runGitResult(['rebase', `origin/${branch}`], { cwd });
+    if (!result.success) {
+      // Abort rebase on failure
+      runGitResult(['rebase', '--abort'], { cwd });
+      return { success: false, error: result.stderr };
+    }
+  } else {
+    const mergeResult = safeMerge(`origin/${branch}`, { 
+      cwd, 
+      message: `chore: sync with origin/${branch}`,
+      abortOnConflict: true,
+    });
+    
+    if (!mergeResult.success) {
+      return { success: false, error: mergeResult.error };
+    }
+  }
+  
+  return { success: true };
 }