@litmers/cursorflow-orchestrator 0.1.18 → 0.1.26

package/dist/utils/git.d.ts

@@ -44,6 +44,10 @@ export declare function getCurrentBranch(cwd?: string): string;
  * Get repository root directory
  */
 export declare function getRepoRoot(cwd?: string): string;
+/**
+ * Get main repository root directory (for worktrees)
+ */
+export declare function getMainRepoRoot(cwd?: string): string;
 /**
  * Check if directory is a git repository
  */
@@ -140,3 +144,120 @@ export declare function getCommitInfo(commitHash: string, options?: {
  * Comparing HEAD with its first parent
  */
 export declare function getLastOperationStats(cwd?: string): string;
+/**
+ * Generate a unique branch name that doesn't conflict with existing branches
+ */
+export declare function generateUniqueBranchName(baseName: string, options?: {
+    cwd?: string;
+    maxAttempts?: number;
+}): string;
+/**
+ * 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 declare function safeMerge(branchName: string, options?: {
+    cwd?: string;
+    noFf?: boolean;
+    message?: string | null;
+    abortOnConflict?: boolean;
+    strategy?: 'ours' | 'theirs' | null;
+}): SafeMergeResult;
+/**
+ * Get list of conflicting files
+ */
+export declare function getConflictingFiles(cwd?: string): string[];
+/**
+ * Check if merge is in progress
+ */
+export declare function isMergeInProgress(cwd?: string): boolean;
+/**
+ * Abort ongoing merge
+ */
+export declare function abortMerge(cwd?: string): boolean;
+/**
+ * Get HEAD commit hash
+ */
+export declare function getHead(cwd?: string): string;
+/**
+ * Get short HEAD commit hash
+ */
+export declare function getHeadShort(cwd?: string): string;
+/**
+ * Stash changes with optional message
+ */
+export declare function stash(message?: string, options?: {
+    cwd?: string;
+}): boolean;
+/**
+ * Pop stashed changes
+ */
+export declare function stashPop(options?: {
+    cwd?: string;
+}): boolean;
+/**
+ * Clean worktree (remove untracked files)
+ */
+export declare function cleanWorktree(options?: {
+    cwd?: string;
+    force?: boolean;
+    directories?: boolean;
+}): void;
+/**
+ * Reset worktree to specific commit/branch
+ */
+export declare function reset(target: string, options?: {
+    cwd?: string;
+    mode?: 'soft' | 'mixed' | 'hard';
+}): void;
+/**
+ * Checkout specific commit or branch
+ */
+export declare function checkout(target: string, options?: {
+    cwd?: string;
+    force?: boolean;
+    createBranch?: boolean;
+}): void;
+/**
+ * Get commits between two refs
+ */
+export declare function getCommitsBetween(fromRef: string, toRef: string, options?: {
+    cwd?: string;
+}): CommitInfo[];
+/**
+ * Enhanced worktree creation with async lock
+ */
+export declare function createWorktreeAsync(worktreePath: string, branchName: string, options?: {
+    cwd?: string;
+    baseBranch?: string;
+    timeout?: number;
+}): Promise<string>;
+/**
+ * Prune orphaned worktrees
+ */
+export declare function pruneWorktrees(options?: {
+    cwd?: string;
+}): void;
+/**
+ * Get worktree for a specific path
+ */
+export declare function getWorktreeForPath(targetPath: string, cwd?: string): WorktreeInfo | null;
+/**
+ * Sync branch with remote (fetch + merge or rebase)
+ */
+export declare function syncWithRemote(branch: string, options?: {
+    cwd?: string;
+    strategy?: 'merge' | 'rebase';
+    createIfMissing?: boolean;
+}): {
+    success: boolean;
+    error?: string;
+};

package/dist/utils/git.js

@@ -2,11 +2,45 @@
 /**
  * Git utilities for CursorFlow
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runGit = runGit;
 exports.runGitResult = runGitResult;
 exports.getCurrentBranch = getCurrentBranch;
 exports.getRepoRoot = getRepoRoot;
+exports.getMainRepoRoot = getMainRepoRoot;
 exports.isGitRepo = isGitRepo;
 exports.worktreeExists = worktreeExists;
 exports.createWorktree = createWorktree;
@@ -23,18 +57,122 @@ exports.deleteBranch = deleteBranch;
 exports.merge = merge;
 exports.getCommitInfo = getCommitInfo;
 exports.getLastOperationStats = getLastOperationStats;
+exports.generateUniqueBranchName = generateUniqueBranchName;
+exports.safeMerge = safeMerge;
+exports.getConflictingFiles = getConflictingFiles;
+exports.isMergeInProgress = isMergeInProgress;
+exports.abortMerge = abortMerge;
+exports.getHead = getHead;
+exports.getHeadShort = getHeadShort;
+exports.stash = stash;
+exports.stashPop = stashPop;
+exports.cleanWorktree = cleanWorktree;
+exports.reset = reset;
+exports.checkout = checkout;
+exports.getCommitsBetween = getCommitsBetween;
+exports.createWorktreeAsync = createWorktreeAsync;
+exports.pruneWorktrees = pruneWorktrees;
+exports.getWorktreeForPath = getWorktreeForPath;
+exports.syncWithRemote = syncWithRemote;
 const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const path_1 = require("./path");
+/**
+ * Acquire a file-based lock for Git operations
+ */
+function acquireLock(lockName, cwd) {
+    const repoRoot = cwd || getRepoRoot();
+    const lockDir = (0, path_1.safeJoin)(repoRoot, '_cursorflow', 'locks');
+    if (!fs.existsSync(lockDir)) {
+        fs.mkdirSync(lockDir, { recursive: true });
+    }
+    const lockFile = (0, path_1.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) {
+    if (lockFile && fs.existsSync(lockFile)) {
+        try {
+            fs.unlinkSync(lockFile);
+        }
+        catch {
+            // Ignore
+        }
+    }
+}
+/**
+ * Run Git command with locking
+ */
+async function runGitWithLock(lockName, fn, options = {}) {
+    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);
+    }
+}
+/**
+ * Filter out noisy git stderr messages
+ */
+function filterGitStderr(stderr) {
+    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
  */
 function runGit(args, options = {}) {
     const { cwd, silent = false } = options;
     try {
+        const stdioMode = silent ? 'pipe' : ['inherit', 'inherit', 'pipe'];
         const result = (0, child_process_1.spawnSync)('git', args, {
             cwd: cwd || process.cwd(),
             encoding: 'utf8',
-            stdio: silent ? 'pipe' : 'inherit',
+            stdio: stdioMode,
         });
+        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 || ''}`);
         }
@@ -76,6 +214,24 @@ function getCurrentBranch(cwd) {
 function getRepoRoot(cwd) {
     return runGit(['rev-parse', '--show-toplevel'], { cwd, silent: true });
 }
+/**
+ * Get main repository root directory (for worktrees)
+ */
+function getMainRepoRoot(cwd) {
+    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
  */
@@ -96,18 +252,59 @@ function worktreeExists(worktreePath, cwd) {
  * Create worktree
  */
 function createWorktree(worktreePath, branchName, options = {}) {
-    const { cwd, baseBranch = 'main' } = options;
-    // 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 });
+    let { cwd, baseBranch } = options;
+    if (!baseBranch) {
+        baseBranch = getCurrentBranch(cwd) || 'refs/heads/main';
     }
-    else {
-        // Create new branch from base
-        runGit(['worktree', 'add', '-b', branchName, worktreePath, baseBranch], { cwd });
+    // 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 = (0, path_1.safeJoin)(cwd || getRepoRoot(), '_cursorflow', 'locks');
+    if (!fs.existsSync(lockDir)) {
+        fs.mkdirSync(lockDir, { recursive: true });
+    }
+    const lockFile = (0, path_1.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 (!acquired) {
+        throw new Error('Failed to acquire worktree lock after multiple retries');
+    }
+    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
+        }
     }
-    return worktreePath;
 }
 /**
  * Remove worktree
@@ -309,4 +506,280 @@ function getLastOperationStats(cwd) {
         return '';
     }
 }
+// ============================================================================
+// Enhanced Git Functions for Robustness
+// ============================================================================
+/**
+ * Generate a unique branch name that doesn't conflict with existing branches
+ */
+function generateUniqueBranchName(baseName, options = {}) {
+    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()}`;
+}
+/**
+ * Safely merge a branch with conflict detection and auto-abort
+ */
+function safeMerge(branchName, options = {}) {
+    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
+ */
+function getConflictingFiles(cwd) {
+    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
+ */
+function isMergeInProgress(cwd) {
+    const repoRoot = getRepoRoot(cwd);
+    return fs.existsSync(path.join(repoRoot, '.git', 'MERGE_HEAD'));
+}
+/**
+ * Abort ongoing merge
+ */
+function abortMerge(cwd) {
+    const result = runGitResult(['merge', '--abort'], { cwd });
+    return result.success;
+}
+/**
+ * Get HEAD commit hash
+ */
+function getHead(cwd) {
+    return runGit(['rev-parse', 'HEAD'], { cwd, silent: true });
+}
+/**
+ * Get short HEAD commit hash
+ */
+function getHeadShort(cwd) {
+    return runGit(['rev-parse', '--short', 'HEAD'], { cwd, silent: true });
+}
+/**
+ * Stash changes with optional message
+ */
+function stash(message, options = {}) {
+    const args = ['stash', 'push'];
+    if (message) {
+        args.push('-m', message);
+    }
+    const result = runGitResult(args, { cwd: options.cwd });
+    return result.success;
+}
+/**
+ * Pop stashed changes
+ */
+function stashPop(options = {}) {
+    const result = runGitResult(['stash', 'pop'], { cwd: options.cwd });
+    return result.success;
+}
+/**
+ * Clean worktree (remove untracked files)
+ */
+function cleanWorktree(options = {}) {
+    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
+ */
+function reset(target, options = {}) {
+    const args = ['reset'];
+    if (options.mode)
+        args.push(`--${options.mode}`);
+    args.push(target);
+    runGit(args, { cwd: options.cwd });
+}
+/**
+ * Checkout specific commit or branch
+ */
+function checkout(target, options = {}) {
+    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
+ */
+function getCommitsBetween(fromRef, toRef, options = {}) {
+    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
+ */
+async function createWorktreeAsync(worktreePath, branchName, options = {}) {
+    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 Promise.resolve().then(() => __importStar(require('./lock')));
+    const lockDir = (0, path_1.safeJoin)(cwd || getRepoRoot(), '_cursorflow', 'locks');
+    if (!fs.existsSync(lockDir)) {
+        fs.mkdirSync(lockDir, { recursive: true });
+    }
+    const lockFile = (0, path_1.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
+ */
+function pruneWorktrees(options = {}) {
+    runGit(['worktree', 'prune'], { cwd: options.cwd });
+}
+/**
+ * Get worktree for a specific path
+ */
+function getWorktreeForPath(targetPath, cwd) {
+    const worktrees = listWorktrees(cwd);
+    return worktrees.find(wt => wt.path === targetPath) || null;
+}
+/**
+ * Sync branch with remote (fetch + merge or rebase)
+ */
+function syncWithRemote(branch, options = {}) {
+    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 };
+}
 //# sourceMappingURL=git.js.map