diff-easy 0.1.0

package/dist/server/git-diff.js

@@ -0,0 +1,909 @@
+import { simpleGit } from 'simple-git';
+import { isAbsolute, resolve, sep } from 'path';
+import { validateDiffArguments, shortHash, createCommitRangeString, findUntrackedFiles, } from '../cli/utils.js';
+import { getMergeBaseTargetRef, normalizeBaseMode } from '../utils/diffSelection.js';
+import { isGeneratedFile } from './generated-file-check.js';
+/**
+ * Run `fn` over `items` with at most `limit` in flight at once, preserving input
+ * order in the results. Keeps unbounded fan-out (one git spawn per file) from
+ * exhausting processes/memory while staying non-blocking.
+ */
+async function mapWithConcurrency(items, limit, fn) {
+    const results = new Array(items.length);
+    let next = 0;
+    const worker = async () => {
+        while (next < items.length) {
+            const index = next++;
+            results[index] = await fn(items[index]);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+    return results;
+}
+export class GitDiffParser {
+    git;
+    repoPath;
+    includeUntracked;
+    resolvedCommitCache = new Map();
+    static RESOLVED_COMMIT_CACHE_TTL_MS = 5_000;
+    static GENERATED_HEADER_SCAN_BYTES = 4 * 1024;
+    static GITATTRIBUTES_CHECK_CHUNK_SIZE = 200;
+    static UNTRACKED_DIFF_MAX_BUFFER = 100 * 1024 * 1024; // 100MB
+    // Bound the per-fetch untracked work so a repo full of untracked files (fresh
+    // clone, build output) can't spawn thousands of git processes or hog memory.
+    static UNTRACKED_DIFF_CONCURRENCY = 8;
+    static MAX_UNTRACKED_FILES = 2000;
+    // `includeUntracked` is opt-in: the hub opens arbitrary repos at runtime where
+    // it cannot show difit's interactive "include untracked?" prompt, so it asks
+    // for read-only synthesis instead (see getUntrackedFileDiffs). The CLI leaves
+    // it off and keeps owning untracked files via its intent-to-add prompt.
+    constructor(repoPath = process.cwd(), options = {}) {
+        this.repoPath = repoPath;
+        this.git = simpleGit(repoPath);
+        this.includeUntracked = options.includeUntracked ?? false;
+    }
+    normalizeRepositoryRelativePath(filepath) {
+        if (filepath.length === 0) {
+            throw new Error('Invalid file path');
+        }
+        const normalizedFilepath = filepath.replace(/\\/g, '/');
+        const hasParentTraversal = normalizedFilepath.split('/').some((segment) => segment === '..');
+        if (isAbsolute(filepath) || normalizedFilepath.startsWith('/') || hasParentTraversal) {
+            throw new Error('File path outside repository');
+        }
+        const repositoryPath = resolve(this.repoPath);
+        const resolvedPath = resolve(repositoryPath, normalizedFilepath);
+        if (resolvedPath !== repositoryPath && !resolvedPath.startsWith(`${repositoryPath}${sep}`)) {
+            throw new Error('File path outside repository');
+        }
+        return normalizedFilepath;
+    }
+    async resolveBaseCommitish(selection) {
+        if (normalizeBaseMode(selection.baseMode) !== 'merge-base') {
+            return selection.baseCommitish;
+        }
+        const targetRef = getMergeBaseTargetRef(selection.targetCommitish);
+        const mergeBase = await this.git.raw(['merge-base', targetRef, selection.baseCommitish]);
+        return mergeBase.trim();
+    }
+    async parseDiff(selection, ignoreWhitespace = false, contextLines) {
+        const { targetCommitish, baseCommitish } = selection;
+        const requestedBaseMode = normalizeBaseMode(selection.baseMode) === 'merge-base' ? 'merge-base' : undefined;
+        try {
+            // diff-easy: a turn that produced no changes has identical before/after
+            // snapshots (git dedups equal trees), so base === target. Treat that as an
+            // empty diff instead of erroring ("Cannot compare X with itself").
+            if (baseCommitish === targetCommitish) {
+                const hash = shortHash(baseCommitish);
+                return {
+                    commit: 'No changes in this turn',
+                    files: [],
+                    isEmpty: true,
+                    baseCommitish: hash,
+                    targetCommitish: hash,
+                    requestedBaseCommitish: baseCommitish,
+                    requestedTargetCommitish: targetCommitish,
+                    requestedBaseMode,
+                };
+            }
+            // Validate arguments
+            const validation = validateDiffArguments(targetCommitish, baseCommitish);
+            if (!validation.valid) {
+                throw new Error(validation.error);
+            }
+            const effectiveBaseCommitish = await this.resolveBaseCommitish(selection);
+            let resolvedCommit;
+            let diffArgs;
+            let resolvedBaseCommitish = effectiveBaseCommitish;
+            let resolvedTargetCommitish = targetCommitish;
+            let attributesRef = targetCommitish;
+            // Handle target special chars (base is always a regular commit)
+            if (targetCommitish === 'working') {
+                // Show unstaged changes (working vs staged)
+                resolvedCommit = 'Working Directory (unstaged changes)';
+                diffArgs = [];
+            }
+            else if (targetCommitish === 'staged') {
+                // Show staged changes against base commit
+                const baseHash = await this.git.revparse([effectiveBaseCommitish]);
+                resolvedCommit = `${shortHash(baseHash)} vs Staging Area (staged changes)`;
+                resolvedBaseCommitish = shortHash(baseHash);
+                diffArgs = ['--cached', effectiveBaseCommitish];
+            }
+            else if (targetCommitish === '.') {
+                // Show all uncommitted changes against base commit
+                const baseHash = await this.git.revparse([effectiveBaseCommitish]);
+                resolvedCommit = `${shortHash(baseHash)} vs Working Directory (all uncommitted changes)`;
+                resolvedBaseCommitish = shortHash(baseHash);
+                diffArgs = [effectiveBaseCommitish];
+            }
+            else {
+                // Both are regular commits: standard commit-to-commit comparison
+                const targetHash = await this.git.revparse([targetCommitish]);
+                const baseHash = await this.git.revparse([effectiveBaseCommitish]);
+                resolvedCommit = createCommitRangeString(shortHash(baseHash), shortHash(targetHash));
+                resolvedBaseCommitish = shortHash(baseHash);
+                resolvedTargetCommitish = shortHash(targetHash);
+                attributesRef = targetHash;
+                diffArgs = [baseHash, targetHash];
+            }
+            if (ignoreWhitespace) {
+                diffArgs.push('-w');
+            }
+            if (contextLines !== undefined) {
+                diffArgs.push(`-U${contextLines}`);
+            }
+            // Ignore external diff-tools to unify output.
+            // https://github.com/yoshiko-pg/difit/issues/19
+            diffArgs.push('--no-ext-diff', '--color=never');
+            // Single git invocation for better startup latency on large repositories.
+            let diffRaw = await this.git.diff(diffArgs);
+            // `git diff` never reports untracked files, so brand-new files are invisible
+            // in the working ('working') and all-uncommitted ('.') views. When enabled
+            // (hub mode), synthesize new-file diffs for them — read-only, no index
+            // mutation. The staged ('--cached') view correctly excludes them.
+            if (this.includeUntracked && (targetCommitish === 'working' || targetCommitish === '.')) {
+                const untrackedDiff = await this.getUntrackedFileDiffs(ignoreWhitespace, contextLines);
+                if (untrackedDiff) {
+                    diffRaw =
+                        diffRaw && !diffRaw.endsWith('\n')
+                            ? `${diffRaw}\n${untrackedDiff}`
+                            : `${diffRaw}${untrackedDiff}`;
+                }
+            }
+            const files = await this.markGitattributesGeneratedFiles(this.parseUnifiedDiff(diffRaw), attributesRef);
+            return {
+                commit: resolvedCommit,
+                files,
+                isEmpty: files.length === 0,
+                baseCommitish: resolvedBaseCommitish,
+                targetCommitish: resolvedTargetCommitish,
+                requestedBaseCommitish: baseCommitish,
+                requestedTargetCommitish: targetCommitish,
+                requestedBaseMode,
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to parse diff for ${targetCommitish} vs ${baseCommitish}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Build synthetic unified diffs for untracked (new, not-yet-added) files.
+     *
+     * difit's own untracked support works by mutating the index (`git add
+     * --intent-to-add`) so the normal `git diff` picks the files up. The hub can't
+     * prompt for that and must not mutate repos it merely views, so instead we
+     * reuse difit's read-only enumerator (`findUntrackedFiles`) and produce a
+     * new-file diff per file with `git diff --no-index -- /dev/null <file>`, which
+     * never touches the index.
+     */
+    async getUntrackedFileDiffs(ignoreWhitespace, contextLines) {
+        let files = await findUntrackedFiles(this.git);
+        if (files.length === 0) {
+            return '';
+        }
+        // Guard against repos with a huge number of untracked files (fresh clone,
+        // build artifacts): cap the work and tell the operator what was dropped
+        // rather than silently spawning thousands of git processes.
+        if (files.length > GitDiffParser.MAX_UNTRACKED_FILES) {
+            console.warn(`difit: ${files.length - GitDiffParser.MAX_UNTRACKED_FILES} untracked file(s) beyond ${GitDiffParser.MAX_UNTRACKED_FILES} are not shown in the diff`);
+            files = files.slice(0, GitDiffParser.MAX_UNTRACKED_FILES);
+        }
+        const { execFile } = await import('child_process');
+        const synthesizeOne = (file) => {
+            const args = ['diff', '--no-index', '--no-ext-diff', '--color=never'];
+            if (ignoreWhitespace) {
+                args.push('-w');
+            }
+            if (contextLines !== undefined) {
+                args.push(`-U${contextLines}`);
+            }
+            args.push('--', '/dev/null', file);
+            // Async (non-blocking) so a hub fetch over many untracked files never
+            // stalls the event loop — other requests, SSE pings and watcher callbacks
+            // keep flowing while git runs.
+            return new Promise((resolve) => {
+                execFile('git', args, {
+                    cwd: this.repoPath,
+                    encoding: 'utf8',
+                    maxBuffer: GitDiffParser.UNTRACKED_DIFF_MAX_BUFFER,
+                }, (error, stdout) => {
+                    // `git diff --no-index` exits 1 when the files differ (always here,
+                    // since we diff against /dev/null) and still writes the diff to
+                    // stdout. Treat exit 1 as success; skip anything else (e.g. the file
+                    // vanished between listing and diffing) rather than failing the fetch.
+                    const code = error?.code;
+                    if (error && code !== 1) {
+                        resolve('');
+                        return;
+                    }
+                    resolve((stdout ?? '').toString());
+                });
+            });
+        };
+        const outputs = await mapWithConcurrency(files, GitDiffParser.UNTRACKED_DIFF_CONCURRENCY, synthesizeOne);
+        return outputs
+            .filter((output) => output.trim())
+            .map((output) => (output.endsWith('\n') ? output : `${output}\n`))
+            .join('');
+    }
+    parseUnifiedDiff(diffText) {
+        const files = [];
+        const fileBlocks = diffText.split(/^diff --git /m).slice(1);
+        for (const fileBlock of fileBlocks) {
+            const block = `diff --git ${fileBlock}`;
+            const file = this.parseFileBlock(block);
+            if (file) {
+                files.push(file);
+            }
+        }
+        return files;
+    }
+    getGitattributesSourceArgs(ref) {
+        if (ref === 'working' || ref === '.') {
+            return [];
+        }
+        if (ref === 'staged') {
+            return ['--cached'];
+        }
+        return ['--source', ref];
+    }
+    parseGitattributesGeneratedOutput(output) {
+        const generatedPaths = new Set();
+        const fields = output.split('\0');
+        for (let i = 0; i + 2 < fields.length; i += 3) {
+            const [path, attribute, value] = fields.slice(i, i + 3);
+            if (attribute === 'linguist-generated' && value === 'true') {
+                generatedPaths.add(path);
+            }
+        }
+        return generatedPaths;
+    }
+    async getGitattributesGeneratedPaths(filepaths, ref) {
+        if (filepaths.length === 0) {
+            return new Set();
+        }
+        const generatedPaths = new Set();
+        try {
+            for (let i = 0; i < filepaths.length; i += GitDiffParser.GITATTRIBUTES_CHECK_CHUNK_SIZE) {
+                const chunk = filepaths.slice(i, i + GitDiffParser.GITATTRIBUTES_CHECK_CHUNK_SIZE);
+                const output = await this.git.raw([
+                    'check-attr',
+                    '-z',
+                    ...this.getGitattributesSourceArgs(ref),
+                    'linguist-generated',
+                    '--',
+                    ...chunk,
+                ]);
+                if (typeof output !== 'string') {
+                    continue;
+                }
+                for (const path of this.parseGitattributesGeneratedOutput(output)) {
+                    generatedPaths.add(path);
+                }
+            }
+            return generatedPaths;
+        }
+        catch {
+            return new Set();
+        }
+    }
+    async markGitattributesGeneratedFiles(files, ref) {
+        const candidates = files.filter((file) => !file.isGenerated).map((file) => file.path);
+        const generatedPaths = await this.getGitattributesGeneratedPaths(candidates, ref);
+        if (generatedPaths.size === 0) {
+            return files;
+        }
+        return files.map((file) => generatedPaths.has(file.path) ? { ...file, isGenerated: true } : file);
+    }
+    decodeGitPath(rawPath) {
+        if (typeof rawPath !== 'string') {
+            return undefined;
+        }
+        const trimmed = rawPath.startsWith('"') && rawPath.endsWith('"') ? rawPath.slice(1, -1) : rawPath;
+        const gitPrefixes = ['a/', 'b/', 'c/', 'i/', 'w/'];
+        let withoutPrefix = trimmed;
+        for (const prefix of gitPrefixes) {
+            if (withoutPrefix.startsWith(prefix)) {
+                withoutPrefix = withoutPrefix.slice(prefix.length);
+                break;
+            }
+        }
+        const tabIndex = withoutPrefix.indexOf('\t');
+        if (tabIndex !== -1) {
+            withoutPrefix = withoutPrefix.slice(0, tabIndex);
+        }
+        if (withoutPrefix === '/dev/null') {
+            return undefined;
+        }
+        const bytes = [];
+        for (let i = 0; i < withoutPrefix.length; i++) {
+            const char = withoutPrefix[i];
+            if (char === '\\' && i + 1 < withoutPrefix.length) {
+                const next = withoutPrefix[i + 1];
+                if (/[0-7]/.test(next)) {
+                    let octal = next;
+                    let read = 1;
+                    while (read < 3 && i + 1 + read < withoutPrefix.length) {
+                        const candidate = withoutPrefix[i + 1 + read];
+                        if (!/[0-7]/.test(candidate)) {
+                            break;
+                        }
+                        octal += candidate;
+                        read++;
+                    }
+                    bytes.push(parseInt(octal, 8));
+                    i += read; // Skip consumed digits
+                    continue;
+                }
+                switch (next) {
+                    case 't':
+                        bytes.push(0x09);
+                        break;
+                    case 'n':
+                        bytes.push(0x0a);
+                        break;
+                    case 'r':
+                        bytes.push(0x0d);
+                        break;
+                    case 'b':
+                        bytes.push(0x08);
+                        break;
+                    case 'f':
+                        bytes.push(0x0c);
+                        break;
+                    case 'v':
+                        bytes.push(0x0b);
+                        break;
+                    case 'a':
+                        bytes.push(0x07);
+                        break;
+                    case '\\':
+                        bytes.push(0x5c);
+                        break;
+                    case '"':
+                        bytes.push(0x22);
+                        break;
+                    case ' ':
+                        bytes.push(0x20);
+                        break;
+                    default:
+                        bytes.push(...Buffer.from(next, 'utf8'));
+                        break;
+                }
+                i++; // Skip the escaped character
+                continue;
+            }
+            bytes.push(...Buffer.from(char, 'utf8'));
+        }
+        return Buffer.from(bytes).toString('utf8');
+    }
+    extractPathFromLine(line, prefix) {
+        if (!line?.startsWith(prefix)) {
+            return undefined;
+        }
+        return this.decodeGitPath(line.slice(prefix.length));
+    }
+    parseDiffHeaderPaths(headerLine) {
+        if (!headerLine.startsWith('diff --git ')) {
+            return null;
+        }
+        const raw = headerLine.slice('diff --git '.length);
+        const segments = [];
+        let current = '';
+        let inQuotes = false;
+        for (let i = 0; i < raw.length; i++) {
+            const char = raw[i];
+            const prevChar = i > 0 ? raw[i - 1] : null;
+            if (char === '"' && prevChar !== '\\') {
+                inQuotes = !inQuotes;
+                current += char;
+                continue;
+            }
+            if (char === ' ' && !inQuotes && prevChar !== '\\') {
+                if (current) {
+                    segments.push(current);
+                    current = '';
+                }
+                continue;
+            }
+            current += char;
+        }
+        if (current) {
+            segments.push(current);
+        }
+        if (segments.length !== 2) {
+            return null;
+        }
+        const [rawOldPath, rawNewPath] = segments;
+        return {
+            oldPath: this.decodeGitPath(rawOldPath),
+            newPath: this.decodeGitPath(rawNewPath),
+        };
+    }
+    parseFileBlock(block) {
+        const lines = block.split('\n');
+        const headerLine = lines[0];
+        const headerPaths = this.parseDiffHeaderPaths(headerLine);
+        const minusLine = lines.find((line) => line.startsWith('--- '));
+        const plusLine = lines.find((line) => line.startsWith('+++ '));
+        const renameFromLine = lines.find((line) => line.startsWith('rename from '));
+        const renameToLine = lines.find((line) => line.startsWith('rename to '));
+        const plusPath = this.extractPathFromLine(plusLine, '+++ ');
+        const minusPath = this.extractPathFromLine(minusLine, '--- ');
+        const renameFromPath = this.extractPathFromLine(renameFromLine, 'rename from ');
+        const renameToPath = this.extractPathFromLine(renameToLine, 'rename to ');
+        const newPath = renameToPath ?? plusPath ?? headerPaths?.newPath;
+        const oldPath = renameFromPath ?? minusPath ?? headerPaths?.oldPath ?? newPath;
+        if (!newPath) {
+            return null;
+        }
+        const path = newPath;
+        let status = 'modified';
+        // Check for new file mode (added files)
+        const newFileMode = lines.find((line) => line.startsWith('new file mode'));
+        const deletedFileMode = lines.find((line) => line.startsWith('deleted file mode'));
+        // Check for /dev/null which indicates added or deleted files
+        if (newFileMode || minusLine?.includes('/dev/null')) {
+            status = 'added';
+        }
+        else if (deletedFileMode || plusLine?.includes('/dev/null')) {
+            status = 'deleted';
+        }
+        else if (oldPath !== newPath) {
+            status = 'renamed';
+        }
+        // Common properties for all files
+        const baseFile = {
+            path,
+            oldPath: status === 'renamed' && oldPath !== newPath ? oldPath : undefined,
+            status,
+        };
+        // Parse chunks
+        const chunks = this.parseChunks(lines);
+        const { additions, deletions } = this.countLinesFromChunks(chunks);
+        return {
+            ...baseFile,
+            additions,
+            deletions,
+            chunks,
+            isGenerated: isGeneratedFile(path).isGenerated,
+        };
+    }
+    countLinesFromChunks(chunks) {
+        let additions = 0;
+        let deletions = 0;
+        for (const chunk of chunks) {
+            for (const line of chunk.lines) {
+                if (line.type === 'add')
+                    additions++;
+                else if (line.type === 'delete')
+                    deletions++;
+            }
+        }
+        return { additions, deletions };
+    }
+    parseChunks(lines) {
+        const chunks = [];
+        let currentChunk = null;
+        let oldLineNum = 0;
+        let newLineNum = 0;
+        for (const line of lines) {
+            if (line.startsWith('@@')) {
+                if (currentChunk) {
+                    chunks.push(currentChunk);
+                }
+                const match = line.match(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)/);
+                if (match) {
+                    const oldStart = parseInt(match[1]);
+                    const oldLines = parseInt(match[2] || '1');
+                    const newStart = parseInt(match[3]);
+                    const newLines = parseInt(match[4] || '1');
+                    oldLineNum = oldStart;
+                    newLineNum = newStart;
+                    currentChunk = {
+                        header: line,
+                        oldStart,
+                        oldLines,
+                        newStart,
+                        newLines,
+                        lines: [],
+                    };
+                }
+            }
+            else if (currentChunk &&
+                (line.startsWith('+') || line.startsWith('-') || line.startsWith(' '))) {
+                const type = line.startsWith('+') ? 'add' : line.startsWith('-') ? 'delete' : 'normal';
+                const diffLine = {
+                    type,
+                    content: line.slice(1),
+                    oldLineNumber: type !== 'add' ? oldLineNum : undefined,
+                    newLineNumber: type !== 'delete' ? newLineNum : undefined,
+                };
+                currentChunk.lines.push(diffLine);
+                if (type !== 'add')
+                    oldLineNum++;
+                if (type !== 'delete')
+                    newLineNum++;
+            }
+        }
+        if (currentChunk) {
+            chunks.push(currentChunk);
+        }
+        return chunks;
+    }
+    async validateCommit(commitish) {
+        try {
+            if (commitish === '.' || commitish === 'working' || commitish === 'staged') {
+                // For working directory or staging area, just check if we're in a git repo
+                await this.git.status();
+                return true;
+            }
+            await this.git.show([commitish, '--name-only']);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    parseStdinDiff(diffContent) {
+        const files = this.parseUnifiedDiff(diffContent);
+        return {
+            commit: 'stdin diff',
+            files,
+            isEmpty: files.length === 0,
+        };
+    }
+    async getBlobContent(filepath, ref) {
+        try {
+            // For working directory, read directly from filesystem
+            if (ref === 'working' || ref === '.') {
+                const fs = await import('fs');
+                if (filepath.length === 0) {
+                    throw new Error('Invalid file path');
+                }
+                const repositoryPath = fs.realpathSync(resolve(this.repoPath));
+                const repositoryRoot = `${repositoryPath}${sep}`;
+                const absolutePath = fs.realpathSync(resolve(repositoryRoot, filepath.replace(/\\/g, '/')));
+                if (!absolutePath.startsWith(repositoryRoot)) {
+                    throw new Error('File path outside repository');
+                }
+                return fs.readFileSync(absolutePath);
+            }
+            const normalizedFilepath = this.normalizeRepositoryRelativePath(filepath);
+            // For git refs, we need to use child_process to execute git cat-file
+            // to properly handle binary data
+            const { execFileSync } = await import('child_process');
+            // Handle staged files
+            if (ref === 'staged') {
+                // For staged files, use git show :filepath
+                // Using execFileSync to prevent command injection
+                const buffer = execFileSync('git', ['show', `:${normalizedFilepath}`], {
+                    cwd: this.repoPath,
+                    maxBuffer: 10 * 1024 * 1024, // 10MB limit
+                });
+                return buffer;
+            }
+            // First, get the blob hash for the file at the given ref
+            // Using execFileSync to prevent command injection
+            const blobHash = execFileSync('git', ['rev-parse', `${ref}:${normalizedFilepath}`], {
+                cwd: this.repoPath,
+                encoding: 'utf8',
+                maxBuffer: 10 * 1024 * 1024,
+            }).trim();
+            // Then use git cat-file to get the raw binary content
+            // Increase maxBuffer to handle large files (default is 1024*1024 = 1MB)
+            const buffer = execFileSync('git', ['cat-file', 'blob', blobHash], {
+                cwd: this.repoPath,
+                maxBuffer: 10 * 1024 * 1024, // 10MB limit
+            });
+            return buffer;
+        }
+        catch (error) {
+            // Check if it's a buffer size error
+            if (error instanceof Error &&
+                (error.message.includes('ENOBUFS') || error.message.includes('maxBuffer'))) {
+                throw new Error(`Image file ${filepath} is too large to display (over 10MB limit)`);
+            }
+            if (error instanceof Error &&
+                (error.message === 'Invalid file path' || error.message === 'File path outside repository')) {
+                throw error;
+            }
+            throw new Error(`Failed to get blob content for ${filepath} at ${ref}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async getLineCount(filepath, ref) {
+        const buffer = await this.getBlobContent(filepath, ref);
+        let count = 0;
+        for (let i = 0; i < buffer.length; i++) {
+            if (buffer[i] === 0x0a)
+                count++; // newline byte
+        }
+        // If file doesn't end with newline, the last line still counts
+        if (buffer.length > 0 && buffer[buffer.length - 1] !== 0x0a) {
+            count++;
+        }
+        return count;
+    }
+    extractHeaderLines(buffer, maxLines = 20) {
+        const headerSlice = buffer.subarray(0, GitDiffParser.GENERATED_HEADER_SCAN_BYTES);
+        return headerSlice.toString('utf8').split('\n').slice(0, maxLines);
+    }
+    async getGeneratedStatus(filepath, ref) {
+        const pathResult = isGeneratedFile(filepath);
+        if (pathResult.isGenerated) {
+            return { isGenerated: true, source: 'path' };
+        }
+        const gitattributesResult = await this.getGitattributesGeneratedPaths([filepath], ref);
+        if (gitattributesResult.has(filepath)) {
+            return { isGenerated: true, source: 'path' };
+        }
+        try {
+            const buffer = await this.getBlobContent(filepath, ref);
+            const lines = this.extractHeaderLines(buffer);
+            const result = isGeneratedFile(filepath, () => lines);
+            return { isGenerated: result.isGenerated, source: 'content' };
+        }
+        catch {
+            return { isGenerated: false, source: 'path' };
+        }
+    }
+    async resolveCommitish(commitish) {
+        const now = Date.now();
+        const cached = this.resolvedCommitCache.get(commitish);
+        if (cached && cached.expiresAt > now) {
+            return cached.value;
+        }
+        const hash = await this.git.revparse([commitish]);
+        const value = hash.substring(0, 7);
+        this.resolvedCommitCache.set(commitish, {
+            value,
+            expiresAt: now + GitDiffParser.RESOLVED_COMMIT_CACHE_TTL_MS,
+        });
+        return value;
+    }
+    clearResolvedCommitCache() {
+        this.resolvedCommitCache.clear();
+    }
+    async getDefaultBranch() {
+        try {
+            // Try to get the default branch from origin/HEAD
+            const result = await this.git.raw(['symbolic-ref', 'refs/remotes/origin/HEAD']);
+            // Result will be like "refs/remotes/origin/main\n"
+            const match = result.trim().match(/refs\/remotes\/origin\/(.+)/);
+            if (match) {
+                return match[1];
+            }
+        }
+        catch {
+            // If origin/HEAD is not set, fall back to common default branches
+            const commonDefaults = ['main', 'master'];
+            const branchResult = await this.git.branchLocal();
+            const branchNames = Object.keys(branchResult.branches);
+            for (const defaultName of commonDefaults) {
+                if (branchNames.includes(defaultName)) {
+                    return defaultName;
+                }
+            }
+        }
+        return null;
+    }
+    async getOriginDefaultBranch() {
+        try {
+            const result = await this.git.raw(['symbolic-ref', 'refs/remotes/origin/HEAD']);
+            const match = result.trim().match(/refs\/remotes\/origin\/(.+)/);
+            if (match) {
+                return `origin/${match[1]}`;
+            }
+        }
+        catch {
+            const commonDefaults = ['main', 'master'];
+            for (const defaultName of commonDefaults) {
+                try {
+                    await this.git.raw([
+                        'show-ref',
+                        '--verify',
+                        '--quiet',
+                        `refs/remotes/origin/${defaultName}`,
+                    ]);
+                    return `origin/${defaultName}`;
+                }
+                catch {
+                    // Ignore missing refs and continue checking common defaults.
+                }
+            }
+        }
+        return null;
+    }
+    async getCurrentBranch() {
+        try {
+            const name = (await this.git.raw(['rev-parse', '--abbrev-ref', 'HEAD'])).trim();
+            return name && name !== 'HEAD' ? name : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async getPgitParent() {
+        const branch = await this.getCurrentBranch();
+        if (!branch)
+            return null;
+        let value;
+        try {
+            value = (await this.git.raw(['config', `branch.${branch}.pgit-parent`])).trim();
+        }
+        catch {
+            // git config exits non-zero when the key is absent
+            return null;
+        }
+        if (!value)
+            return null;
+        // Only use the recorded parent if it actually resolves locally; a stale or
+        // missing ref would make the current-branch merge-base diff fail, so fall
+        // back to null (→ client lands on Uncommitted + a "pick a base" banner).
+        try {
+            await this.git.raw(['rev-parse', '--verify', '--quiet', `${value}^{commit}`]);
+            return value;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Best-effort parent for a stacked/task branch when no pgit parent is recorded:
+     * the local branch whose tip is the *nearest* ancestor of HEAD (smallest
+     * `<branch>..HEAD` commit distance, excluding the current branch). For a branch
+     * cut from another local branch (e.g. `task_X_child` off `task_X`) this recovers
+     * the real parent; git stores no such link otherwise. Heuristic — the caller
+     * marks it inferred and keeps it overridable.
+     */
+    async getNearestAncestorBranch(currentBranch) {
+        let candidates;
+        try {
+            const out = await this.git.raw(['branch', '--merged', 'HEAD', '--format=%(refname:short)']);
+            candidates = out
+                .split('\n')
+                .map((s) => s.trim())
+                .filter((b) => b && b !== currentBranch && !b.startsWith('('));
+        }
+        catch {
+            return null;
+        }
+        const measured = await Promise.all(candidates.map(async (branch) => {
+            try {
+                const dist = Number.parseInt((await this.git.raw(['rev-list', '--count', `${branch}..HEAD`])).trim(), 10);
+                return Number.isFinite(dist) && dist > 0 ? { branch, dist } : null;
+            }
+            catch {
+                return null;
+            }
+        }));
+        let best = null;
+        for (const m of measured) {
+            if (!m)
+                continue;
+            if (!best || m.dist < best.dist || (m.dist === best.dist && m.branch < best.branch))
+                best = m;
+        }
+        return best?.branch ?? null;
+    }
+    async getCommitsInRange(base, target) {
+        const normalizeRef = (ref) => ref === '.' || ref === 'staged' || ref === 'working' ? 'HEAD' : ref;
+        const normTarget = normalizeRef(target);
+        const normBase = base ? normalizeRef(base) : undefined;
+        const result = normBase
+            ? await this.git.log([`${normBase}..${normTarget}`, '--max-count=200'])
+            : await this.git.log([normTarget, '--max-count=50']);
+        return result.all.map((commit) => ({
+            hash: commit.hash,
+            shortHash: commit.hash.substring(0, 7),
+            message: commit.message,
+            body: commit.body || undefined,
+            author: commit.author_name || undefined,
+            date: commit.date || undefined,
+        }));
+    }
+    async getRevisionOptions(currentBase, currentTarget) {
+        const [branchResult, logResult, defaultBranch, originDefaultBranch, currentBranch, pgitParent] = await Promise.all([
+            this.git.branchLocal(),
+            this.git.log({ maxCount: 20 }),
+            this.getDefaultBranch(),
+            this.getOriginDefaultBranch(),
+            this.getCurrentBranch(),
+            this.getPgitParent(),
+        ]);
+        const branches = Object.entries(branchResult.branches).map(([name, data]) => ({
+            name,
+            current: data.current,
+        }));
+        // Sort branches: default branch first, then current branch, then alphabetically
+        branches.sort((a, b) => {
+            if (defaultBranch) {
+                if (a.name === defaultBranch)
+                    return -1;
+                if (b.name === defaultBranch)
+                    return 1;
+            }
+            if (a.current && !b.current)
+                return -1;
+            if (!a.current && b.current)
+                return 1;
+            return a.name.localeCompare(b.name);
+        });
+        const commits = logResult.all.map((commit) => ({
+            hash: commit.hash,
+            shortHash: commit.hash.substring(0, 7),
+            message: commit.message,
+            body: commit.body || undefined,
+            author: commit.author_name || undefined,
+            date: commit.date || undefined,
+        }));
+        // Resolve HEAD and HEAD^ to actual commit hashes if they're being used
+        let resolvedBase;
+        let resolvedTarget;
+        if (currentBase && !['working', 'staged', '.'].includes(currentBase)) {
+            try {
+                resolvedBase = await this.resolveCommitish(currentBase);
+            }
+            catch {
+                // If resolution fails, leave undefined
+            }
+        }
+        if (currentTarget && !['working', 'staged', '.'].includes(currentTarget)) {
+            try {
+                resolvedTarget = await this.resolveCommitish(currentTarget);
+            }
+            catch {
+                // If resolution fails, leave undefined
+            }
+        }
+        // Effective base for the "Current branch" view. Prefer the explicit pgit
+        // parent; otherwise fall back to the origin default branch, but only when the
+        // current branch actually diverges from it (a merge-base exists and isn't
+        // HEAD itself) — so a branch sitting on/at the default branch doesn't produce
+        // an empty "branch diff". When neither yields a base, the client prompts.
+        let branchBase;
+        let branchBaseSource;
+        if (pgitParent) {
+            branchBase = pgitParent;
+            branchBaseSource = 'pgit';
+        }
+        else {
+            // Prefer the nearest local ancestor branch (recovers a stacked/task
+            // branch's real parent); fall back to the origin default branch only when
+            // no local parent exists.
+            const nearest = await this.getNearestAncestorBranch(currentBranch);
+            if (nearest) {
+                branchBase = nearest;
+                branchBaseSource = 'branch';
+            }
+            else if (originDefaultBranch) {
+                try {
+                    const [mergeBase, head] = await Promise.all([
+                        this.git.raw(['merge-base', originDefaultBranch, 'HEAD']).then((s) => s.trim()),
+                        this.git.raw(['rev-parse', 'HEAD']).then((s) => s.trim()),
+                    ]);
+                    if (mergeBase && mergeBase !== head) {
+                        branchBase = originDefaultBranch;
+                        branchBaseSource = 'origin-default';
+                    }
+                }
+                catch {
+                    // No merge-base (unrelated histories) or the default ref is missing —
+                    // leave branchBase undefined so the client falls back to a prompt.
+                }
+            }
+        }
+        return {
+            branches,
+            commits,
+            originDefaultBranch: originDefaultBranch ?? undefined,
+            resolvedBase,
+            resolvedTarget,
+            currentBranch: currentBranch ?? undefined,
+            pgitParent: pgitParent ?? undefined,
+            branchBase,
+            branchBaseSource,
+        };
+    }
+}