bobs-workshop 0.3.3 → 3.1.1

package/dist/tools/gitTools.js

@@ -1,741 +0,0 @@
-// src/tools/gitTools.ts
-import { exec } from "child_process";
-import { promisify } from "util";
-import { z } from "zod";
-import path from "path";
-import fs from "fs";
-import os from "os";
-import { specGetHandler, specUpdateHandler } from "./specTools.js";
-const execAsync = promisify(exec);
-// Find worktree path associated with a SPEC
-export async function findWorktreeForSpec(specId) {
-    try {
-        console.log(`Finding worktree for SPEC: ${specId}`);
-        // PRIMARY: Read SPEC metadata for worktree information
-        try {
-            const spec = await specGetHandler({ spec_id: specId });
-            if (spec.worktree && spec.worktree.path && spec.worktree.status === 'active') {
-                console.log(`Found worktree in SPEC metadata: ${spec.worktree.path}`);
-                // Verify the path actually exists
-                if (fs.existsSync(spec.worktree.path)) {
-                    console.log(`✅ SPEC metadata worktree verified: ${spec.worktree.path}`);
-                    return spec.worktree.path;
-                }
-                else {
-                    console.warn(`⚠️ SPEC metadata has path ${spec.worktree.path} but it doesn't exist on filesystem`);
-                    // Continue to fallback methods
-                }
-            }
-            else {
-                console.log(`SPEC metadata doesn't have active worktree (status: ${spec.worktree?.status || 'missing'})`);
-            }
-        }
-        catch (specError) {
-            console.warn('Could not read SPEC metadata, falling back to heuristic:', specError);
-        }
-        // FALLBACK 1: Use git worktree list with pattern matching
-        const { stdout } = await execAsync('git worktree list --porcelain');
-        console.log(`Git worktree list output:\n${stdout}`);
-        if (!stdout.trim()) {
-            console.log('No worktrees found');
-            return null;
-        }
-        const worktrees = stdout.trim().split('\n\n');
-        console.log(`Found ${worktrees.length} worktrees`);
-        for (const worktreeInfo of worktrees) {
-            const lines = worktreeInfo.split('\n');
-            const worktreePath = lines[0].replace('worktree ', '');
-            console.log(`Checking worktree path: ${worktreePath}`);
-            // Skip the main repository worktree
-            if (worktreePath === process.cwd()) {
-                console.log(`Skipping main repository: ${worktreePath}`);
-                continue;
-            }
-            // Check if this worktree is in our managed worktrees directory
-            const expectedWorktreePath = path.resolve(process.cwd(), `.bob/worktrees`);
-            if (worktreePath.startsWith(expectedWorktreePath)) {
-                console.log(`Found managed worktree: ${worktreePath}`);
-                // Extract branch name from worktree path and match against SPEC
-                const branchName = path.basename(worktreePath);
-                // Check if this branch/worktree is associated with our SPEC
-                // Look for the feature branch pattern that includes the SPEC
-                if (branchName.includes('feature/') || worktreePath.includes(specId)) {
-                    if (fs.existsSync(worktreePath)) {
-                        console.log(`✅ Found valid worktree for SPEC ${specId}: ${worktreePath}`);
-                        return worktreePath;
-                    }
-                    else {
-                        console.log(`Worktree path registered but does not exist: ${worktreePath}`);
-                    }
-                }
-            }
-        }
-        // FALLBACK 2: try to find worktree by SPEC pattern in our managed directory
-        const expectedPath = path.resolve(process.cwd(), `.bob/worktrees/feature/${specId}`);
-        if (fs.existsSync(expectedPath)) {
-            console.log(`✅ Found worktree by SPEC pattern: ${expectedPath}`);
-            return expectedPath;
-        }
-        console.log('No suitable worktree found for this SPEC');
-        return null;
-    }
-    catch (error) {
-        console.warn('Error finding worktree for SPEC:', error);
-        return null;
-    }
-}
-// Execute git command in a specific directory
-async function execAsyncInDir(command, cwd) {
-    return execAsync(command, { cwd });
-}
-export const AutoGitCommitInput = z.object({
-    spec_id: z.string(),
-    files_changed: z.array(z.string()),
-    task_id: z.string().optional(),
-    action_description: z.string().describe("Brief description of what was implemented"),
-    worktree_path: z.string().optional().describe("Optional worktree directory path to run git commands in")
-});
-export const AutoGitMergeInput = z.object({
-    spec_id: z.string(),
-    target_branch: z.string().default("main"),
-    cleanup_worktree: z.boolean().default(true)
-});
-export const GitStatusOutput = z.object({
-    current_branch: z.string(),
-    is_clean: z.boolean(),
-    staged_files: z.array(z.string()),
-    unstaged_files: z.array(z.string()),
-    untracked_files: z.array(z.string())
-});
-// Generate smart commit message based on SPEC and changes
-export async function generateCommitMessage(input) {
-    const validated = AutoGitCommitInput.parse(input);
-    try {
-        // Get SPEC data for context
-        const spec = await specGetHandler({ spec_id: validated.spec_id });
-        // Analyze files changed to determine type of change
-        const changedFiles = validated.files_changed;
-        const isNewFeature = changedFiles.some(file => file.includes('/components/') ||
-            file.includes('/pages/') ||
-            file.includes('/features/'));
-        const isBackend = changedFiles.some(file => file.includes('/api/') ||
-            file.includes('/server/') ||
-            file.includes('/services/') ||
-            file.includes('/tools/'));
-        const isConfig = changedFiles.some(file => file.includes('package.json') ||
-            file.includes('.json') ||
-            file.includes('.config.') ||
-            file.includes('.env'));
-        const isTest = changedFiles.some(file => file.includes('.test.') ||
-            file.includes('.spec.') ||
-            file.includes('/tests/'));
-        const isDocs = changedFiles.some(file => file.includes('.md') ||
-            file.includes('/docs/'));
-        // Determine commit type
-        let commitType = 'feat';
-        if (validated.action_description.toLowerCase().includes('fix')) {
-            commitType = 'fix';
-        }
-        else if (isTest) {
-            commitType = 'test';
-        }
-        else if (isDocs) {
-            commitType = 'docs';
-        }
-        else if (isConfig) {
-            commitType = 'chore';
-        }
-        else if (validated.action_description.toLowerCase().includes('refactor')) {
-            commitType = 'refactor';
-        }
-        // Extract key features from SPEC title
-        const specTitle = spec.title || 'development work';
-        const featureName = specTitle.toLowerCase()
-            .replace(/[^a-z0-9\s]/g, '')
-            .split(' ')
-            .slice(0, 3)
-            .join(' ');
-        // Create descriptive commit message
-        const scope = isBackend ? 'backend' : isNewFeature ? 'frontend' : undefined;
-        const scopeStr = scope ? `(${scope})` : '';
-        const description = validated.action_description
-            .toLowerCase()
-            .replace(/^(implement|add|create|update|fix)\s*/i, '')
-            .trim();
-        // Build commit message parts
-        const subject = `${commitType}${scopeStr}: ${description}`;
-        // Add body with more details
-        const body = [
-            `- ${validated.action_description}`,
-            validated.task_id ? `- Task: ${validated.task_id}` : null,
-            `- SPEC: ${validated.spec_id}`,
-            changedFiles.length <= 5 ? `- Files: ${changedFiles.join(', ')}` : `- Modified ${changedFiles.length} files`
-        ].filter(Boolean).join('\n');
-        const footer = [
-            '',
-            '🤖 Generated with [Claude Code](https://claude.ai/code)',
-            '',
-            'Co-Authored-By: Claude <noreply@anthropic.com>'
-        ].join('\n');
-        return `${subject}\n\n${body}\n${footer}`;
-    }
-    catch (error) {
-        // Fallback to simple message if SPEC lookup fails
-        return `${validated.action_description}\n\n🤖 Generated with [Claude Code](https://claude.ai/code)\n\nCo-Authored-By: Claude <noreply@anthropic.com>`;
-    }
-}
-// Get current git status
-export async function getGitStatus() {
-    try {
-        // Get current branch
-        const { stdout: branchOutput } = await execAsync('git branch --show-current');
-        const currentBranch = branchOutput.trim();
-        // Get status
-        const { stdout: statusOutput } = await execAsync('git status --porcelain');
-        const statusLines = statusOutput.trim().split('\n').filter(line => line.length > 0);
-        const stagedFiles = [];
-        const unstagedFiles = [];
-        const untrackedFiles = [];
-        for (const line of statusLines) {
-            const status = line.substring(0, 2);
-            const filePath = line.substring(3);
-            if (status[0] !== ' ' && status[0] !== '?') {
-                stagedFiles.push(filePath);
-            }
-            if (status[1] !== ' ' && status[1] !== '?') {
-                unstagedFiles.push(filePath);
-            }
-            if (status === '??') {
-                untrackedFiles.push(filePath);
-            }
-        }
-        return {
-            current_branch: currentBranch,
-            is_clean: statusLines.length === 0,
-            staged_files: stagedFiles,
-            unstaged_files: unstagedFiles,
-            untracked_files: untrackedFiles
-        };
-    }
-    catch (error) {
-        throw new Error(`Failed to get git status: ${error}`);
-    }
-}
-// Auto-commit changes with generated message
-export async function autoCommitChanges(input) {
-    const validated = AutoGitCommitInput.parse(input);
-    try {
-        // Determine working directory (worktree or current directory)
-        const workingDir = validated.worktree_path || process.cwd();
-        console.log(`autoCommitChanges running in: ${workingDir}`);
-        // Get git status in the working directory
-        const { stdout: statusOutput } = await execAsyncInDir('git status --porcelain', workingDir);
-        const hasChanges = statusOutput.trim().length > 0;
-        if (!hasChanges) {
-            // No changes to commit - return early with current HEAD
-            const { stdout: hashOutput } = await execAsyncInDir('git rev-parse HEAD', workingDir);
-            const commitHash = hashOutput.trim().substring(0, 8);
-            console.log('No changes to commit - working tree is clean');
-            return {
-                commit_hash: commitHash,
-                message: 'No changes to commit',
-                files_committed: [],
-                git_output: 'Working tree clean - no commit needed'
-            };
-        }
-        // Stage files if provided
-        if (validated.files_changed.length > 0) {
-            for (const file of validated.files_changed) {
-                try {
-                    await execAsyncInDir(`git add "${file}"`, workingDir);
-                }
-                catch (error) {
-                    console.log(`Warning: Could not stage file ${file}:`, error);
-                }
-            }
-        }
-        else {
-            // Stage all changes if no specific files provided
-            await execAsyncInDir('git add -A', workingDir);
-        }
-        // Check if anything was actually staged after git add operations
-        const { stdout: stagedCheck } = await execAsyncInDir('git diff --cached --name-only', workingDir);
-        const hasStagedFiles = stagedCheck.trim().length > 0;
-        if (!hasStagedFiles) {
-            // Nothing was staged (files already committed or don't exist)
-            const { stdout: hashOutput } = await execAsyncInDir('git rev-parse HEAD', workingDir);
-            const commitHash = hashOutput.trim().substring(0, 8);
-            console.log('No files staged for commit - specified files already committed or do not exist');
-            return {
-                commit_hash: commitHash,
-                message: 'No files staged - already committed',
-                files_committed: [],
-                git_output: 'Nothing to commit - specified files already committed'
-            };
-        }
-        // Generate commit message
-        const commitMessage = await generateCommitMessage(validated);
-        // Write commit message to temporary file to handle multiline messages properly
-        // Heredoc syntax doesn't work with Node.js execAsync
-        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bob-commit-'));
-        const tmpFile = path.join(tmpDir, 'commit-msg.txt');
-        fs.writeFileSync(tmpFile, commitMessage, 'utf8');
-        let stdout;
-        try {
-            // Create commit using -F to read message from file
-            const result = await execAsyncInDir(`git commit -F "${tmpFile}"`, workingDir);
-            stdout = result.stdout;
-        }
-        finally {
-            // Clean up temp file
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-        }
-        // Get commit hash
-        const { stdout: hashOutput } = await execAsyncInDir('git rev-parse HEAD', workingDir);
-        const commitHash = hashOutput.trim().substring(0, 8);
-        // Log the commit in the SPEC
-        await specUpdateHandler({
-            spec_id: validated.spec_id,
-            execution_log: {
-                timestamp: new Date().toISOString(),
-                engineer: "BOB_GIT_AUTOMATION",
-                action: "auto_commit",
-                task_id: validated.task_id || "AUTO-COMMIT",
-                files_changed: validated.files_changed,
-                commit_hash: commitHash,
-                note: `Auto-committed: ${validated.action_description}`
-            }
-        });
-        return {
-            commit_hash: commitHash,
-            message: commitMessage,
-            files_committed: validated.files_changed,
-            git_output: stdout.trim()
-        };
-    }
-    catch (error) {
-        throw new Error(`Failed to auto-commit changes: ${error}`);
-    }
-}
-// Auto-merge worktree to main and cleanup
-export async function autoMergeAndCleanup(input) {
-    const validated = AutoGitMergeInput.parse(input);
-    try {
-        console.log(`🔧 [FIXED VERSION] autoMergeAndCleanup called for SPEC: ${validated.spec_id}`);
-        // Get SPEC for context
-        const spec = await specGetHandler({ spec_id: validated.spec_id });
-        // Get current repository state
-        const gitStatus = await getGitStatus();
-        const currentBranch = gitStatus.current_branch;
-        console.log(`Current branch: ${currentBranch}, target branch: ${validated.target_branch}`);
-        // Find the worktree associated with this SPEC
-        const worktreePath = await findWorktreeForSpec(validated.spec_id);
-        if (worktreePath) {
-            // Traditional worktree workflow
-            console.log(`Found worktree for SPEC ${validated.spec_id} at: ${worktreePath}`);
-            // Get git status from the worktree using -z flag for null-byte separation
-            // This is the best practice for parsing (avoids issues with filenames containing spaces)
-            const { stdout: statusOutput } = await execAsyncInDir('git status --porcelain -z', worktreePath);
-            const { stdout: branchOutput } = await execAsyncInDir('git branch --show-current', worktreePath);
-            const worktreeBranch = branchOutput.trim();
-            // Check for uncommitted changes
-            if (statusOutput.trim()) {
-                console.log(`Worktree has uncommitted changes, analyzing...`);
-                // Parse uncommitted files from git status --porcelain -z format
-                // -z uses null-byte separators instead of newlines, making parsing reliable
-                // Format is: "XY filename\0" where X and Y are status codes (2 chars) + 1 space
-                const uncommittedFiles = statusOutput
-                    .split('\0') // Split on null bytes
-                    .filter(line => line.length > 0) // Remove empty entries
-                    .map(line => {
-                    // First 3 chars are status codes + space (XY ), rest is filename
-                    const fileName = line.substring(3);
-                    // Handle renamed files (contains ->)
-                    const arrowIndex = fileName.indexOf(' -> ');
-                    return arrowIndex > -1 ? fileName.substring(arrowIndex + 4) : fileName;
-                });
-                // Define patterns for files that are safe to ignore (build artifacts, dependencies)
-                const ignorablePatterns = [
-                    /^node_modules\//,
-                    /^dist\//,
-                    /^build\//,
-                    /^\.next\//,
-                    /^out\//,
-                    /^coverage\//,
-                    /^\.cache\//,
-                    /\.log$/,
-                    /\.lock$/,
-                    /^\.env\.local$/
-                ];
-                // Categorize files
-                const importantFiles = uncommittedFiles.filter(file => !ignorablePatterns.some(pattern => pattern.test(file)));
-                if (importantFiles.length > 0) {
-                    // There are important uncommitted changes - fail gracefully
-                    throw new Error(`Worktree has ${importantFiles.length} uncommitted file(s) that need attention:\n` +
-                        importantFiles.slice(0, 5).map(f => `  - ${f}`).join('\n') +
-                        (importantFiles.length > 5 ? `\n  ... and ${importantFiles.length - 5} more` : '') +
-                        `\n\nPlease commit or stash these changes before deploying.`);
-                }
-                // Only ignorable files (node_modules, dist, etc.) - auto-stash them
-                console.log(`Only build artifacts/dependencies changed (${uncommittedFiles.length} files). Auto-stashing...`);
-                try {
-                    await execAsyncInDir('git stash push -u -m "Auto-stash before merge (build artifacts)"', worktreePath);
-                    console.log('✅ Auto-stashed build artifacts');
-                }
-                catch (stashError) {
-                    console.warn('Warning: Could not stash changes, but proceeding anyway:', stashError);
-                    // Don't fail - these are ignorable files
-                }
-            }
-            console.log(`Worktree ready on branch ${worktreeBranch}, proceeding with merge to ${validated.target_branch}`);
-            // Switch to target branch from main repository (not worktree)
-            await execAsync(`git checkout ${validated.target_branch}`);
-            // Check if target branch is clean
-            const targetBranchStatus = await getGitStatus();
-            if (!targetBranchStatus.is_clean) {
-                throw new Error(`Target branch ${validated.target_branch} is not clean. Please clean it before merging.`);
-            }
-            // Pull latest changes in target branch
-            try {
-                await execAsync(`git pull origin ${validated.target_branch}`);
-            }
-            catch (error) {
-                console.log('Warning: Could not pull latest changes:', error);
-            }
-            // Merge the feature branch using temp file (no heredoc)
-            const mergeMessage = `Merge ${worktreeBranch}: ${spec.title}\n\n🤖 Generated with [Claude Code](https://claude.ai/code)\n\nCo-Authored-By: Claude <noreply@anthropic.com>`;
-            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bob-merge-'));
-            const tmpFile = path.join(tmpDir, 'merge-msg.txt');
-            fs.writeFileSync(tmpFile, mergeMessage, 'utf8');
-            try {
-                await execAsync(`git merge ${worktreeBranch} -F "${tmpFile}"`);
-            }
-            finally {
-                fs.rmSync(tmpDir, { recursive: true, force: true });
-            }
-            // Get merge commit hash
-            const { stdout: hashOutput } = await execAsync('git rev-parse HEAD');
-            const mergeCommitHash = hashOutput.trim().substring(0, 8);
-            let cleanupResult = null;
-            // Cleanup worktree if requested
-            if (validated.cleanup_worktree) {
-                try {
-                    // Remove the worktree first
-                    console.log(`Removing worktree: ${worktreePath}`);
-                    await execAsync(`git worktree remove ${worktreePath}`);
-                    // Delete the feature branch
-                    await execAsync(`git branch -d ${worktreeBranch}`);
-                    // Try to remove remote branch if it exists
-                    try {
-                        await execAsync(`git push origin --delete ${worktreeBranch}`);
-                    }
-                    catch (error) {
-                        console.log('Note: Could not delete remote branch (may not exist):', error);
-                    }
-                    cleanupResult = {
-                        worktree_removed: worktreePath,
-                        branch_deleted: worktreeBranch,
-                        remote_cleanup_attempted: true
-                    };
-                }
-                catch (error) {
-                    console.log('Warning: Could not cleanup worktree and branch:', error);
-                    cleanupResult = {
-                        worktree_removed: null,
-                        branch_deleted: null,
-                        cleanup_error: error instanceof Error ? error.message : String(error)
-                    };
-                }
-            }
-            // Log the merge in the SPEC
-            await specUpdateHandler({
-                spec_id: validated.spec_id,
-                execution_log: {
-                    timestamp: new Date().toISOString(),
-                    engineer: "BOB_GIT_AUTOMATION",
-                    action: "auto_merge",
-                    task_id: "MERGE-COMPLETE",
-                    files_changed: [],
-                    commit_hash: mergeCommitHash,
-                    note: `Auto-merged ${worktreeBranch} to ${validated.target_branch} and ${validated.cleanup_worktree ? 'cleaned up worktree' : 'kept worktree'}`
-                }
-            });
-            return {
-                merge_commit_hash: mergeCommitHash,
-                merged_from: worktreeBranch,
-                merged_to: validated.target_branch,
-                cleanup_result: cleanupResult,
-                current_branch: validated.target_branch
-            };
-        }
-        else {
-            // FIXED: Now that we have proper worktree creation, this should not happen
-            throw new Error(`No worktree found for SPEC ${validated.spec_id}. Please ensure the worktree was created properly with workflow.start.`);
-        }
-    }
-    catch (error) {
-        throw new Error(`Failed to auto-merge and cleanup: ${error}`);
-    }
-}
-// Smart git operations for completion workflow
-export async function completeWorkflowGitOperations(spec_id) {
-    try {
-        // Get current git status
-        const gitStatus = await getGitStatus();
-        // Auto-commit any remaining changes
-        if (!gitStatus.is_clean) {
-            const allChangedFiles = [
-                ...gitStatus.staged_files,
-                ...gitStatus.unstaged_files,
-                ...gitStatus.untracked_files
-            ];
-            await autoCommitChanges({
-                spec_id,
-                files_changed: allChangedFiles,
-                action_description: "finalize implementation and prepare for completion"
-            });
-        }
-        // Auto-merge and cleanup
-        const mergeResult = await autoMergeAndCleanup({
-            spec_id,
-            target_branch: "main",
-            cleanup_worktree: true
-        });
-        // Update SPEC with completion status
-        await specUpdateHandler({
-            spec_id,
-            execution_log: {
-                timestamp: new Date().toISOString(),
-                engineer: "BOB_GIT_AUTOMATION",
-                action: "user_satisfied",
-                task_id: "WORKFLOW-COMPLETE",
-                files_changed: [],
-                commit_hash: mergeResult.merge_commit_hash,
-                note: "Workflow completed successfully: merged to main and cleaned up worktree"
-            }
-        });
-        return {
-            workflow_status: "completed",
-            final_commit: mergeResult.merge_commit_hash,
-            merged_to: mergeResult.merged_to,
-            cleanup_successful: !!mergeResult.cleanup_result?.branch_deleted
-        };
-    }
-    catch (error) {
-        throw new Error(`Failed to complete workflow git operations: ${error}`);
-    }
-}
-// ============================================================================
-// NEW MCP TOOLS: Streamlined Worktree-Aware Git Operations
-// ============================================================================
-export const GitCommitInput = z.object({
-    spec_id: z.string().describe("SPEC ID for context and logging"),
-    worktree_path: z.string().optional().describe("Optional worktree path (auto-detected from SPEC if not provided)"),
-    commit_message: z.string().describe("Commit message"),
-    files: z.array(z.string()).optional().describe("Specific files to commit (stages all changes if not provided)")
-});
-export const GitCommitOutput = z.object({
-    commit_hash: z.string(),
-    committed_files: z.array(z.string()),
-    worktree_path: z.string().optional(),
-    message: z.string()
-});
-export const GitMergeInput = z.object({
-    spec_id: z.string().describe("SPEC ID for the worktree to merge"),
-    worktree_branch: z.string().optional().describe("Branch to merge (auto-detected from SPEC if not provided)"),
-    target_branch: z.string().default("main").describe("Target branch to merge into"),
-    cleanup_worktree: z.boolean().default(true).describe("Remove worktree after successful merge")
-});
-export const GitMergeOutput = z.object({
-    merge_commit_hash: z.string(),
-    merged_from: z.string(),
-    merged_to: z.string(),
-    worktree_cleaned: z.boolean(),
-    conflicts: z.array(z.string()).optional()
-});
-/**
- * bob.git.commit - Worktree-aware commit handler
- * Commits changes in the correct worktree context for a SPEC
- */
-export async function gitCommitHandler(input) {
-    const validated = GitCommitInput.parse(input);
-    try {
-        console.log(`bob.git.commit called for SPEC: ${validated.spec_id}`);
-        // Find worktree path if not provided
-        let worktreePath = validated.worktree_path;
-        if (!worktreePath) {
-            worktreePath = await findWorktreeForSpec(validated.spec_id) || undefined;
-        }
-        // Determine working directory (worktree or main repo)
-        const workingDir = worktreePath || process.cwd();
-        console.log(`Committing in: ${workingDir}`);
-        // Get git status in the target directory
-        const { stdout: statusOutput } = await execAsyncInDir('git status --porcelain', workingDir);
-        const hasChanges = statusOutput.trim().length > 0;
-        if (!hasChanges) {
-            const { stdout: hashOutput } = await execAsyncInDir('git rev-parse HEAD', workingDir);
-            const commitHash = hashOutput.trim().substring(0, 8);
-            return {
-                commit_hash: commitHash,
-                committed_files: [],
-                worktree_path: worktreePath,
-                message: 'No changes to commit - working tree clean'
-            };
-        }
-        // Stage files
-        if (validated.files && validated.files.length > 0) {
-            for (const file of validated.files) {
-                await execAsyncInDir(`git add "${file}"`, workingDir);
-            }
-        }
-        else {
-            await execAsyncInDir('git add -A', workingDir);
-        }
-        // Create commit using -F to read message from file (heredoc doesn't work with execAsync)
-        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bob-commit-'));
-        const tmpFile = path.join(tmpDir, 'commit-msg.txt');
-        fs.writeFileSync(tmpFile, validated.commit_message, 'utf8');
-        let commitOutput;
-        try {
-            const result = await execAsyncInDir(`git commit -F "${tmpFile}"`, workingDir);
-            commitOutput = result.stdout;
-        }
-        finally {
-            // Clean up temp file
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-        }
-        // Get commit hash
-        const { stdout: hashOutput } = await execAsyncInDir('git rev-parse HEAD', workingDir);
-        const commitHash = hashOutput.trim().substring(0, 8);
-        // Get list of committed files
-        const { stdout: diffOutput } = await execAsyncInDir(`git diff-tree --no-commit-id --name-only -r ${commitHash}`, workingDir);
-        const committedFiles = diffOutput.trim().split('\n').filter(f => f.length > 0);
-        // Log to SPEC
-        await specUpdateHandler({
-            spec_id: validated.spec_id,
-            execution_log: {
-                timestamp: new Date().toISOString(),
-                engineer: "bob.git.commit",
-                action: "commit",
-                task_id: "GIT-COMMIT",
-                files_changed: committedFiles,
-                commit_hash: commitHash,
-                note: `Committed ${committedFiles.length} files: ${validated.commit_message.split('\n')[0]}`
-            }
-        });
-        return {
-            commit_hash: commitHash,
-            committed_files: committedFiles,
-            worktree_path: worktreePath,
-            message: commitOutput.trim()
-        };
-    }
-    catch (error) {
-        throw new Error(`bob.git.commit failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * bob.git.merge - Worktree → main merge handler
- * Handles the complete merge workflow with conflict detection
- */
-export async function gitMergeHandler(input) {
-    const validated = GitMergeInput.parse(input);
-    try {
-        console.log(`bob.git.merge called for SPEC: ${validated.spec_id}`);
-        // Get SPEC info
-        const spec = await specGetHandler({ spec_id: validated.spec_id });
-        // Determine branch to merge
-        let branchToMerge = validated.worktree_branch;
-        if (!branchToMerge) {
-            // Try to get from SPEC metadata
-            if (spec.worktree && spec.worktree.branch) {
-                branchToMerge = spec.worktree.branch;
-            }
-            else {
-                throw new Error(`Cannot determine branch to merge. Provide worktree_branch or ensure SPEC has worktree metadata.`);
-            }
-        }
-        console.log(`Merging branch: ${branchToMerge} → ${validated.target_branch}`);
-        // Ensure we're on the target branch in main repo
-        const { stdout: currentBranchOutput } = await execAsync('git branch --show-current');
-        const currentBranch = currentBranchOutput.trim();
-        if (currentBranch !== validated.target_branch) {
-            console.log(`Switching from ${currentBranch} to ${validated.target_branch}`);
-            await execAsync(`git checkout ${validated.target_branch}`);
-        }
-        // Pull latest changes
-        try {
-            await execAsync(`git pull origin ${validated.target_branch}`);
-        }
-        catch (pullError) {
-            console.warn(`Could not pull latest ${validated.target_branch}:`, pullError);
-        }
-        // Check for merge conflicts (dry-run)
-        try {
-            await execAsync(`git merge --no-commit --no-ff ${branchToMerge}`);
-            await execAsync('git merge --abort'); // Abort dry-run
-        }
-        catch (dryRunError) {
-            // Check if it's a conflict
-            const { stdout: statusOutput } = await execAsync('git status --porcelain');
-            if (statusOutput.includes('UU ')) {
-                const conflicts = statusOutput.split('\n')
-                    .filter(line => line.startsWith('UU '))
-                    .map(line => line.substring(3));
-                await execAsync('git merge --abort'); // Clean up
-                return {
-                    merge_commit_hash: '',
-                    merged_from: branchToMerge,
-                    merged_to: validated.target_branch,
-                    worktree_cleaned: false,
-                    conflicts
-                };
-            }
-        }
-        // Perform actual merge
-        const { stdout: mergeOutput } = await execAsync(`git merge --no-ff ${branchToMerge} -m "Merge ${branchToMerge} into ${validated.target_branch}"`);
-        // Get merge commit hash
-        const { stdout: hashOutput } = await execAsync('git rev-parse HEAD');
-        const mergeCommitHash = hashOutput.trim().substring(0, 8);
-        // Cleanup worktree if requested
-        let worktreeCleaned = false;
-        if (validated.cleanup_worktree && branchToMerge) {
-            try {
-                const { worktreeRemoveHandler } = await import("./worktreeTools.js");
-                await worktreeRemoveHandler({ worktree_id: branchToMerge, spec_id: validated.spec_id });
-                worktreeCleaned = true;
-            }
-            catch (cleanupError) {
-                console.warn(`Worktree cleanup failed (non-critical):`, cleanupError);
-            }
-        }
-        // Update SPEC
-        await specUpdateHandler({
-            spec_id: validated.spec_id,
-            execution_log: {
-                timestamp: new Date().toISOString(),
-                engineer: "bob.git.merge",
-                action: "merge",
-                task_id: "GIT-MERGE",
-                files_changed: [],
-                commit_hash: mergeCommitHash,
-                note: `Merged ${branchToMerge} → ${validated.target_branch}. Worktree cleanup: ${worktreeCleaned}`
-            },
-            worktree: worktreeCleaned ? {
-                status: "merged",
-                removed_at: new Date().toISOString()
-            } : undefined
-        });
-        return {
-            merge_commit_hash: mergeCommitHash,
-            merged_from: branchToMerge,
-            merged_to: validated.target_branch,
-            worktree_cleaned: worktreeCleaned,
-            conflicts: undefined
-        };
-    }
-    catch (error) {
-        throw new Error(`bob.git.merge failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-//# sourceMappingURL=gitTools.js.map