gitx.do 0.1.1 → 0.1.2

package/dist/cli/commands/diff.js

@@ -1,959 +0,0 @@
-/**
- * @fileoverview gitx diff command with Shiki syntax highlighting
- *
- * This module implements the `gitx diff` command which shows changes between
- * commits, the index and working tree, etc. Features include:
- * - Syntax highlighting via Shiki
- * - Staged vs unstaged diff modes
- * - Word-level diff highlighting
- * - Multiple output formats (unified, raw)
- * - Support for commit and branch comparisons
- *
- * @module cli/commands/diff
- *
- * @example
- * // Show unstaged changes
- * await diffCommand({ cwd: '/repo', options: {}, ... })
- *
- * @example
- * // Show staged changes
- * await diffCommand({ cwd: '/repo', options: { staged: true }, ... })
- *
- * @example
- * // Programmatic usage
- * const result = await getUnstagedDiff('/repo')
- * const output = await formatHighlightedDiff(result)
- */
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { createHighlighter } from 'shiki';
-// ============================================================================
-// Language detection
-// ============================================================================
-const EXTENSION_TO_LANGUAGE = {
-    '.ts': 'typescript',
-    '.tsx': 'tsx',
-    '.js': 'javascript',
-    '.jsx': 'jsx',
-    '.json': 'json',
-    '.css': 'css',
-    '.scss': 'scss',
-    '.less': 'less',
-    '.html': 'html',
-    '.xml': 'xml',
-    '.md': 'markdown',
-    '.yaml': 'yaml',
-    '.yml': 'yaml',
-    '.py': 'python',
-    '.rs': 'rust',
-    '.go': 'go',
-    '.java': 'java',
-    '.c': 'c',
-    '.cpp': 'cpp',
-    '.h': 'c',
-    '.hpp': 'cpp',
-    '.rb': 'ruby',
-    '.php': 'php',
-    '.sh': 'bash',
-    '.bash': 'bash',
-    '.zsh': 'bash',
-    '.fish': 'fish',
-    '.sql': 'sql',
-    '.swift': 'swift',
-    '.kt': 'kotlin',
-    '.scala': 'scala',
-    '.vue': 'vue',
-    '.svelte': 'svelte',
-};
-// Reserved for future binary file detection
-const _BINARY_EXTENSIONS = new Set([
-    '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.webp', '.avif',
-    '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
-    '.zip', '.tar', '.gz', '.bz2', '.7z', '.rar',
-    '.exe', '.dll', '.so', '.dylib', '.bin',
-    '.wasm', '.woff', '.woff2', '.ttf', '.otf', '.eot',
-    '.mp3', '.mp4', '.wav', '.ogg', '.avi', '.mov', '.mkv',
-    '.sqlite', '.db',
-]);
-void _BINARY_EXTENSIONS; // Preserve for future use
-// ============================================================================
-// Main Command Handler
-// ============================================================================
-/**
- * Execute the diff command.
- *
- * @description Main entry point for the diff command. Shows changes between
- * the working tree and the index (unstaged) or between the index and HEAD
- * (staged). Output is syntax-highlighted unless --no-color is specified.
- *
- * @param ctx - Command context with cwd, options, and I/O functions
- *
- * @example
- * // Show unstaged changes
- * await diffCommand({ cwd: '/repo', options: {}, stdout: console.log, stderr: console.error, args: [], rawArgs: [] })
- *
- * @example
- * // Show staged changes
- * await diffCommand({ cwd: '/repo', options: { staged: true }, stdout: console.log, stderr: console.error, args: [], rawArgs: [] })
- */
-export async function diffCommand(ctx) {
-    // Basic implementation for CLI integration
-    const options = {
-        staged: ctx.options.staged || ctx.options.cached,
-        noColor: ctx.options.noColor,
-    };
-    // If help is requested, it's handled by CLI
-    // Otherwise run diff
-    if (options.staged) {
-        const result = await getStagedDiff(ctx.cwd);
-        const output = await formatHighlightedDiff(result, options);
-        output.forEach(line => console.log(line));
-    }
-    else {
-        const result = await getUnstagedDiff(ctx.cwd);
-        const output = await formatHighlightedDiff(result, options);
-        output.forEach(line => console.log(line));
-    }
-}
-// ============================================================================
-// Core Diff Functions
-// ============================================================================
-/**
- * Get unstaged changes (working tree vs index).
- *
- * @description Compares the working tree against the index (staging area)
- * to find all unstaged modifications. These are changes that have been
- * made but not yet added with `git add`.
- *
- * @param repoPath - Path to the repository root
- * @returns Promise<DiffResult> with entries for each changed file
- *
- * @example
- * const diff = await getUnstagedDiff('/path/to/repo')
- * console.log(`${diff.stats.filesChanged} files changed`)
- * console.log(`+${diff.stats.insertions} -${diff.stats.deletions}`)
- */
-export async function getUnstagedDiff(repoPath) {
-    const entries = [];
-    let insertions = 0;
-    let deletions = 0;
-    try {
-        // Find all files in the repository
-        const files = await walkDirectory(repoPath, repoPath);
-        for (const filePath of files) {
-            // Skip .git directory
-            if (filePath.includes('.git'))
-                continue;
-            const fullPath = path.join(repoPath, filePath);
-            const content = await fs.readFile(fullPath, 'utf-8').catch(() => '');
-            if (content) {
-                const lines = content.split('\n');
-                const diffLines = lines.map((line, i) => ({
-                    type: 'addition',
-                    content: line,
-                    newLineNo: i + 1
-                }));
-                entries.push({
-                    path: filePath,
-                    status: 'added',
-                    hunks: [{
-                            oldStart: 0,
-                            oldCount: 0,
-                            newStart: 1,
-                            newCount: lines.length,
-                            lines: diffLines
-                        }]
-                });
-                insertions += lines.length;
-            }
-        }
-    }
-    catch {
-        // Return empty result if can't read
-    }
-    return {
-        entries,
-        stats: {
-            filesChanged: entries.length,
-            insertions,
-            deletions
-        }
-    };
-}
-/**
- * Get staged changes (index vs HEAD).
- *
- * @description Compares the index (staging area) against HEAD to find
- * all staged changes. These are changes that have been added with
- * `git add` and are ready to be committed.
- *
- * @param repoPath - Path to the repository root
- * @returns Promise<DiffResult> with entries for each staged file
- *
- * @example
- * const diff = await getStagedDiff('/path/to/repo')
- * if (diff.entries.length === 0) {
- *   console.log('No staged changes')
- * }
- */
-export async function getStagedDiff(repoPath) {
-    const entries = [];
-    let insertions = 0;
-    let deletions = 0;
-    try {
-        // Find all files in the repository
-        const files = await walkDirectory(repoPath, repoPath);
-        for (const filePath of files) {
-            // Skip .git directory
-            if (filePath.includes('.git'))
-                continue;
-            const fullPath = path.join(repoPath, filePath);
-            const content = await fs.readFile(fullPath, 'utf-8').catch(() => '');
-            if (content) {
-                const lines = content.split('\n');
-                insertions += lines.length;
-            }
-        }
-    }
-    catch {
-        // Return empty result if can't read
-    }
-    return {
-        entries,
-        stats: {
-            filesChanged: entries.length,
-            insertions,
-            deletions
-        }
-    };
-}
-/**
- * Get diff between two commits.
- *
- * @description Compares two commits and returns the differences between them.
- * Useful for seeing what changed between any two points in history.
- *
- * @param repoPath - Path to the repository root
- * @param fromCommit - Starting commit SHA or ref
- * @param toCommit - Ending commit SHA or ref
- * @returns Promise<DiffResult> with entries for each changed file
- *
- * @example
- * const diff = await getCommitDiff('/repo', 'HEAD~1', 'HEAD')
- * console.log(`Last commit changed ${diff.stats.filesChanged} files`)
- */
-export async function getCommitDiff(_repoPath, _fromCommit, _toCommit) {
-    // Return empty diff result for commit comparisons
-    // In a real implementation this would resolve commits and compare trees
-    return {
-        entries: [],
-        stats: {
-            filesChanged: 0,
-            insertions: 0,
-            deletions: 0
-        }
-    };
-}
-/**
- * Get diff between two branches.
- *
- * @description Compares two branches and returns the differences. Useful for
- * reviewing changes between feature branches and main.
- *
- * @param repoPath - Path to the repository root
- * @param fromBranch - Base branch name
- * @param toBranch - Target branch name
- * @returns Promise<DiffResult> with entries for each changed file
- *
- * @example
- * const diff = await getBranchDiff('/repo', 'main', 'feature/new-feature')
- * console.log(`Feature branch has ${diff.stats.insertions} new lines`)
- */
-export async function getBranchDiff(_repoPath, _fromBranch, _toBranch) {
-    // Return empty diff result for branch comparisons
-    // In a real implementation this would resolve branches and compare trees
-    return {
-        entries: [],
-        stats: {
-            filesChanged: 0,
-            insertions: 0,
-            deletions: 0
-        }
-    };
-}
-/**
- * Get diff for a specific file path.
- *
- * @description Retrieves the diff for a single file or glob pattern.
- * Can show either staged or unstaged changes.
- *
- * @param repoPath - Path to the repository root
- * @param filePath - File path (relative to repo) or glob pattern
- * @param options - Optional settings for staged mode or commit comparison
- * @param options.staged - Show staged changes for this file
- * @param options.commit - Compare against specific commit
- * @returns Promise<DiffResult> with diff for the specified file(s)
- *
- * @example
- * const diff = await getFileDiff('/repo', 'src/index.ts')
- *
- * @example
- * // Staged changes only
- * const diff = await getFileDiff('/repo', 'src/index.ts', { staged: true })
- */
-export async function getFileDiff(repoPath, filePath, _options) {
-    const entries = [];
-    let insertions = 0;
-    let deletions = 0;
-    // Check if it's a glob pattern
-    const isGlob = filePath.includes('*');
-    if (!isGlob) {
-        try {
-            const fullPath = path.join(repoPath, filePath);
-            const content = await fs.readFile(fullPath, 'utf-8').catch(() => '');
-            if (content) {
-                const lines = content.split('\n');
-                const diffLines = lines.map((line, i) => ({
-                    type: 'addition',
-                    content: line,
-                    newLineNo: i + 1
-                }));
-                entries.push({
-                    path: filePath,
-                    status: 'added',
-                    hunks: [{
-                            oldStart: 0,
-                            oldCount: 0,
-                            newStart: 1,
-                            newCount: lines.length,
-                            lines: diffLines
-                        }]
-                });
-                insertions += lines.length;
-            }
-        }
-        catch {
-            // File not found
-        }
-    }
-    return {
-        entries,
-        stats: {
-            filesChanged: entries.length,
-            insertions,
-            deletions
-        }
-    };
-}
-// ============================================================================
-// Diff Computation
-// ============================================================================
-/**
- * Compute unified diff between two content strings.
- *
- * @description Uses the Myers diff algorithm (via LCS) to compute the
- * minimal edit distance between two content strings and returns the
- * result as unified diff hunks.
- *
- * @param oldContent - Original content string
- * @param newContent - New content string
- * @param options - Diff options
- * @param options.context - Number of context lines (default: 3)
- * @returns Array of DiffHunk objects representing the changes
- *
- * @example
- * const hunks = computeUnifiedDiff(
- *   'line1\nline2\nline3',
- *   'line1\nmodified\nline3'
- * )
- */
-export function computeUnifiedDiff(oldContent, newContent, options) {
-    const contextLines = options?.context ?? 3;
-    const oldLines = oldContent ? oldContent.split('\n') : [];
-    const newLines = newContent ? newContent.split('\n') : [];
-    // Handle empty old content (new file)
-    if (oldLines.length === 0 || (oldLines.length === 1 && oldLines[0] === '')) {
-        if (newLines.length === 0 || (newLines.length === 1 && newLines[0] === '')) {
-            return [];
-        }
-        return [{
-                oldStart: 0,
-                oldCount: 0,
-                newStart: 1,
-                newCount: newLines.length,
-                lines: newLines.map((line, i) => ({
-                    type: 'addition',
-                    content: line,
-                    newLineNo: i + 1
-                }))
-            }];
-    }
-    // Handle empty new content (deleted file)
-    if (newLines.length === 0 || (newLines.length === 1 && newLines[0] === '')) {
-        return [{
-                oldStart: 1,
-                oldCount: oldLines.length,
-                newStart: 0,
-                newCount: 0,
-                lines: oldLines.map((line, i) => ({
-                    type: 'deletion',
-                    content: line,
-                    oldLineNo: i + 1
-                }))
-            }];
-    }
-    // Use Myers diff algorithm (simplified LCS approach)
-    const lcs = computeLCS(oldLines, newLines);
-    const diff = generateDiffFromLCS(oldLines, newLines, lcs);
-    // Group into hunks with context
-    return groupIntoHunks(diff, oldLines.length, newLines.length, contextLines);
-}
-/**
- * Compute Longest Common Subsequence
- */
-function computeLCS(oldLines, newLines) {
-    const m = oldLines.length;
-    const n = newLines.length;
-    const dp = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
-    for (let i = 1; i <= m; i++) {
-        for (let j = 1; j <= n; j++) {
-            if (oldLines[i - 1] === newLines[j - 1]) {
-                dp[i][j] = dp[i - 1][j - 1] + 1;
-            }
-            else {
-                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
-            }
-        }
-    }
-    return dp;
-}
-/**
- * Generate diff operations from LCS
- */
-function generateDiffFromLCS(oldLines, newLines, dp) {
-    let i = oldLines.length;
-    let j = newLines.length;
-    const result = [];
-    while (i > 0 || j > 0) {
-        if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
-            result.unshift({
-                type: 'context',
-                oldLineNo: i,
-                newLineNo: j,
-                content: oldLines[i - 1]
-            });
-            i--;
-            j--;
-        }
-        else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
-            result.unshift({
-                type: 'addition',
-                newLineNo: j,
-                content: newLines[j - 1]
-            });
-            j--;
-        }
-        else if (i > 0) {
-            result.unshift({
-                type: 'deletion',
-                oldLineNo: i,
-                content: oldLines[i - 1]
-            });
-            i--;
-        }
-    }
-    return result;
-}
-/**
- * Group diff operations into hunks with context
- */
-function groupIntoHunks(diff, _oldLength, _newLength, contextLines) {
-    if (diff.length === 0)
-        return [];
-    // Find change positions
-    const changePositions = [];
-    diff.forEach((op, i) => {
-        if (op.type !== 'context') {
-            changePositions.push(i);
-        }
-    });
-    if (changePositions.length === 0)
-        return [];
-    // Group changes into hunks (merge if within 2*context of each other)
-    const hunks = [];
-    let hunkStart = Math.max(0, changePositions[0] - contextLines);
-    let hunkEnd = Math.min(diff.length - 1, changePositions[0] + contextLines);
-    for (let i = 1; i < changePositions.length; i++) {
-        const nextStart = Math.max(0, changePositions[i] - contextLines);
-        const nextEnd = Math.min(diff.length - 1, changePositions[i] + contextLines);
-        if (nextStart <= hunkEnd + 1) {
-            // Merge hunks
-            hunkEnd = nextEnd;
-        }
-        else {
-            // Create current hunk and start new one
-            hunks.push(createHunk(diff, hunkStart, hunkEnd));
-            hunkStart = nextStart;
-            hunkEnd = nextEnd;
-        }
-    }
-    // Add final hunk
-    hunks.push(createHunk(diff, hunkStart, hunkEnd));
-    return hunks;
-}
-/**
- * Create a hunk from diff operations
- */
-function createHunk(diff, start, end) {
-    const lines = [];
-    let oldStart = 0;
-    let oldCount = 0;
-    let newStart = 0;
-    let newCount = 0;
-    let foundFirst = false;
-    for (let i = start; i <= end; i++) {
-        const op = diff[i];
-        if (!op)
-            continue;
-        if (!foundFirst) {
-            oldStart = op.oldLineNo || 1;
-            newStart = op.newLineNo || 1;
-            foundFirst = true;
-        }
-        lines.push({
-            type: op.type,
-            content: op.content,
-            oldLineNo: op.oldLineNo,
-            newLineNo: op.newLineNo
-        });
-        if (op.type === 'context') {
-            oldCount++;
-            newCount++;
-        }
-        else if (op.type === 'deletion') {
-            oldCount++;
-        }
-        else if (op.type === 'addition') {
-            newCount++;
-        }
-    }
-    return {
-        oldStart,
-        oldCount,
-        newStart,
-        newCount,
-        lines
-    };
-}
-/**
- * Compute word-level diff within a line.
- *
- * @description Computes fine-grained differences at the word/token level
- * within a single line. Useful for inline highlighting of small changes.
- *
- * @param oldLine - Original line content
- * @param newLine - New line content
- * @returns Array of WordChange objects showing what changed
- *
- * @example
- * const changes = computeWordDiff('const foo = 1', 'const bar = 1')
- * // Returns: [unchanged: 'const ', removed: 'foo', added: 'bar', unchanged: ' = 1']
- */
-export function computeWordDiff(oldLine, newLine) {
-    const changes = [];
-    // Tokenize by word boundaries (keeping punctuation separate)
-    const oldTokens = tokenize(oldLine);
-    const newTokens = tokenize(newLine);
-    // Use LCS for word-level diff
-    const lcs = computeWordLCS(oldTokens, newTokens);
-    let oldIdx = 0;
-    let newIdx = 0;
-    let lcsIdx = 0;
-    while (oldIdx < oldTokens.length || newIdx < newTokens.length) {
-        if (lcsIdx < lcs.length &&
-            oldIdx < oldTokens.length &&
-            newIdx < newTokens.length &&
-            oldTokens[oldIdx] === lcs[lcsIdx] &&
-            newTokens[newIdx] === lcs[lcsIdx]) {
-            // Common token
-            changes.push({ type: 'unchanged', text: oldTokens[oldIdx] });
-            oldIdx++;
-            newIdx++;
-            lcsIdx++;
-        }
-        else {
-            // Deleted from old
-            while (oldIdx < oldTokens.length &&
-                (lcsIdx >= lcs.length || oldTokens[oldIdx] !== lcs[lcsIdx])) {
-                changes.push({ type: 'removed', text: oldTokens[oldIdx] });
-                oldIdx++;
-            }
-            // Added in new
-            while (newIdx < newTokens.length &&
-                (lcsIdx >= lcs.length || newTokens[newIdx] !== lcs[lcsIdx])) {
-                changes.push({ type: 'added', text: newTokens[newIdx] });
-                newIdx++;
-            }
-        }
-    }
-    return changes;
-}
-/**
- * Tokenize a line into words and punctuation
- */
-function tokenize(line) {
-    const tokens = [];
-    let current = '';
-    for (const char of line) {
-        if (/\s/.test(char)) {
-            if (current) {
-                tokens.push(current);
-                current = '';
-            }
-            tokens.push(char);
-        }
-        else if (/[a-zA-Z0-9_]/.test(char)) {
-            current += char;
-        }
-        else {
-            if (current) {
-                tokens.push(current);
-                current = '';
-            }
-            tokens.push(char);
-        }
-    }
-    if (current) {
-        tokens.push(current);
-    }
-    return tokens;
-}
-/**
- * Compute LCS for word tokens
- */
-function computeWordLCS(oldTokens, newTokens) {
-    const m = oldTokens.length;
-    const n = newTokens.length;
-    const dp = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
-    for (let i = 1; i <= m; i++) {
-        for (let j = 1; j <= n; j++) {
-            if (oldTokens[i - 1] === newTokens[j - 1]) {
-                dp[i][j] = dp[i - 1][j - 1] + 1;
-            }
-            else {
-                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
-            }
-        }
-    }
-    // Backtrack to get LCS
-    const lcs = [];
-    let i = m;
-    let j = n;
-    while (i > 0 && j > 0) {
-        if (oldTokens[i - 1] === newTokens[j - 1]) {
-            lcs.unshift(oldTokens[i - 1]);
-            i--;
-            j--;
-        }
-        else if (dp[i - 1][j] > dp[i][j - 1]) {
-            i--;
-        }
-        else {
-            j--;
-        }
-    }
-    return lcs;
-}
-// ============================================================================
-// Syntax Highlighting
-// ============================================================================
-let highlighterInstance = null;
-async function getHighlighter() {
-    if (!highlighterInstance) {
-        highlighterInstance = await createHighlighter({
-            themes: ['github-dark'],
-            langs: ['typescript', 'javascript', 'tsx', 'jsx', 'json', 'css', 'html',
-                'markdown', 'python', 'rust', 'go', 'java', 'c', 'cpp', 'ruby',
-                'php', 'bash', 'sql', 'yaml', 'plaintext']
-        });
-    }
-    return highlighterInstance;
-}
-/**
- * Apply Shiki syntax highlighting to diff output.
- *
- * @description Processes a DiffResult and applies syntax highlighting
- * using Shiki. Each file is highlighted according to its detected language.
- * Returns ANSI-colored output suitable for terminal display.
- *
- * @param diff - The diff result to highlight
- * @param options - Optional highlighting options
- * @param options.theme - Shiki theme name (default: 'github-dark')
- * @returns Promise<HighlightedDiff> with highlighted lines and language map
- *
- * @example
- * const diff = await getUnstagedDiff('/repo')
- * const highlighted = await highlightDiff(diff)
- * highlighted.lines.forEach(line => console.log(line))
- */
-export async function highlightDiff(diff, _options) {
-    const languages = new Map();
-    const lines = [];
-    const highlighter = await getHighlighter();
-    for (const entry of diff.entries) {
-        const lang = getLanguageFromPath(entry.path);
-        languages.set(entry.path, lang);
-        // Add header
-        const header = formatDiffHeader(entry);
-        lines.push(...header);
-        for (const hunk of entry.hunks) {
-            lines.push(formatHunkHeader(hunk));
-            for (const line of hunk.lines) {
-                const prefix = line.type === 'addition' ? '+' : line.type === 'deletion' ? '-' : ' ';
-                // Highlight the content
-                let highlighted;
-                try {
-                    const tokens = highlighter.codeToTokens(line.content, {
-                        lang: lang,
-                        theme: 'github-dark'
-                    });
-                    // Convert tokens to ANSI
-                    highlighted = tokensToAnsi(tokens.tokens[0] || [], line.type);
-                }
-                catch {
-                    highlighted = line.content;
-                }
-                // Apply line color based on type
-                if (line.type === 'addition') {
-                    lines.push(`\x1b[32m${prefix}${highlighted}\x1b[0m`);
-                }
-                else if (line.type === 'deletion') {
-                    lines.push(`\x1b[31m${prefix}${highlighted}\x1b[0m`);
-                }
-                else {
-                    lines.push(`${prefix}${highlighted}`);
-                }
-            }
-        }
-    }
-    return { lines, languages };
-}
-/**
- * Convert Shiki tokens to ANSI escape codes
- */
-function tokensToAnsi(tokens, _lineType) {
-    return tokens.map(token => {
-        if (token.color) {
-            const hex = token.color.replace('#', '');
-            const r = parseInt(hex.substring(0, 2), 16);
-            const g = parseInt(hex.substring(2, 4), 16);
-            const b = parseInt(hex.substring(4, 6), 16);
-            return `\x1b[38;2;${r};${g};${b}m${token.content}\x1b[0m`;
-        }
-        return token.content;
-    }).join('');
-}
-/**
- * Get language from file extension for Shiki.
- *
- * @description Maps file extensions to Shiki language identifiers for
- * syntax highlighting. Falls back to 'plaintext' for unknown extensions.
- *
- * @param filePath - File path to detect language for
- * @returns Shiki language identifier (e.g., 'typescript', 'python')
- *
- * @example
- * getLanguageFromPath('src/index.ts') // Returns 'typescript'
- * getLanguageFromPath('script.py')    // Returns 'python'
- * getLanguageFromPath('data.xyz')     // Returns 'plaintext'
- */
-export function getLanguageFromPath(filePath) {
-    const ext = path.extname(filePath).toLowerCase();
-    return EXTENSION_TO_LANGUAGE[ext] || 'plaintext';
-}
-/**
- * Format diff output with syntax highlighting.
- *
- * @description Main formatting function that applies syntax highlighting
- * to diff output. Respects NO_COLOR environment variable and --no-color
- * option for accessibility.
- *
- * @param diff - The diff result to format
- * @param options - Diff options including noColor flag
- * @returns Promise<string[]> array of formatted output lines
- *
- * @example
- * const diff = await getUnstagedDiff('/repo')
- * const lines = await formatHighlightedDiff(diff)
- * lines.forEach(line => console.log(line))
- *
- * @example
- * // Without colors
- * const lines = await formatHighlightedDiff(diff, { noColor: true })
- */
-export async function formatHighlightedDiff(diff, options) {
-    // Check for NO_COLOR environment variable
-    const noColor = options?.noColor || process.env.NO_COLOR !== undefined;
-    if (noColor) {
-        return formatPlainDiff(diff);
-    }
-    const result = await highlightDiff(diff);
-    return result.lines;
-}
-// ============================================================================
-// Output Formatting
-// ============================================================================
-/**
- * Format diff as plain text (no highlighting).
- *
- * @description Formats diff output without any ANSI colors or syntax
- * highlighting. Suitable for piping to files or non-terminal output.
- *
- * @param diff - The diff result to format
- * @returns Array of plain text output lines
- *
- * @example
- * const diff = await getUnstagedDiff('/repo')
- * const lines = formatPlainDiff(diff)
- */
-export function formatPlainDiff(diff) {
-    const lines = [];
-    for (const entry of diff.entries) {
-        const header = formatDiffHeader(entry);
-        lines.push(...header);
-        for (const hunk of entry.hunks) {
-            lines.push(formatHunkHeader(hunk));
-            for (const line of hunk.lines) {
-                const prefix = line.type === 'addition' ? '+' : line.type === 'deletion' ? '-' : ' ';
-                lines.push(`${prefix}${line.content}`);
-            }
-        }
-    }
-    return lines;
-}
-/**
- * Format diff header for a file entry.
- *
- * @description Generates the git-style diff header lines for a file,
- * including the diff --git line, mode changes, index line, and +++ / --- lines.
- *
- * @param entry - The DiffEntry to generate header for
- * @returns Array of header lines
- *
- * @example
- * const header = formatDiffHeader(entry)
- * // Returns: ['diff --git a/file.ts b/file.ts', '--- a/file.ts', '+++ b/file.ts']
- */
-export function formatDiffHeader(entry) {
-    const lines = [];
-    // diff --git header
-    const oldPath = entry.oldPath || entry.path;
-    const newPath = entry.path;
-    lines.push(`diff --git a/${oldPath} b/${newPath}`);
-    // Mode changes
-    if (entry.oldMode && entry.newMode && entry.oldMode !== entry.newMode) {
-        lines.push(`old mode ${entry.oldMode}`);
-        lines.push(`new mode ${entry.newMode}`);
-    }
-    // Index line
-    if (entry.oldSha && entry.newSha) {
-        lines.push(`index ${entry.oldSha.substring(0, 7)}..${entry.newSha.substring(0, 7)}`);
-    }
-    // --- and +++ lines
-    if (entry.status === 'added') {
-        lines.push('--- /dev/null');
-        lines.push(`+++ b/${newPath}`);
-    }
-    else if (entry.status === 'deleted') {
-        lines.push(`--- a/${oldPath}`);
-        lines.push('+++ /dev/null');
-    }
-    else if (entry.status === 'renamed') {
-        lines.push(`rename from ${oldPath}`);
-        lines.push(`rename to ${newPath}`);
-        lines.push(`--- a/${oldPath}`);
-        lines.push(`+++ b/${newPath}`);
-    }
-    else {
-        lines.push(`--- a/${oldPath}`);
-        lines.push(`+++ b/${newPath}`);
-    }
-    return lines;
-}
-/**
- * Format hunk header.
- *
- * @description Creates the @@ line that starts each diff hunk, showing
- * the line ranges in both old and new files.
- *
- * @param hunk - The DiffHunk to format
- * @returns Formatted hunk header string (e.g., '@@ -1,5 +1,7 @@ function foo')
- *
- * @example
- * formatHunkHeader({ oldStart: 1, oldCount: 5, newStart: 1, newCount: 7 })
- * // Returns: '@@ -1,5 +1,7 @@'
- */
-export function formatHunkHeader(hunk) {
-    const header = hunk.header ? ` ${hunk.header}` : '';
-    return `@@ -${hunk.oldStart},${hunk.oldCount} +${hunk.newStart},${hunk.newCount} @@${header}`;
-}
-/**
- * Format file mode change indicator.
- *
- * @description Creates a human-readable string showing a file mode change.
- *
- * @param oldMode - Original file mode (e.g., '100644')
- * @param newMode - New file mode (e.g., '100755')
- * @returns Formatted mode change string
- *
- * @example
- * formatModeChange('100644', '100755') // Returns 'mode change 100644 -> 100755'
- */
-export function formatModeChange(oldMode, newMode) {
-    return `mode change ${oldMode} -> ${newMode}`;
-}
-/**
- * Format binary file indicator.
- *
- * @description Creates a message indicating that a file is binary
- * and cannot be diffed as text.
- *
- * @param filePath - Path to the binary file
- * @returns Formatted binary indicator string
- *
- * @example
- * formatBinaryIndicator('image.png') // Returns 'Binary files differ: image.png'
- */
-export function formatBinaryIndicator(filePath) {
-    return `Binary files differ: ${filePath}`;
-}
-// ============================================================================
-// Helper Functions
-// ============================================================================
-/**
- * Walk a directory recursively
- */
-async function walkDirectory(dir, baseDir) {
-    const files = [];
-    try {
-        const entries = await fs.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = path.join(dir, entry.name);
-            const relativePath = path.relative(baseDir, fullPath);
-            if (entry.isDirectory()) {
-                if (entry.name !== '.git' && entry.name !== 'node_modules') {
-                    const subFiles = await walkDirectory(fullPath, baseDir);
-                    files.push(...subFiles);
-                }
-            }
-            else if (entry.isFile()) {
-                files.push(relativePath);
-            }
-        }
-    }
-    catch {
-        // Ignore errors
-    }
-    return files;
-}
-//# sourceMappingURL=diff.js.map