@nanocollective/nanocoder 1.20.4 → 1.22.0

package/dist/tools/git/utils.js

@@ -1,10 +1,40 @@
 /**
- * Git Workflow Utilities
+ * Git Utilities
  *
  * Shared utilities for git operations including command execution,
- * diff parsing, and analysis functions.
+ * status parsing, and availability checks.
  */
-import { spawn } from 'node:child_process';
+import { execSync, spawn } from 'node:child_process';
+// ============================================================================
+// Availability Checks (Synchronous - for conditional tool registration)
+// ============================================================================
+/**
+ * Check if git is available on the system (synchronous)
+ */
+export function isGitAvailable() {
+    try {
+        execSync('git --version', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if gh CLI is available on the system (synchronous)
+ */
+export function isGhAvailable() {
+    try {
+        execSync('gh --version', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ============================================================================
+// Git Command Execution
+// ============================================================================
 /**
  * Execute a git command and return the output
  */
@@ -21,13 +51,9 @@ export async function execGit(args) {
         });
         proc.on('close', (code) => {
             if (code === 0) {
-                // Use trimEnd() instead of trim() to preserve leading whitespace
-                // which is significant in porcelain output (e.g., " M" vs "M ")
                 resolve(stdout.trimEnd());
             }
             else {
-                // Non-zero exit code indicates an error
-                // Include stderr in error message for context
                 const errorMessage = stderr.trim() || `Git command failed with exit code ${code}`;
                 reject(new Error(errorMessage));
             }
@@ -38,29 +64,109 @@ export async function execGit(args) {
     });
 }
 /**
- * Check if current directory is a git repository
+ * Execute a gh CLI command and return the output
+ */
+export async function execGh(args) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn('gh', args);
+        let stdout = '';
+        let stderr = '';
+        proc.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        proc.on('close', (code) => {
+            if (code === 0) {
+                resolve(stdout.trimEnd());
+            }
+            else {
+                const errorMessage = stderr.trim() || `gh command failed with exit code ${code}`;
+                reject(new Error(errorMessage));
+            }
+        });
+        proc.on('error', error => {
+            reject(new Error(`Failed to execute gh: ${error.message}`));
+        });
+    });
+}
+// ============================================================================
+// Repository State Checks
+// ============================================================================
+/**
+ * Check if there are uncommitted changes (staged or unstaged)
+ */
+export async function hasUncommittedChanges() {
+    try {
+        const status = await execGit(['status', '--porcelain']);
+        return status.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if there are staged changes
+ */
+export async function hasStagedChanges() {
+    try {
+        const diff = await execGit(['diff', '--cached', '--name-only']);
+        return diff.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a rebase is in progress
+ */
+export async function isRebaseInProgress() {
+    try {
+        await execGit(['rev-parse', '--git-path', 'rebase-merge']);
+        const result = await execGit([
+            'rev-parse',
+            '--verify',
+            '--quiet',
+            'REBASE_HEAD',
+        ]);
+        return result !== '';
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a merge is in progress
  */
-export async function isGitRepository() {
+export async function isMergeInProgress() {
     try {
-        await execGit(['rev-parse', '--is-inside-work-tree']);
+        await execGit(['rev-parse', '--verify', '--quiet', 'MERGE_HEAD']);
         return true;
     }
     catch {
         return false;
     }
 }
+// ============================================================================
+// Branch Operations
+// ============================================================================
 /**
  * Get the current branch name
  */
 export async function getCurrentBranch() {
-    return execGit(['rev-parse', '--abbrev-ref', 'HEAD']);
+    try {
+        return await execGit(['rev-parse', '--abbrev-ref', 'HEAD']);
+    }
+    catch {
+        return 'HEAD'; // Detached HEAD state
+    }
 }
 /**
  * Get the default branch (main or master)
  */
 export async function getDefaultBranch() {
     try {
-        // Try to get from remote origin
         const remoteBranch = await execGit([
             'symbolic-ref',
             'refs/remotes/origin/HEAD',
@@ -80,57 +186,197 @@ export async function getDefaultBranch() {
                 return 'master';
             }
             catch {
-                return 'main'; // Default to main
+                return 'main';
             }
         }
     }
 }
 /**
- * Parse git diff --stat output to extract file changes
+ * Check if a branch exists
  */
-export function parseDiffStat(diffStat) {
-    const files = [];
-    const lines = diffStat.split('\n').filter(line => line.trim());
-    for (const line of lines) {
-        // Skip summary line (e.g., "3 files changed, 10 insertions(+), 5 deletions(-)")
-        if (line.includes('files changed') || line.includes('file changed')) {
-            continue;
-        }
-        // Parse line format: " path/to/file.ts | 10 ++++---"
-        const match = line.match(/^\s*(.+?)\s+\|\s+(\d+|Bin)/);
-        if (match) {
-            const path = match[1].trim();
-            const isBinary = match[2] === 'Bin';
-            // Count + and - signs for additions/deletions
-            const changesMatch = line.match(/\|.*?(\d+)?\s*([+-]+)?/);
-            let additions = 0;
-            let deletions = 0;
-            if (changesMatch && changesMatch[2]) {
-                additions = (changesMatch[2].match(/\+/g) || []).length;
-                deletions = (changesMatch[2].match(/-/g) || []).length;
-            }
-            // Detect renames (format: old => new)
-            const renameMatch = path.match(/(.+)\s*=>\s*(.+)/);
-            let finalPath = path;
-            let oldPath;
-            let status = 'modified';
-            if (renameMatch) {
-                // Handle various rename formats
-                oldPath = renameMatch[1].trim();
-                finalPath = renameMatch[2].trim();
-                status = 'renamed';
+export async function branchExists(name) {
+    try {
+        await execGit(['rev-parse', '--verify', `refs/heads/${name}`]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the upstream branch for the current branch
+ */
+export async function getUpstreamBranch() {
+    try {
+        return await execGit(['rev-parse', '--abbrev-ref', '@{upstream}']);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get ahead/behind counts relative to upstream
+ */
+export async function getAheadBehind() {
+    try {
+        const upstream = await getUpstreamBranch();
+        if (!upstream)
+            return { ahead: 0, behind: 0 };
+        const result = await execGit([
+            'rev-list',
+            '--left-right',
+            '--count',
+            `${upstream}...HEAD`,
+        ]);
+        const [behind, ahead] = result.split('\t').map(n => parseInt(n, 10) || 0);
+        return { ahead, behind };
+    }
+    catch {
+        return { ahead: 0, behind: 0 };
+    }
+}
+/**
+ * Get list of local branches
+ */
+export async function getLocalBranches() {
+    try {
+        const output = await execGit([
+            'branch',
+            '--format=%(refname:short)|%(upstream:short)|%(upstream:track,nobracket)|%(HEAD)',
+        ]);
+        return output
+            .split('\n')
+            .filter(line => line.trim())
+            .map(line => {
+            const [name, upstream, track, head] = line.split('|');
+            let ahead = 0;
+            let behind = 0;
+            if (track) {
+                const aheadMatch = track.match(/ahead (\d+)/);
+                const behindMatch = track.match(/behind (\d+)/);
+                if (aheadMatch)
+                    ahead = parseInt(aheadMatch[1], 10);
+                if (behindMatch)
+                    behind = parseInt(behindMatch[1], 10);
             }
-            files.push({
-                path: finalPath,
-                status,
-                oldPath,
-                additions,
-                deletions,
-                isBinary,
-            });
-        }
+            return {
+                name: name || '',
+                current: head === '*',
+                upstream: upstream || undefined,
+                ahead,
+                behind,
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get list of remote branches
+ */
+export async function getRemoteBranches() {
+    try {
+        const output = await execGit(['branch', '-r', '--format=%(refname:short)']);
+        return output
+            .split('\n')
+            .filter(line => line.trim() && !line.includes('HEAD'));
+    }
+    catch {
+        return [];
+    }
+}
+// ============================================================================
+// Commit Operations
+// ============================================================================
+/**
+ * Get unpushed commits (commits ahead of upstream)
+ */
+export async function getUnpushedCommits() {
+    try {
+        const upstream = await getUpstreamBranch();
+        if (!upstream)
+            return [];
+        return await getCommits({ range: `${upstream}..HEAD` });
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Check if the last commit has been pushed
+ */
+export async function isLastCommitPushed() {
+    try {
+        const upstream = await getUpstreamBranch();
+        if (!upstream)
+            return false;
+        const { ahead } = await getAheadBehind();
+        return ahead === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get commits with various filters
+ */
+export async function getCommits(options) {
+    try {
+        const args = ['log', '--format=%H|%h|%an|%ae|%ad|%ar|%s', '--date=short'];
+        if (options.count)
+            args.push(`-n`, options.count.toString());
+        if (options.range)
+            args.push(options.range);
+        if (options.author)
+            args.push(`--author=${options.author}`);
+        if (options.since)
+            args.push(`--since=${options.since}`);
+        if (options.grep)
+            args.push(`--grep=${options.grep}`);
+        if (options.file)
+            args.push('--', options.file);
+        const output = await execGit(args);
+        if (!output.trim())
+            return [];
+        return output.split('\n').map(line => {
+            const [hash, shortHash, author, email, date, relativeDate, subject] = line.split('|');
+            return {
+                hash: hash || '',
+                shortHash: shortHash || '',
+                author: author || '',
+                email: email || '',
+                date: date || '',
+                relativeDate: relativeDate || '',
+                subject: subject || '',
+                body: '',
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+// ============================================================================
+// Status Parsing
+// ============================================================================
+/**
+ * Map git status character to FileChangeStatus
+ */
+function mapStatusChar(char) {
+    switch (char) {
+        case 'A':
+            return 'added';
+        case 'D':
+            return 'deleted';
+        case 'R':
+            return 'renamed';
+        case 'C':
+            return 'copied';
+        case 'M':
+        default:
+            return 'modified';
     }
-    return files;
 }
 /**
  * Parse git status --porcelain output
@@ -140,15 +386,18 @@ export function parseGitStatus(statusOutput) {
     const unstaged = [];
     const untracked = [];
     const conflicts = [];
-    const lines = statusOutput.split('\n').filter(line => line.trim());
+    const lines = statusOutput.split('\n').filter(line => line);
     for (const line of lines) {
         if (line.length < 3)
             continue;
         const indexStatus = line[0];
         const workTreeStatus = line[1];
-        const path = line.slice(3).trim();
-        // Detect conflicts (both modified)
-        if (indexStatus === 'U' || workTreeStatus === 'U') {
+        const path = line.slice(3);
+        // Detect conflicts
+        if (indexStatus === 'U' ||
+            workTreeStatus === 'U' ||
+            (indexStatus === 'A' && workTreeStatus === 'A') ||
+            (indexStatus === 'D' && workTreeStatus === 'D')) {
             conflicts.push(path);
             continue;
         }
@@ -157,7 +406,7 @@ export function parseGitStatus(statusOutput) {
             untracked.push(path);
             continue;
         }
-        // Staged changes (index status)
+        // Staged changes
         if (indexStatus !== ' ' && indexStatus !== '?') {
             staged.push({
                 path,
@@ -167,7 +416,7 @@ export function parseGitStatus(statusOutput) {
                 isBinary: false,
             });
         }
-        // Unstaged changes (work tree status)
+        // Unstaged changes
         if (workTreeStatus !== ' ' && workTreeStatus !== '?') {
             unstaged.push({
                 path,
@@ -181,331 +430,127 @@ export function parseGitStatus(statusOutput) {
     return { staged, unstaged, untracked, conflicts };
 }
 /**
- * Map git status character to FileChangeStatus
- */
-function mapStatusChar(char) {
-    switch (char) {
-        case 'A':
-            return 'added';
-        case 'D':
-            return 'deleted';
-        case 'R':
-            return 'renamed';
-        case 'C':
-            return 'copied';
-        case 'M':
-        default:
-            return 'modified';
-    }
-}
-/**
- * Analyze staged changes to suggest commit type
- */
-export function analyzeChangesForCommitType(files) {
-    // Check file patterns to determine commit type
-    const paths = files.map(f => f.path.toLowerCase());
-    // Test files
-    if (paths.every(p => p.includes('test') ||
-        p.includes('spec') ||
-        p.includes('__tests__') ||
-        p.endsWith('.test.ts') ||
-        p.endsWith('.test.tsx') ||
-        p.endsWith('.spec.ts') ||
-        p.endsWith('.spec.tsx'))) {
-        return 'test';
-    }
-    // Documentation
-    if (paths.every(p => p.endsWith('.md') ||
-        p.includes('readme') ||
-        p.includes('docs/') ||
-        p.includes('documentation'))) {
-        return 'docs';
-    }
-    // CI/CD
-    if (paths.every(p => p.includes('.github/') ||
-        p.includes('.gitlab-ci') ||
-        p.includes('jenkinsfile') ||
-        p.includes('.circleci') ||
-        p.includes('.travis'))) {
-        return 'ci';
-    }
-    // Build configuration
-    if (paths.every(p => p.includes('package.json') ||
-        p.includes('webpack') ||
-        p.includes('vite') ||
-        p.includes('rollup') ||
-        p.includes('tsconfig') ||
-        p.includes('babel') ||
-        p.includes('eslint') ||
-        p.includes('prettier'))) {
-        return 'build';
-    }
-    // Style changes (CSS, formatting)
-    if (paths.every(p => p.endsWith('.css') ||
-        p.endsWith('.scss') ||
-        p.endsWith('.less') ||
-        p.endsWith('.styled.ts') ||
-        p.endsWith('.styled.tsx'))) {
-        return 'style';
-    }
-    // All new files = likely a feature
-    if (files.every(f => f.status === 'added')) {
-        return 'feat';
-    }
-    // All deletions = likely chore/cleanup
-    if (files.every(f => f.status === 'deleted')) {
-        return 'chore';
-    }
-    // If files contain "fix" in path or small changes in specific files
-    if (paths.some(p => p.includes('fix')) ||
-        (files.length <= 3 && files.every(f => f.additions + f.deletions < 20))) {
-        return 'fix';
-    }
-    // Default to feat for larger changes
-    return 'feat';
-}
-/**
- * Suggest a scope based on file paths
+ * Get diff stats for files (additions/deletions)
  */
-export function suggestScope(files) {
-    if (files.length === 0)
-        return undefined;
-    const paths = files.map(f => f.path);
-    // Extract common directory patterns
-    const directories = paths.map(p => {
-        const parts = p.split('/');
-        // Return second level for src/components/Button.tsx -> components
-        if (parts[0] === 'source' || parts[0] === 'src') {
-            return parts[1];
-        }
-        return parts[0];
-    });
-    // Find most common directory
-    const counts = new Map();
-    for (const dir of directories) {
-        if (dir) {
-            counts.set(dir, (counts.get(dir) || 0) + 1);
+export async function getDiffStats(staged = false) {
+    const stats = new Map();
+    try {
+        const args = ['diff', '--numstat'];
+        if (staged)
+            args.push('--cached');
+        const output = await execGit(args);
+        if (!output.trim())
+            return stats;
+        for (const line of output.split('\n')) {
+            const parts = line.split('\t');
+            if (parts.length >= 3) {
+                const additions = parts[0] === '-' ? 0 : parseInt(parts[0], 10) || 0;
+                const deletions = parts[1] === '-' ? 0 : parseInt(parts[1], 10) || 0;
+                const path = parts[2];
+                stats.set(path, { additions, deletions });
+            }
         }
     }
-    // If all files are in same directory, use it as scope
-    if (counts.size === 1) {
-        const scope = directories[0];
-        // Don't use generic names as scope
-        if (scope && !['lib', 'utils', 'helpers', 'common'].includes(scope)) {
-            return scope;
-        }
+    catch {
+        // Ignore errors
     }
-    return undefined;
-}
-/**
- * Detect potential breaking changes in the diff
- */
-async function detectBreakingChanges(files) {
-    // For now, we'll check file patterns that commonly indicate breaking changes
-    const riskyPaths = files.filter(f => f.path.includes('types') ||
-        f.path.includes('interfaces') ||
-        f.path.includes('api') ||
-        f.path.includes('schema') ||
-        f.path.includes('public'));
-    // If modifying public API files with deletions
-    if (riskyPaths.length > 0 && riskyPaths.some(f => f.deletions > 0)) {
-        return {
-            isBreaking: true,
-            reason: `Modifying public API files: ${riskyPaths.map(f => f.path).join(', ')}`,
-        };
-    }
-    return { isBreaking: false };
+    return stats;
 }
+// ============================================================================
+// Stash Operations
+// ============================================================================
 /**
- * Analyze staged changes comprehensively
+ * Get list of stashes
  */
-export async function analyzeStagedChanges() {
-    // Get diff stat
-    const diffStat = await execGit(['diff', '--staged', '--stat']);
-    const files = parseDiffStat(diffStat);
-    // Get name-status for accurate file status (A=added, M=modified, D=deleted, R=renamed)
-    const nameStatus = await execGit(['diff', '--staged', '--name-status']);
-    const statusLines = nameStatus.split('\n').filter(line => line.trim());
-    for (const line of statusLines) {
-        const parts = line.split('\t');
-        if (parts.length >= 2) {
-            const statusCode = parts[0][0]; // First char is status (A, M, D, R, C)
-            const path = parts.length === 3 ? parts[2] : parts[1]; // For renames, new path is third
-            const file = files.find(f => f.path === path);
-            if (file) {
-                switch (statusCode) {
-                    case 'A':
-                        file.status = 'added';
-                        break;
-                    case 'D':
-                        file.status = 'deleted';
-                        break;
-                    case 'R':
-                        file.status = 'renamed';
-                        break;
-                    case 'C':
-                        file.status = 'copied';
-                        break;
-                    // M stays as 'modified' (default)
-                }
-            }
-        }
+export async function getStashList() {
+    try {
+        const output = await execGit(['stash', 'list', '--format=%gd|%gs|%cr']);
+        if (!output.trim())
+            return [];
+        return output.split('\n').map((line, index) => {
+            const [ref, message, date] = line.split('|');
+            const branchMatch = message?.match(/WIP on ([^:]+):/);
+            return {
+                index,
+                message: message || ref || `stash@{${index}}`,
+                branch: branchMatch?.[1] || 'unknown',
+                date: date || '',
+            };
+        });
     }
-    // Get numstat for accurate counts
-    const numstat = await execGit(['diff', '--staged', '--numstat']);
-    const numstatLines = numstat.split('\n').filter(line => line.trim());
-    for (const line of numstatLines) {
-        const parts = line.split('\t');
-        if (parts.length >= 3) {
-            // Parse with NaN guard - default to 0 if parsing fails
-            const additionsRaw = parseInt(parts[0], 10);
-            const deletionsRaw = parseInt(parts[1], 10);
-            const additions = parts[0] === '-' || Number.isNaN(additionsRaw) ? 0 : additionsRaw;
-            const deletions = parts[1] === '-' || Number.isNaN(deletionsRaw) ? 0 : deletionsRaw;
-            const path = parts[2];
-            // Use exact path matching to avoid substring false positives
-            const file = files.find(f => f.path === path);
-            if (file) {
-                file.additions = additions;
-                file.deletions = deletions;
-            }
-        }
+    catch {
+        return [];
     }
-    const totalAdditions = files.reduce((sum, f) => sum + f.additions, 0);
-    const totalDeletions = files.reduce((sum, f) => sum + f.deletions, 0);
-    const suggestedType = analyzeChangesForCommitType(files);
-    const suggestedScope = suggestScope(files);
-    const { isBreaking, reason } = await detectBreakingChanges(files);
-    return {
-        files,
-        totalAdditions,
-        totalDeletions,
-        totalFiles: files.length,
-        suggestedType,
-        suggestedScope,
-        isBreakingChange: isBreaking,
-        breakingChangeReason: reason,
-    };
 }
 /**
- * Get enhanced git status
+ * Get stash count
  */
-export async function getEnhancedStatus() {
-    // Get porcelain status
-    const statusOutput = await execGit(['status', '--porcelain']);
-    const { staged, unstaged, untracked, conflicts } = parseGitStatus(statusOutput);
-    // Get branch info
-    const branch = await getCurrentBranch();
-    // Get upstream info
-    let upstream;
-    let ahead = 0;
-    let behind = 0;
+export async function getStashCount() {
     try {
-        upstream = await execGit(['rev-parse', '--abbrev-ref', '@{upstream}']);
-        const aheadBehind = await execGit([
-            'rev-list',
-            '--left-right',
-            '--count',
-            `${upstream}...HEAD`,
-        ]);
-        const [behindCount, aheadCount] = aheadBehind
-            .split('\t')
-            .map(n => parseInt(n, 10));
-        ahead = aheadCount || 0;
-        behind = behindCount || 0;
+        const output = await execGit(['stash', 'list']);
+        if (!output.trim())
+            return 0;
+        return output.split('\n').length;
     }
     catch {
-        // No upstream configured
-    }
-    // Build summary
-    const summaryParts = [];
-    if (staged.length > 0)
-        summaryParts.push(`${staged.length} staged`);
-    if (unstaged.length > 0)
-        summaryParts.push(`${unstaged.length} modified`);
-    if (untracked.length > 0)
-        summaryParts.push(`${untracked.length} untracked`);
-    if (conflicts.length > 0)
-        summaryParts.push(`${conflicts.length} conflicts`);
-    if (ahead > 0)
-        summaryParts.push(`${ahead} ahead`);
-    if (behind > 0)
-        summaryParts.push(`${behind} behind`);
-    const summary = summaryParts.length > 0 ? summaryParts.join(', ') : 'Working tree clean';
-    return {
-        branch,
-        upstream,
-        ahead,
-        behind,
-        staged,
-        unstaged,
-        untracked,
-        hasConflicts: conflicts.length > 0,
-        conflicts,
-        summary,
-    };
+        return 0;
+    }
 }
+// ============================================================================
+// Remote Operations
+// ============================================================================
 /**
- * Get commits between current branch and target
+ * Check if a remote exists
  */
-export async function getCommitsBetween(targetBranch) {
+export async function remoteExists(name) {
     try {
-        const log = await execGit([
-            'log',
-            `${targetBranch}..HEAD`,
-            '--format=%H%n%s%n%b%n---COMMIT_SEPARATOR---',
-        ]);
-        if (!log.trim()) {
-            return [];
-        }
-        const commitBlocks = log
-            .split('---COMMIT_SEPARATOR---')
-            .filter(b => b.trim());
-        return commitBlocks.map(block => {
-            const lines = block.trim().split('\n');
-            return {
-                hash: lines[0] || '',
-                subject: lines[1] || '',
-                body: lines.slice(2).join('\n').trim(),
-            };
-        });
+        const remotes = await execGit(['remote']);
+        return remotes.split('\n').includes(name);
     }
     catch {
-        return [];
+        return false;
     }
 }
+// ============================================================================
+// Diff Output Helpers
+// ============================================================================
 /**
- * Get list of contributors who have modified the changed files
+ * Truncate diff output if too long
  */
-export async function getSuggestedReviewers(files) {
-    const reviewers = new Set();
-    for (const file of files.slice(0, 5)) {
-        // Limit to avoid too many git commands
-        try {
-            const log = await execGit([
-                'log',
-                '--format=%ae',
-                '-n',
-                '5',
-                '--',
-                file.path,
-            ]);
-            for (const email of log.split('\n').filter(e => e.trim())) {
-                reviewers.add(email.trim());
-            }
-        }
-        catch {
-            // File might be new
-        }
-    }
-    // Remove current user
-    try {
-        const currentUser = await execGit(['config', 'user.email']);
-        reviewers.delete(currentUser.trim());
+export function truncateDiff(diff, maxLines = 500) {
+    const lines = diff.split('\n');
+    const totalLines = lines.length;
+    if (totalLines <= maxLines) {
+        return { content: diff, truncated: false, totalLines };
     }
-    catch {
-        // Config might not be set
+    const truncatedContent = lines.slice(0, maxLines).join('\n');
+    return {
+        content: truncatedContent +
+            `\n\n... [Diff truncated: showing ${maxLines} of ${totalLines} lines]`,
+        truncated: true,
+        totalLines,
+    };
+}
+// ============================================================================
+// Formatting Helpers
+// ============================================================================
+/**
+ * Format file status character for display
+ */
+export function formatStatusChar(status) {
+    switch (status) {
+        case 'added':
+            return 'A';
+        case 'modified':
+            return 'M';
+        case 'deleted':
+            return 'D';
+        case 'renamed':
+            return 'R';
+        case 'copied':
+            return 'C';
+        default:
+            return '?';
     }
-    return Array.from(reviewers).slice(0, 5);
 }
 //# sourceMappingURL=utils.js.map