@codesherlock/codesherlock-beta-mcp-server 0.0.1

package/build/services/gitService.js

@@ -0,0 +1,778 @@
+import { simpleGit } from 'simple-git';
+import { logger } from './loggingService.js';
+/**
+ * Git Service
+ * Handles all Git-related operations like getting diffs, file content, etc.
+ *
+ * NOTE: simple-git StatusResult property mappings:
+ * - not_added:  Untracked files (new files never added to git, shown as ?? in git status)
+ * - created:    Newly staged files (added to index with `git add`, shown as A in git status)
+ * - staged:     Modified files that are staged (shown as M in index)
+ * - modified:   Modified files with unstaged changes (shown as M in working tree)
+ * - deleted:    Deleted files (shown as D)
+ * - renamed:    Renamed files (shown as R)
+ */
+export class GitService {
+    getGitInstance(repoPath) {
+        return simpleGit(repoPath);
+    }
+    /**
+     * Get diff for a specific commit or PR
+     * @param repoPath - Path to the git repository
+     * @param commitHash - Commit hash or PR reference
+     * @returns Git diff content
+     */
+    async getDiff(repoPath, commitHash) {
+        try {
+            const git = this.getGitInstance(repoPath);
+            // If commitHash is empty or "HEAD", get unstaged changes
+            if (!commitHash || commitHash === 'HEAD') {
+                logger.logInfo('Fetching diff for HEAD (unstaged changes)', { repoPath });
+                return await git.diff();
+            }
+            // If commitHash contains '..' it's a range comparison
+            if (commitHash.includes('..')) {
+                logger.logInfo(`Fetching diff for range: ${commitHash}`, { repoPath });
+                return await git.diff([commitHash]);
+            }
+            // Otherwise, get diff for specific commit (comparing with parent)
+            logger.logInfo(`Fetching diff for commit: ${commitHash}`, { repoPath });
+            return await git.show([commitHash]);
+        }
+        catch (error) {
+            logger.logError('Error fetching diff', error, { repoPath, commitHash });
+            throw error;
+        }
+    }
+    /**
+     * Get diff for uncommitted changes (both staged and unstaged)
+     * @param repoPath - Path to the git repository
+     * @returns Git diff content for uncommitted changes
+     */
+    async getUncommittedDiff(repoPath) {
+        try {
+            const git = this.getGitInstance(repoPath);
+            // Get both staged and unstaged diffs
+            const stagedDiff = await git.diff(['--cached']);
+            const unstagedDiff = await git.diff();
+            // Combine both diffs
+            const combinedDiff = [stagedDiff, unstagedDiff]
+                .filter(diff => diff.trim())
+                .join('\n');
+            return combinedDiff;
+        }
+        catch (error) {
+            logger.logError('Error fetching uncommitted diff', error, { repoPath });
+            throw error;
+        }
+    }
+    /**
+     * Get file content from repository
+     * @param repoPath - Path to the git repository
+     * @param filePath - Path to the file within the repo
+     * @param ref - Git reference (branch, tag, commit hash)
+     * @returns File content as string
+     */
+    async getFileContent(repoPath, filePath, ref) {
+        try {
+            const git = this.getGitInstance(repoPath);
+            // If no ref is provided, get current working tree version
+            if (!ref) {
+                const { readFileSync, existsSync } = await import('fs');
+                const { join } = await import('path');
+                const fullPath = join(repoPath, filePath);
+                logger.logInfo('Reading file from working tree', {
+                    filePath,
+                    fullPath,
+                    exists: String(existsSync(fullPath))
+                });
+                if (!existsSync(fullPath)) {
+                    logger.logWarning('File does not exist in working tree', {
+                        filePath,
+                        fullPath
+                    });
+                    throw new Error(`File does not exist: ${fullPath}`);
+                }
+                const content = readFileSync(fullPath, 'utf-8');
+                logger.logInfo('File read from working tree', {
+                    filePath,
+                    contentLength: String(content.length),
+                    lineCount: String(content.split('\n').length)
+                });
+                return content;
+            }
+            // Get file content from specific commit/branch/tag
+            logger.logInfo('Reading file from git commit', {
+                filePath,
+                ref,
+                gitCommand: `${ref}:${filePath}`
+            });
+            const content = await git.show([`${ref}:${filePath}`]);
+            logger.logInfo('File read from git commit', {
+                filePath,
+                ref,
+                contentLength: String(content.length),
+                lineCount: String(content.split('\n').length)
+            });
+            return content;
+        }
+        catch (error) {
+            logger.logError('Error fetching file content', error, {
+                repoPath,
+                filePath,
+                ref: ref || 'working tree',
+                errorMessage: String(error)
+            });
+            throw error;
+        }
+    }
+    /**
+     * Get list of changed files in a commit or PR
+     * @param repoPath - Path to the git repository
+     * @param commitHash - Commit hash or PR reference
+     * @returns Array of changed file paths
+     */
+    async getChangedFiles(repoPath, commitHash) {
+        try {
+            const git = this.getGitInstance(repoPath);
+            // If commitHash is empty, get unstaged and staged files
+            if (!commitHash) {
+                const status = await git.status();
+                // Collect all changed files from different categories:
+                // - modified: files with unstaged modifications
+                // - created: newly staged files (added to index)
+                // - not_added: untracked files (simple-git's name for untracked)
+                // - deleted: deleted files
+                // - renamed: renamed files (use the new path)
+                return [
+                    ...status.modified,
+                    ...status.created,
+                    ...status.not_added,
+                    ...status.deleted,
+                    ...status.renamed.map(r => r.to)
+                ];
+            }
+            // Get files changed in specific commit
+            const diffSummary = await git.diffSummary([`${commitHash}^`, commitHash]);
+            return diffSummary.files.map(file => file.file);
+        }
+        catch (error) {
+            logger.logError('Error fetching changed files', error, { repoPath, commitHash });
+            throw error;
+        }
+    }
+    /**
+     * Get commit information
+     * @param repoPath - Path to the git repository
+     * @param commitHash - Commit hash
+     * @returns Commit metadata
+     */
+    async getCommitInfo(repoPath, commitHash) {
+        try {
+            const git = this.getGitInstance(repoPath);
+            // Get commit log
+            const log = await git.log([commitHash, '-1']);
+            if (!log.latest) {
+                throw new Error(`Commit ${commitHash} not found`);
+            }
+            const commit = log.latest;
+            // Get changed files for this commit
+            const changedFiles = await this.getChangedFiles(repoPath, commitHash);
+            return {
+                hash: commit.hash,
+                author: commit.author_name,
+                email: commit.author_email,
+                date: commit.date,
+                message: commit.message,
+                files: changedFiles
+            };
+        }
+        catch (error) {
+            logger.logError('Error fetching commit info', error, { repoPath, commitHash });
+            throw error;
+        }
+    }
+    /**
+     * Get repository status
+     * @param repoPath - Path to the git repository
+     * @returns Repository status information
+     *
+     * NOTE: simple-git uses these property names:
+     * - not_added = untracked files (files not in git)
+     * - created = newly staged files (git add on new file)
+     * - staged = modified files that are staged
+     */
+    async getRepoStatus(repoPath) {
+        try {
+            const git = this.getGitInstance(repoPath);
+            const status = await git.status();
+            return {
+                branch: status.current || 'HEAD',
+                modified: status.modified,
+                // Staged files include both newly created (added) and modified-then-staged
+                staged: [
+                    ...status.created,
+                    ...status.staged
+                ],
+                // Untracked files - simple-git calls these "not_added"
+                untracked: status.not_added
+            };
+        }
+        catch (error) {
+            logger.logError('Error fetching repo status', error, { repoPath });
+            throw error;
+        }
+    }
+    /**
+     * Get the hash of the current HEAD commit.
+     * Falls back to a placeholder when repository has no commits.
+     */
+    async getCurrentCommitHash(repoPath) {
+        try {
+            const git = this.getGitInstance(repoPath);
+            const hash = await git.revparse(["HEAD"]);
+            return hash.trim();
+        }
+        catch (error) {
+            // For repositories with no commits or when HEAD is unavailable
+            logger.logWarning("Unable to resolve current commit hash; using placeholder", {
+                repoPath,
+                error: String(error),
+            });
+            return "UNCOMMITTED";
+        }
+    }
+    /**
+     * Get diff for a specific file
+     * @param repoPath - Path to the git repository
+     * @param filePath - Path to the file
+     * @param commitHash - Commit hash (optional, if null/empty uses HEAD)
+     * @param fileStatus - Optional file status (untracked/added/modified/deleted) to optimize diff retrieval
+     * @returns Diff content
+     */
+    async getFileDiff(repoPath, filePath, commitHash, fileStatus) {
+        try {
+            const git = this.getGitInstance(repoPath);
+            // UNCOMMITTED changes
+            if (!commitHash) {
+                // Optimize: If file is untracked or added, skip git diff attempts and generate synthetic patch directly
+                if (fileStatus === 'untracked' || fileStatus === 'added') {
+                    logger.logInfo(`Generating synthetic patch for ${fileStatus} file`, {
+                        filePath,
+                        repoPath,
+                        status: fileStatus
+                    });
+                    const syntheticPatch = await this.buildUntrackedPatch(repoPath, filePath);
+                    logger.logInfo('Synthetic patch generated', {
+                        filePath,
+                        patchLength: String(syntheticPatch.length)
+                    });
+                    return syntheticPatch;
+                }
+                logger.logInfo('Getting diff for uncommitted file', {
+                    filePath,
+                    repoPath,
+                    step: 'checking staged diff first'
+                });
+                // 1. Try staged diff first (--cached)
+                try {
+                    const staged = await git.diff(['--cached', '--', filePath]);
+                    if (staged.trim()) {
+                        logger.logInfo('Found staged diff', {
+                            filePath,
+                            diffLength: String(staged.length)
+                        });
+                        return staged;
+                    }
+                    else {
+                        logger.logInfo('Staged diff is empty', { filePath });
+                    }
+                }
+                catch (e) {
+                    // Staged diff failed, continue to unstaged
+                    logger.logInfo(`Staged diff failed for ${filePath}, trying unstaged`, {
+                        error: String(e),
+                        filePath
+                    });
+                }
+                // 2. Try unstaged diff
+                logger.logInfo('Trying unstaged diff', { filePath });
+                try {
+                    const unstaged = await git.diff(['--', filePath]);
+                    if (unstaged.trim()) {
+                        logger.logInfo('Found unstaged diff', {
+                            filePath,
+                            diffLength: String(unstaged.length)
+                        });
+                        return unstaged;
+                    }
+                    else {
+                        logger.logInfo('Unstaged diff is empty', { filePath });
+                    }
+                }
+                catch (e) {
+                    // Unstaged diff failed, continue to check if untracked
+                    logger.logInfo(`Unstaged diff failed for ${filePath}, checking if untracked`, {
+                        error: String(e),
+                        filePath
+                    });
+                }
+                // 3. UNTRACKED FILE (NO DIFF EXISTS)
+                // Git diff does NOT show untracked files by default
+                // We must generate a synthetic patch
+                logger.logInfo(`No diff found for ${filePath}, generating synthetic patch for untracked/added file`, {
+                    filePath,
+                    repoPath
+                });
+                const syntheticPatch = await this.buildUntrackedPatch(repoPath, filePath);
+                logger.logInfo('Synthetic patch generated', {
+                    filePath,
+                    patchLength: String(syntheticPatch.length)
+                });
+                return syntheticPatch;
+            }
+            // Diff for specific commit
+            logger.logInfo('Getting diff for committed file', {
+                filePath,
+                commitHash,
+                gitCommand: `${commitHash}^..${commitHash}`
+            });
+            const diff = await git.diff([`${commitHash}^..${commitHash}`, '--', filePath]);
+            logger.logInfo('Committed file diff retrieved', {
+                filePath,
+                commitHash,
+                diffLength: String(diff.length)
+            });
+            return diff;
+        }
+        catch (error) {
+            logger.logError('Error fetching file diff', error, {
+                repoPath,
+                filePath,
+                commitHash: commitHash || 'working tree',
+                errorMessage: String(error)
+            });
+            throw error;
+        }
+    }
+    /**
+     * Build a synthetic git patch for untracked files
+     * Git does NOT diff untracked files, so we must create the patch ourselves
+     * @param repoPath - Path to the git repository
+     * @param filePath - Path to the untracked file
+     * @returns Synthetic git diff patch
+     */
+    async buildUntrackedPatch(repoPath, filePath) {
+        try {
+            logger.logInfo('Building synthetic patch for untracked/added file', {
+                filePath,
+                repoPath
+            });
+            const { readFileSync, existsSync } = await import('fs');
+            const { join } = await import('path');
+            const fullPath = join(repoPath, filePath);
+            logger.logInfo('Checking file existence for patch', {
+                filePath,
+                fullPath,
+                exists: String(existsSync(fullPath))
+            });
+            // Check if file exists
+            if (!existsSync(fullPath)) {
+                logger.logWarning(`File does not exist for untracked patch: ${filePath}`, {
+                    filePath,
+                    fullPath
+                });
+                return '';
+            }
+            logger.logInfo('Reading file content for synthetic patch', {
+                filePath,
+                fullPath
+            });
+            const content = readFileSync(fullPath, 'utf-8');
+            const lines = content.split('\n');
+            const lineCount = lines.length;
+            logger.logInfo('File content read for patch generation', {
+                filePath,
+                contentLength: String(content.length),
+                lineCount: String(lineCount)
+            });
+            // Generate proper git diff format for new file
+            const patchLines = [
+                `diff --git a/${filePath} b/${filePath}`,
+                `new file mode 100644`,
+                `index 0000000..e69de29`,
+                `--- /dev/null`,
+                `+++ b/${filePath}`,
+            ];
+            if (lineCount > 0) {
+                // Add hunk header
+                patchLines.push(`@@ -0,0 +1,${lineCount} @@`);
+                // Add lines with + prefix
+                for (const line of lines) {
+                    patchLines.push(`+${line}`);
+                }
+            }
+            else {
+                // Empty file
+                patchLines.push(`@@ -0,0 +1,0 @@`);
+            }
+            return patchLines.join('\n');
+        }
+        catch (error) {
+            logger.logError('Error building untracked patch', error, { repoPath, filePath });
+            // Return empty string on error rather than throwing
+            // This allows the pipeline to continue with other files
+            return '';
+        }
+    }
+    /**
+     * Get changed files with status
+     * @param repoPath - Path to the git repository
+     * @param commitHash - Commit hash (optional)
+     * @returns Array of objects with path and status
+     *
+     * NOTE: simple-git file status codes:
+     * - file.index: status in the staging area (index)
+     * - file.working_dir: status in the working directory
+     * - '?' = untracked
+     * - 'A' = added (staged new file)
+     * - 'M' = modified
+     * - 'D' = deleted
+     * - 'R' = renamed
+     * - ' ' = unmodified
+     */
+    async getChangedFilesWithStatus(repoPath, commitHash) {
+        try {
+            const git = this.getGitInstance(repoPath);
+            if (!commitHash) {
+                // Get status including untracked files
+                logger.logInfo('Getting git status for uncommitted changes', { repoPath });
+                const status = await git.status();
+                // Log raw status information
+                logger.logInfo('Git status retrieved', {
+                    repoPath,
+                    totalFiles: String(status.files?.length || 0),
+                    modifiedCount: String(status.modified?.length || 0),
+                    createdCount: String(status.created?.length || 0),
+                    notAddedCount: String(status.not_added?.length || 0),
+                    deletedCount: String(status.deleted?.length || 0),
+                    renamedCount: String(status.renamed?.length || 0),
+                    stagedCount: String(status.staged?.length || 0)
+                });
+                // Ensure we have files array
+                if (!status.files || status.files.length === 0) {
+                    logger.logInfo('No changed files found in repository status', { repoPath });
+                    return [];
+                }
+                // Log all files with their raw status codes
+                logger.logInfo('Raw git status files', {
+                    files: JSON.stringify(status.files.map(f => ({
+                        path: f.path,
+                        index: f.index,
+                        working_dir: f.working_dir
+                    })))
+                });
+                const filesWithStatus = status.files.map(file => {
+                    if (!file.path) {
+                        logger.logWarning('File entry missing path in status', { file: JSON.stringify(file) });
+                        return null;
+                    }
+                    // Determine file status based on simple-git's index and working_dir codes
+                    const fileStatus = this.determineFileStatus(file.index, file.working_dir);
+                    logger.logInfo('File status determined', {
+                        path: file.path,
+                        indexCode: file.index,
+                        workingDirCode: file.working_dir,
+                        determinedStatus: fileStatus
+                    });
+                    return {
+                        path: file.path,
+                        status: fileStatus
+                    };
+                }).filter((file) => file !== null);
+                // Log summary of files by status
+                const filesByStatus = filesWithStatus.reduce((acc, file) => {
+                    acc[file.status] = (acc[file.status] || 0) + 1;
+                    return acc;
+                }, {});
+                logger.logInfo('Files grouped by status', {
+                    repoPath,
+                    filesByStatus: JSON.stringify(filesByStatus),
+                    totalFiles: String(filesWithStatus.length),
+                    fileList: JSON.stringify(filesWithStatus.map(f => `${f.path} (${f.status})`))
+                });
+                return filesWithStatus;
+            }
+            // Get files changed in specific commit with status
+            const result = await git.raw(['show', '--name-status', '--format=', commitHash]);
+            return result.trim().split('\n').filter(Boolean).map(line => {
+                const parts = line.split('\t');
+                const code = parts[0][0];
+                let path = parts[1];
+                let statusStr = 'modified';
+                if (code === 'A')
+                    statusStr = 'added';
+                else if (code === 'D')
+                    statusStr = 'deleted';
+                else if (code === 'R') {
+                    statusStr = 'renamed';
+                    path = parts[2] || parts[1];
+                }
+                return { status: statusStr, path };
+            });
+        }
+        catch (error) {
+            logger.logError('Error fetching changed files with status', error, { repoPath, commitHash: commitHash || 'HEAD' });
+            throw error;
+        }
+    }
+    /**
+     * Determine file status from simple-git's index and working_dir codes
+     * @param indexCode - Status code in the staging area
+     * @param workingDirCode - Status code in the working directory
+     * @returns Human-readable status string
+     */
+    determineFileStatus(indexCode, workingDirCode) {
+        // Untracked files have '?' in both index and working_dir
+        if (indexCode === '?' && workingDirCode === '?') {
+            return 'untracked';
+        }
+        // Added files (staged new files) have 'A' in index
+        if (indexCode === 'A') {
+            return 'added';
+        }
+        // Deleted files have 'D' in either index or working_dir
+        if (indexCode === 'D' || workingDirCode === 'D') {
+            return 'deleted';
+        }
+        // Renamed files have 'R' in either index or working_dir
+        if (indexCode === 'R' || workingDirCode === 'R') {
+            return 'renamed';
+        }
+        // Default to 'modified' for other cases (M = Modified)
+        return 'modified';
+    }
+    /**
+     * Analyze git changes for a commit or uncommitted changes
+     * @param uncommitted - If true, analyze uncommitted changes. If false, analyze HEAD.
+     * @param directory - Path to git repository
+     */
+    async analyzeGitChanges(uncommitted, directory) {
+        try {
+            logger.logInfo(`Analyzing git changes`, {
+                directory,
+                uncommitted: String(uncommitted),
+                targetHash: uncommitted ? 'working tree' : 'HEAD'
+            });
+            const targetHash = uncommitted ? undefined : 'HEAD';
+            const changes = await this.getChangedFilesWithStatus(directory, targetHash);
+            logger.logInfo(`Found ${changes.length} changed files`, {
+                directory,
+                uncommitted: String(uncommitted),
+                files: JSON.stringify(changes.map(c => `${c.path} (${c.status})`))
+            });
+            const results = [];
+            for (const change of changes) {
+                logger.logInfo(`Processing file in analyzeGitChanges`, {
+                    filename: change.path,
+                    status: change.status,
+                    isAdded: String(change.status === 'added'),
+                    targetHash: targetHash || 'working tree'
+                });
+                let new_content = '';
+                if (change.status !== 'deleted') {
+                    try {
+                        logger.logInfo(`Getting content for file`, {
+                            filename: change.path,
+                            status: change.status,
+                            source: targetHash ? `commit ${targetHash}` : 'working tree'
+                        });
+                        new_content = await this.getFileContent(directory, change.path, targetHash);
+                        logger.logInfo(`Content retrieved successfully`, {
+                            filename: change.path,
+                            status: change.status,
+                            contentLength: String(new_content.length)
+                        });
+                    }
+                    catch (error) {
+                        logger.logWarning(`Failed to read content for ${change.path}`, {
+                            error: String(error),
+                            status: change.status,
+                            filename: change.path
+                        });
+                    }
+                }
+                else {
+                    logger.logInfo(`Skipping content for deleted file`, {
+                        filename: change.path
+                    });
+                }
+                let patch = '';
+                try {
+                    logger.logInfo(`Getting diff for file`, {
+                        filename: change.path,
+                        status: change.status,
+                        targetHash: targetHash || 'working tree'
+                    });
+                    patch = await this.getFileDiff(directory, change.path, targetHash, change.status);
+                    logger.logInfo(`Diff retrieved successfully`, {
+                        filename: change.path,
+                        status: change.status,
+                        patchLength: String(patch.length)
+                    });
+                }
+                catch (error) {
+                    logger.logWarning(`Failed to get diff for ${change.path}`, {
+                        error: String(error),
+                        status: change.status,
+                        filename: change.path
+                    });
+                }
+                const result = {
+                    filename: change.path,
+                    status: change.status,
+                    new_content,
+                    patch
+                };
+                logger.logInfo(`File processing complete`, {
+                    filename: change.path,
+                    status: change.status,
+                    hasContent: String(new_content.length > 0),
+                    hasPatch: String(patch.length > 0),
+                    contentLength: String(new_content.length),
+                    patchLength: String(patch.length)
+                });
+                results.push(result);
+            }
+            logger.logInfo(`Git changes analysis complete`, {
+                directory,
+                totalFiles: String(results.length),
+                filesProcessed: JSON.stringify(results.map(r => ({
+                    filename: r.filename,
+                    status: r.status,
+                    hasContent: r.new_content.length > 0,
+                    hasPatch: r.patch.length > 0
+                })))
+            });
+            return results;
+        }
+        catch (error) {
+            logger.logError('Error analyzing git changes', error, { directory });
+            throw error;
+        }
+    }
+    /**
+     * Get file changes for a commit or uncommitted changes
+     * @param uncommitted - true for unstaged changes, false for specific commit
+     * @param commitHash - Git commit hash (required when uncommitted=false)
+     * @param directory - Path to the Git repository root
+     * @returns Array of file changes with filename, status, new_content, and patch
+     */
+    async getFileChanges(uncommitted, commitHash, directory) {
+        try {
+            // Validate parameters
+            if (!uncommitted && !commitHash) {
+                throw new Error("commitHash is required when uncommitted is false");
+            }
+            logger.logInfo(`Getting file changes`, {
+                directory,
+                uncommitted: String(uncommitted),
+                commitHash: commitHash || 'none'
+            });
+            // Determine the target commit/ref
+            const targetHash = uncommitted ? undefined : commitHash;
+            // Get changed files with status
+            const changes = await this.getChangedFilesWithStatus(directory, targetHash);
+            logger.logInfo(`Found ${changes.length} changed files`);
+            const results = [];
+            for (const change of changes) {
+                logger.logInfo('Processing file change', {
+                    filename: change.path,
+                    status: change.status,
+                    targetHash: targetHash || 'working tree',
+                    isAdded: String(change.status === 'added')
+                });
+                let new_content = '';
+                // Get new content for non-deleted files
+                if (change.status !== 'deleted') {
+                    try {
+                        logger.logInfo('Getting file content', {
+                            filename: change.path,
+                            status: change.status,
+                            source: targetHash ? `commit ${targetHash}` : 'working tree',
+                            isAdded: String(change.status === 'added')
+                        });
+                        new_content = await this.getFileContent(directory, change.path, targetHash);
+                        logger.logInfo('File content retrieved', {
+                            filename: change.path,
+                            status: change.status,
+                            contentLength: String(new_content.length),
+                            lineCount: String(new_content.split('\n').length)
+                        });
+                    }
+                    catch (error) {
+                        logger.logWarning(`Failed to read content for ${change.path}`, {
+                            error: String(error),
+                            status: change.status,
+                            targetHash: targetHash || 'working tree'
+                        });
+                    }
+                }
+                else {
+                    logger.logInfo('Skipping content retrieval for deleted file', {
+                        filename: change.path
+                    });
+                }
+                // Get diff/patch for the file
+                let patch = '';
+                try {
+                    logger.logInfo('Getting file diff', {
+                        filename: change.path,
+                        status: change.status,
+                        targetHash: targetHash || 'working tree',
+                        isAdded: String(change.status === 'added')
+                    });
+                    patch = await this.getFileDiff(directory, change.path, targetHash, change.status);
+                    logger.logInfo('File diff retrieved', {
+                        filename: change.path,
+                        status: change.status,
+                        patchLength: String(patch.length),
+                        hasPatch: String(patch.length > 0)
+                    });
+                }
+                catch (error) {
+                    logger.logWarning(`Failed to get diff for ${change.path}`, {
+                        error: String(error),
+                        status: change.status,
+                        targetHash: targetHash || 'working tree'
+                    });
+                }
+                results.push({
+                    filename: change.path,
+                    status: change.status,
+                    new_content,
+                    patch
+                });
+                logger.logInfo('File change processed', {
+                    filename: change.path,
+                    status: change.status,
+                    hasContent: String(new_content.length > 0),
+                    hasPatch: String(patch.length > 0),
+                    contentLength: String(new_content.length),
+                    patchLength: String(patch.length)
+                });
+            }
+            logger.logInfo(`Successfully processed ${results.length} file changes`);
+            return results;
+        }
+        catch (error) {
+            logger.logError('Error in getFileChanges', error, {
+                directory,
+                uncommitted: String(uncommitted),
+                commitHash: commitHash || 'none'
+            });
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=gitService.js.map