@hyperdrive.bot/cli 1.0.2

package/dist/services/git.js

@@ -0,0 +1,409 @@
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+export class GitService {
+    DEFAULT_EXCLUDES = [
+        // Always exclude these regardless of .gitignore
+        'tmp',
+        'temp'
+    ];
+    async branchExists(tmpProjectPath, branchName, remote) {
+        const result = await this.executeCommand(`git show-ref --verify --quiet refs/remotes/${remote}/${branchName}`, tmpProjectPath);
+        return result.success;
+    }
+    async checkoutBranch(tmpProjectPath, branchName, remote) {
+        // Clean untracked files before reset
+        const cleanResult = await this.executeCommand('git clean -fd', tmpProjectPath);
+        if (!cleanResult.success) {
+            return {
+                error: `Failed to clean untracked files before checkout: ${cleanResult.stderr || cleanResult.stdout || 'Unknown error'}`,
+                success: false
+            };
+        }
+        // First reset any local changes to ensure clean checkout
+        const resetResult = await this.executeCommand('git reset --hard HEAD', tmpProjectPath);
+        if (!resetResult.success) {
+            return {
+                error: `Failed to reset working directory before checkout: ${resetResult.stderr || resetResult.stdout || 'Unknown error'}`,
+                success: false
+            };
+        }
+        // First try to checkout existing local branch
+        let result = await this.executeCommand(`git checkout ${branchName}`, tmpProjectPath);
+        if (!result.success) {
+            // If local branch doesn't exist, create it from remote
+            result = await this.executeCommand(`git checkout -b ${branchName} ${remote}/${branchName}`, tmpProjectPath);
+            if (!result.success) {
+                return {
+                    error: `Failed to checkout/create branch ${branchName}: ${result.stderr || result.stdout || 'Unknown error'}`,
+                    success: false
+                };
+            }
+        }
+        return { success: true };
+    }
+    async cleanupTmpDir(tmpDir) {
+        try {
+            fs.rmSync(tmpDir, { force: true, recursive: true });
+        }
+        catch (error) {
+            // Ignore cleanup errors
+            console.warn(`Warning: Failed to cleanup temporary directory: ${tmpDir}`);
+        }
+    }
+    async copyProjectToTmp(sourcePath, tmpDir, verbose = false, progressCallback) {
+        // Get exclusion patterns from .gitignore
+        const excludePatterns = this.getExcludePatterns(sourcePath);
+        if (verbose) {
+            progressCallback?.('📂', 'cyan', `Found ${excludePatterns.length} exclusion patterns from .gitignore`);
+            console.log('Exclusion patterns:', excludePatterns);
+        }
+        // Try rsync first for better performance
+        if (await this.tryRsyncCopy(sourcePath, tmpDir, excludePatterns, verbose, progressCallback)) {
+            return;
+        }
+        // Fallback to manual copy with exclusions
+        progressCallback?.('📂', 'cyan', 'rsync not available, using manual copy with exclusions...');
+        await this.copyWithExclusions(sourcePath, tmpDir, excludePatterns, verbose, progressCallback);
+    }
+    async createTmpDir() {
+        const tmpDir = path.join(os.tmpdir(), `hyperdrive-sync-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`);
+        fs.mkdirSync(tmpDir, { recursive: true });
+        return tmpDir;
+    }
+    async fetchRemote(tmpProjectPath, remote) {
+        const result = await this.executeCommand(`git fetch ${remote}`, tmpProjectPath, 30000); // 30 second timeout
+        if (!result.success) {
+            throw new Error(`Failed to fetch from remote ${remote}: ${result.stderr}`);
+        }
+    }
+    async getAllRemoteBranches(tmpProjectPath, remote) {
+        const result = await this.executeCommand(`git branch -r`, tmpProjectPath);
+        if (!result.success) {
+            throw new Error(`Failed to get remote branches: ${result.stderr}`);
+        }
+        return result.stdout
+            .split('\n')
+            .map(branch => branch.trim())
+            .filter(branch => branch.startsWith(`${remote}/`) && !branch.includes('HEAD'))
+            .map(branch => branch.replace(`${remote}/`, ''))
+            .filter(branch => branch.length > 0);
+    }
+    async getCurrentBranch(tmpProjectPath) {
+        const result = await this.executeCommand('git branch --show-current', tmpProjectPath);
+        if (!result.success) {
+            throw new Error(`Failed to get current branch: ${result.stderr}`);
+        }
+        return result.stdout.trim();
+    }
+    async mergeBranch(tmpProjectPath, sourceBranch, remote, mergeStrategy) {
+        // Clean untracked files before merge
+        const cleanResult = await this.executeCommand('git clean -fd', tmpProjectPath);
+        if (!cleanResult.success) {
+            return { error: `Failed to clean untracked files before merge: ${cleanResult.stderr}`, hasConflicts: false, success: false };
+        }
+        // Reset to ensure clean state before merge
+        const resetResult = await this.executeCommand('git reset --hard HEAD', tmpProjectPath);
+        if (!resetResult.success) {
+            return { error: `Failed to reset before merge: ${resetResult.stderr}`, hasConflicts: false, success: false };
+        }
+        // First, ensure we have the latest source branch
+        const fetchResult = await this.executeCommand(`git fetch ${remote} ${sourceBranch}`, tmpProjectPath, 30000);
+        if (!fetchResult.success) {
+            return { error: `Failed to fetch ${sourceBranch}: ${fetchResult.stderr}`, hasConflicts: false, success: false };
+        }
+        // Attempt merge
+        const mergeCommand = mergeStrategy === 'no-ff'
+            ? `git merge --no-ff --allow-unrelated-histories ${remote}/${sourceBranch}`
+            : `git merge ${mergeStrategy} --allow-unrelated-histories ${remote}/${sourceBranch}`;
+        const result = await this.executeCommand(mergeCommand, tmpProjectPath, 30000);
+        if (!result.success) {
+            // Check if it's a merge conflict
+            const statusResult = await this.executeCommand('git status --porcelain', tmpProjectPath);
+            const hasConflicts = statusResult.stdout.includes('UU') ||
+                statusResult.stdout.includes('AA') ||
+                result.stderr.includes('CONFLICT');
+            // Abort the merge if there are conflicts
+            if (hasConflicts) {
+                await this.executeCommand('git merge --abort', tmpProjectPath);
+            }
+            return {
+                error: hasConflicts ? 'Merge conflicts detected' : result.stderr,
+                hasConflicts,
+                success: false
+            };
+        }
+        return { hasConflicts: false, success: true };
+    }
+    async pushBranch(tmpProjectPath, branchName, remote) {
+        const result = await this.executeCommand(`git push ${remote} ${branchName}`, tmpProjectPath, 30000);
+        if (!result.success) {
+            return {
+                error: `Failed to push branch ${branchName}: ${result.stderr || result.stdout || 'Unknown error'}`,
+                success: false
+            };
+        }
+        return { success: true };
+    }
+    async syncBranches(options, progressCallback) {
+        const results = [];
+        let tmpDir;
+        try {
+            progressCallback?.('🏗️', 'blue', 'Creating temporary workspace...');
+            // Create temporary directory
+            tmpDir = options.tmpDir || await this.createTmpDir();
+            progressCallback?.('📂', 'cyan', 'Copying project files (excluding .gitignore patterns)...');
+            // Copy current project to tmp directory
+            await this.copyProjectToTmp(process.cwd(), tmpDir, options.verbose, progressCallback);
+            const tmpProjectPath = path.join(tmpDir, 'project');
+            progressCallback?.('🌐', 'blue', 'Fetching remote branches...');
+            // Fetch all branches from remote
+            await this.fetchRemote(tmpProjectPath, options.remote);
+            progressCallback?.('🔍', 'yellow', 'Determining branches to sync...');
+            // Determine which branches to sync
+            let branchesToSync = [];
+            if (options.all) {
+                branchesToSync = await this.getAllRemoteBranches(tmpProjectPath, options.remote);
+            }
+            else if (options.targetBranches && options.targetBranches.length > 0) {
+                // Verify the target branches exist
+                for (const branch of options.targetBranches) {
+                    const exists = await this.branchExists(tmpProjectPath, branch, options.remote);
+                    if (!exists) {
+                        return [{
+                                branch,
+                                error: `Branch ${branch} does not exist on remote ${options.remote}`,
+                                success: false
+                            }];
+                    }
+                }
+                branchesToSync = options.targetBranches;
+            }
+            progressCallback?.('⚙️', 'magenta', `Processing ${branchesToSync.length} branches...`);
+            // Process each branch
+            for (const branch of branchesToSync) {
+                // Skip the source branch (no need to merge itself)
+                if (branch === options.sourceBranch) {
+                    continue;
+                }
+                try {
+                    progressCallback?.('🔄', 'cyan', `Syncing branch: ${branch}`);
+                    // Checkout the target branch
+                    const checkoutResult = await this.checkoutBranch(tmpProjectPath, branch, options.remote);
+                    if (!checkoutResult.success) {
+                        results.push({
+                            branch,
+                            error: checkoutResult.error,
+                            success: false
+                        });
+                        continue;
+                    }
+                    progressCallback?.('🔀', 'yellow', `Merging branch: ${options.remote}/${options.sourceBranch} into ${branch}`);
+                    // Merge source branch into target branch
+                    const mergeResult = await this.mergeBranch(tmpProjectPath, options.sourceBranch, options.remote, options.mergeStrategy);
+                    if (!mergeResult.success) {
+                        progressCallback?.('❌', 'red', `Merge failed: ${mergeResult.error}`);
+                        results.push({
+                            branch,
+                            conflicts: mergeResult.hasConflicts,
+                            error: mergeResult.error,
+                            success: false
+                        });
+                        continue;
+                    }
+                    progressCallback?.('⬆️', 'blue', ` Pushing branch: ${options.remote}/${branch}`);
+                    // Pull latest changes from remote before pushing
+                    progressCallback?.('⬇️', 'blue', ` Pulling latest changes for branch: ${branch}`);
+                    const pullResult = await this.executeCommand(`git pull ${options.remote} ${branch}`, tmpProjectPath, 30000);
+                    if (!pullResult.success) {
+                        // If pull fails, it might be because the branch doesn't exist remotely yet, which is fine
+                        // We'll try to push anyway and let the push command handle it
+                        progressCallback?.('⚠️', 'yellow', ` Pull failed (branch might be new): ${pullResult.stderr}`);
+                    }
+                    // Push the merged branch
+                    const pushResult = await this.pushBranch(tmpProjectPath, branch, options.remote);
+                    if (!pushResult.success) {
+                        results.push({
+                            branch,
+                            error: pushResult.error,
+                            success: false
+                        });
+                        continue;
+                    }
+                    progressCallback?.('✅', 'green', `Branch ${branch} synced successfully`);
+                    results.push({
+                        branch,
+                        success: true
+                    });
+                }
+                catch (error) {
+                    results.push({
+                        branch,
+                        error: error instanceof Error ? error.message : String(error),
+                        success: false
+                    });
+                }
+            }
+        }
+        finally {
+            progressCallback?.('🧹', 'gray', 'Cleaning up temporary files...');
+            // Cleanup temporary directory
+            if (tmpDir) {
+                await this.cleanupTmpDir(tmpDir);
+            }
+        }
+        return results;
+    }
+    async copyDirectoryRecursive(sourceDir, targetDir, excludeRegexes, verbose, progressCallback, basePath = '') {
+        // Get all items in source directory
+        const items = fs.readdirSync(sourceDir, { withFileTypes: true });
+        let copiedCount = 0;
+        let skippedCount = 0;
+        for (const item of items) {
+            const relativePath = path.join(basePath, item.name);
+            const isExcluded = excludeRegexes.some(regex => regex.test(relativePath) || regex.test(item.name));
+            if (isExcluded) {
+                skippedCount++;
+                if (verbose) {
+                    console.log(`Skipped: ${relativePath}`);
+                }
+                continue;
+            }
+            const sourcePath_item = path.join(sourceDir, item.name);
+            const targetPath = path.join(targetDir, item.name);
+            if (item.isDirectory()) {
+                fs.mkdirSync(targetPath, { recursive: true });
+                await this.copyDirectoryRecursive(sourcePath_item, targetPath, excludeRegexes, verbose, progressCallback, relativePath);
+            }
+            else {
+                fs.copyFileSync(sourcePath_item, targetPath);
+                copiedCount++;
+                if (verbose) {
+                    console.log(`Copied: ${relativePath}`);
+                }
+            }
+        }
+        if (verbose && basePath === '') {
+            progressCallback?.('📂', 'green', `Manual copy completed: ${copiedCount} files copied, ${skippedCount} files skipped`);
+        }
+    }
+    async copyWithExclusions(sourcePath, tmpDir, excludePatterns, verbose, progressCallback) {
+        const projectDir = path.join(tmpDir, 'project');
+        fs.mkdirSync(projectDir, { recursive: true });
+        if (verbose) {
+            progressCallback?.('📂', 'cyan', 'Starting manual file copy with exclusions...');
+        }
+        // Convert gitignore patterns to regex for matching
+        const excludeRegexes = excludePatterns.map(pattern => this.gitignorePatternToRegex(pattern));
+        await this.copyDirectoryRecursive(sourcePath, projectDir, excludeRegexes, verbose, progressCallback);
+    }
+    async executeCommand(command, cwd, timeout = 10000) {
+        try {
+            const result = execSync(command, {
+                cwd,
+                encoding: 'utf8',
+                env: {
+                    ...process.env,
+                    GIT_TERMINAL_PROMPT: '0' // Disable interactive prompts
+                },
+                stdio: 'pipe',
+                timeout
+            });
+            return { stderr: '', stdout: result, success: true };
+        }
+        catch (error) {
+            const execError = error;
+            // Handle timeout specifically
+            if (execError.code === 'ETIMEDOUT') {
+                return {
+                    stderr: `Command timed out after ${timeout}ms: ${command}`,
+                    stdout: '',
+                    success: false
+                };
+            }
+            return {
+                stderr: execError.stderr || execError.message || '',
+                stdout: execError.stdout || '',
+                success: false
+            };
+        }
+    }
+    getExcludePatterns(sourcePath) {
+        const gitignorePath = path.join(sourcePath, '.gitignore');
+        const patterns = [...this.DEFAULT_EXCLUDES];
+        try {
+            if (fs.existsSync(gitignorePath)) {
+                const gitignoreContent = fs.readFileSync(gitignorePath, 'utf8');
+                const gitignorePatterns = this.parseGitignore(gitignoreContent);
+                patterns.push(...gitignorePatterns);
+            }
+        }
+        catch (error) {
+            console.warn(`Warning: Could not read .gitignore file: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return patterns;
+    }
+    gitignorePatternToRegex(pattern) {
+        // Escape special regex characters except for * and ?
+        let regexPattern = pattern
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.');
+        // If pattern ends with /, it only matches directories
+        if (pattern.endsWith('/')) {
+            regexPattern = regexPattern.slice(0, -1) + '$';
+        }
+        // If pattern doesn't start with /, it can match at any level
+        if (!pattern.startsWith('/')) {
+            regexPattern = `(^|/)${regexPattern}`;
+        }
+        return new RegExp(regexPattern);
+    }
+    parseGitignore(content) {
+        return content
+            .split('\n')
+            .map(line => line.trim())
+            .filter(line => {
+            // Skip empty lines and comments
+            if (!line || line.startsWith('#'))
+                return false;
+            // Skip negation patterns for simplicity (lines starting with !)
+            if (line.startsWith('!'))
+                return false;
+            return true;
+        })
+            .map(line => {
+            // Remove leading slash for rsync compatibility
+            if (line.startsWith('/')) {
+                return line.substring(1);
+            }
+            return line;
+        });
+    }
+    async tryRsyncCopy(sourcePath, tmpDir, excludePatterns, verbose, progressCallback) {
+        try {
+            // Build rsync exclude patterns
+            const excludeArgs = excludePatterns.map(pattern => `--exclude='${pattern}'`).join(' ');
+            // Add rsync flags for verbose output if requested
+            const verboseFlag = verbose ? '-v' : '';
+            const command = `rsync -a${verboseFlag} ${excludeArgs} "${sourcePath}/" "${tmpDir}/project/"`;
+            if (verbose) {
+                progressCallback?.('⚡', 'cyan', `Executing: ${command}`);
+            }
+            const result = await this.executeCommand(command, process.cwd(), 60000); // 60 second timeout
+            if (verbose && result.stdout) {
+                const files = result.stdout.split('\n').filter(line => line.trim() && !line.endsWith('/'));
+                progressCallback?.('⚡', 'green', `Copied ${files.length} files using rsync`);
+                console.log('Files copied:', files);
+            }
+            return result.success;
+        }
+        catch (error) {
+            if (verbose) {
+                progressCallback?.('⚠️', 'yellow', `rsync failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return false;
+        }
+    }
+}