pi-files-widget-overlay 0.3.0

package/src/comment.ts

@@ -0,0 +1,6 @@
+import type { CommentPayload } from "./viewer";
+
+export function formatCommentMessage(payload: CommentPayload, comment: string): string {
+  const subject = payload.isDiff ? `In the diff for \`${payload.relPath}\`` : `In \`${payload.relPath}\``;
+  return `${subject} (${payload.lineRange}):\n\`\`\`${payload.ext}\n${payload.selectedText}\n\`\`\`\n\nComment: ${comment}\n`;
+}

package/src/constants.ts

@@ -0,0 +1,31 @@
+export const MAX_TREE_DEPTH = 6;
+export const POLL_INTERVAL_MS = 3000;
+export const MAX_LINE_COUNT_BYTES = 256 * 1024;
+export const LINE_COUNT_BATCH_SIZE = 8;
+export const LINE_COUNT_BATCH_DELAY_MS = 30;
+export const SCAN_BATCH_SIZE = 4;
+export const SCAN_BATCH_DELAY_MS = 25;
+export const SAFE_MODE_ENTRY_THRESHOLD = 200;
+
+export const DEFAULT_VIEWER_HEIGHT = 29;
+export const DEFAULT_BROWSER_HEIGHT = 28;
+
+export const MIN_PANEL_HEIGHT = 5;
+export const MAX_VIEWER_HEIGHT = 50;
+export const MAX_BROWSER_HEIGHT = 40;
+export const INITIAL_PANEL_HEIGHT_RATIO = 0.85;
+export const OVERLAY_MAX_HEIGHT_RATIO = 0.95;
+export const OVERLAY_MAX_HEIGHT = "95%";
+
+export function getResponsivePanelHeight(
+  fallback: number,
+  maximum: number,
+  chromeRows: number,
+  terminalRows = process.stdout.rows,
+  ratio = INITIAL_PANEL_HEIGHT_RATIO
+): number {
+  if (!terminalRows || terminalRows <= 0) return fallback;
+  return Math.min(maximum, Math.max(MIN_PANEL_HEIGHT, Math.floor(terminalRows * ratio) - chromeRows));
+}
+
+export const SEARCH_SCROLL_OFFSET = 3;

package/src/file-tree.ts

@@ -0,0 +1,321 @@
+import { lstatSync, realpathSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+import { MAX_TREE_DEPTH } from "./constants";
+import type { DiffStats, FileNode, FlatNode } from "./types";
+
+const collator = new Intl.Collator(undefined, { sensitivity: "base" });
+
+function safeRealPathSync(path: string): string {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+
+function getPathInfo(path: string): { isDirectory: boolean; isSymlink: boolean; realPath?: string } {
+  try {
+    const linkStat = lstatSync(path);
+    const isSymlink = linkStat.isSymbolicLink();
+    const targetStat = isSymlink ? statSync(path) : linkStat;
+    return {
+      isDirectory: targetStat.isDirectory(),
+      isSymlink,
+      realPath: targetStat.isDirectory() ? safeRealPathSync(path) : undefined,
+    };
+  } catch {
+    return { isDirectory: false, isSymlink: false };
+  }
+}
+
+function compareNodes(a: FileNode, b: FileNode): number {
+  if (a.isDirectory !== b.isDirectory) {
+    return a.isDirectory ? -1 : 1;
+  }
+  return collator.compare(a.name, b.name);
+}
+
+function shouldIgnoreSegment(segment: string, ignored: Set<string>): boolean {
+  return ignored.has(segment);
+}
+
+export function sortChildren(node: FileNode): void {
+  if (!node.children || node.children.length === 0) return;
+  node.children.sort(compareNodes);
+}
+
+function sortTree(node: FileNode): void {
+  sortChildren(node);
+  if (node.children) {
+    for (const child of node.children) {
+      if (child.isDirectory) {
+        sortTree(child);
+      }
+    }
+  }
+}
+
+export function updateTreeStats(root: FileNode | null): void {
+  if (!root) return;
+
+  function traverse(node: FileNode): {
+    totalLines: number;
+    totalAdditions: number;
+    totalDeletions: number;
+    lineCountComplete: boolean;
+    hasChanges: boolean;
+  } {
+    if (!node.isDirectory) {
+      const totalLines = node.lineCount ?? 0;
+      const totalAdditions = node.diffStats?.additions ?? 0;
+      const totalDeletions = node.diffStats?.deletions ?? 0;
+      const lineCountComplete = node.lineCount !== undefined;
+      const hasChanges = Boolean(node.gitStatus || node.agentModified);
+      return { totalLines, totalAdditions, totalDeletions, lineCountComplete, hasChanges };
+    }
+
+    let totalLines = 0;
+    let totalAdditions = 0;
+    let totalDeletions = 0;
+    let lineCountComplete = true;
+    let hasChanges = false;
+
+    if (node.children) {
+      for (const child of node.children) {
+        const stats = traverse(child);
+        totalLines += stats.totalLines;
+        totalAdditions += stats.totalAdditions;
+        totalDeletions += stats.totalDeletions;
+        if (!stats.lineCountComplete) {
+          lineCountComplete = false;
+        }
+        if (stats.hasChanges) {
+          hasChanges = true;
+        }
+      }
+    }
+
+    node.totalLines = totalLines;
+    node.totalAdditions = totalAdditions;
+    node.totalDeletions = totalDeletions;
+    node.lineCountComplete = lineCountComplete;
+    node.hasChangedChildren = hasChanges;
+
+    return { totalLines, totalAdditions, totalDeletions, lineCountComplete, hasChanges };
+  }
+
+  traverse(root);
+}
+
+export function buildFileTreeFromPaths(
+  cwd: string,
+  filePaths: string[],
+  gitStatus: Map<string, string>,
+  diffStats: Map<string, DiffStats>,
+  ignored: Set<string>,
+  agentModified: Set<string>
+): FileNode {
+  const root: FileNode = {
+    name: ".",
+    path: cwd,
+    isDirectory: true,
+    realPath: safeRealPathSync(cwd),
+    children: [],
+    expanded: true,
+    hasChangedChildren: false,
+  };
+
+  const directoryMap = new Map<string, FileNode>();
+  directoryMap.set("", root);
+  const seenFiles = new Set<string>();
+
+  function addTruncatedDirectoryPath(parts: string[]): void {
+    let current = root;
+    let relPath = "";
+
+    for (let i = 0; i < MAX_TREE_DEPTH; i++) {
+      const part = parts[i];
+      if (!part || shouldIgnoreSegment(part, ignored)) return;
+      relPath = relPath ? `${relPath}/${part}` : part;
+
+      let dirNode = directoryMap.get(relPath);
+      if (!dirNode) {
+        const depth = i + 1;
+        dirNode = {
+          name: part,
+          path: join(cwd, relPath),
+          isDirectory: true,
+          realPath: safeRealPathSync(join(cwd, relPath)),
+          parent: current,
+          children: i === MAX_TREE_DEPTH - 1 ? undefined : [],
+          expanded: depth < 1,
+          hasChangedChildren: false,
+        };
+        directoryMap.set(relPath, dirNode);
+        current.children?.push(dirNode);
+      }
+      current = dirNode;
+    }
+  }
+  for (const rawPath of filePaths) {
+    let normalized = rawPath.trim();
+    if (!normalized) continue;
+    if (normalized.startsWith("./")) {
+      normalized = normalized.slice(2);
+    }
+    normalized = normalized.replace(/\\/g, "/");
+
+    const parts = normalized.split("/").filter(Boolean);
+    if (parts.length === 0) continue;
+    const dirDepth = parts.length - 1;
+    const isChangedPath = gitStatus.has(normalized) || gitStatus.has(`${normalized}/`);
+    if (dirDepth > MAX_TREE_DEPTH && !isChangedPath) {
+      // Keep a navigable prefix for deep tracked paths instead of dropping their
+      // top-level directories from the initial Git tree.
+      addTruncatedDirectoryPath(parts);
+      continue;
+    }
+
+    let current = root;
+    let relPath = "";
+    let skip = false;
+
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      if (shouldIgnoreSegment(part, ignored)) {
+        skip = true;
+        break;
+      }
+      relPath = relPath ? `${relPath}/${part}` : part;
+      let dirNode = directoryMap.get(relPath);
+      if (!dirNode) {
+        const depth = i + 1;
+        dirNode = {
+          name: part,
+          path: join(cwd, relPath),
+          isDirectory: true,
+          realPath: safeRealPathSync(join(cwd, relPath)),
+          parent: current,
+          children: [],
+          expanded: depth < 1,
+          hasChangedChildren: false,
+        };
+        directoryMap.set(relPath, dirNode);
+        current.children?.push(dirNode);
+      }
+      current = dirNode;
+    }
+
+    if (skip) continue;
+
+    const fileName = parts[parts.length - 1];
+    if (shouldIgnoreSegment(fileName, ignored)) continue;
+
+    const fileRelPath = parts.join("/");
+    if (seenFiles.has(fileRelPath)) continue;
+
+    const filePath = join(cwd, fileRelPath);
+    const fileGitStatus = gitStatus.get(fileRelPath) ?? gitStatus.get(`${fileRelPath}/`);
+    const fileDiffStats = diffStats.get(fileRelPath);
+    const existingDir = directoryMap.get(fileRelPath);
+
+    if (existingDir) {
+      if (fileGitStatus) {
+        existingDir.gitStatus = fileGitStatus;
+      }
+      if (fileDiffStats) {
+        existingDir.diffStats = fileDiffStats;
+      }
+      continue;
+    }
+
+    const pathInfo = getPathInfo(filePath);
+    const isDirEntry = normalized.endsWith("/") || pathInfo.isDirectory;
+    if (isDirEntry) {
+      const depth = parts.length;
+      const dirNode: FileNode = {
+        name: fileName,
+        path: filePath,
+        isDirectory: true,
+        isSymlink: pathInfo.isSymlink,
+        realPath: pathInfo.realPath ?? safeRealPathSync(filePath),
+        parent: current,
+        children: pathInfo.isSymlink ? undefined : [],
+        expanded: depth < 1,
+        hasChangedChildren: false,
+        gitStatus: fileGitStatus,
+        diffStats: fileDiffStats,
+      };
+      directoryMap.set(fileRelPath, dirNode);
+      current.children?.push(dirNode);
+      continue;
+    }
+
+    seenFiles.add(fileRelPath);
+
+    current.children?.push({
+      name: fileName,
+      path: filePath,
+      isDirectory: false,
+      isSymlink: pathInfo.isSymlink,
+      parent: current,
+      gitStatus: fileGitStatus,
+      agentModified: agentModified.has(filePath),
+      diffStats: fileDiffStats,
+    });
+  }
+
+  sortTree(root);
+  updateTreeStats(root);
+  return root;
+}
+
+export function getIgnoredNames(): Set<string> {
+  return new Set([
+    "node_modules",
+    ".git",
+    ".DS_Store",
+    "__pycache__",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".next",
+    ".nuxt",
+    "dist",
+    "build",
+    ".venv",
+    "venv",
+    ".env",
+    "coverage",
+    ".nyc_output",
+    ".turbo",
+    ".cache",
+  ]);
+}
+
+export function flattenTree(
+  node: FileNode,
+  depth = 0,
+  isRoot = true,
+  includeCollapsed = false
+): FlatNode[] {
+  const result: FlatNode[] = [];
+
+  // Skip the root "." node itself, just process its children
+  if (isRoot && node.name === ".") {
+    for (const child of node.children || []) {
+      result.push(...flattenTree(child, 0, false, includeCollapsed));
+    }
+    return result;
+  }
+
+  result.push({ node, depth });
+
+  if (node.isDirectory && node.children && (includeCollapsed || node.expanded)) {
+    for (const child of node.children) {
+      result.push(...flattenTree(child, depth + 1, false, includeCollapsed));
+    }
+  }
+
+  return result;
+}

package/src/file-viewer.ts

@@ -0,0 +1,181 @@
+import { getLanguageFromPath, getMarkdownTheme, highlightCode, type Theme } from "@earendil-works/pi-coding-agent";
+import { Markdown, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { execSync } from "node:child_process";
+import { readFileSync, statSync } from "node:fs";
+
+import { isGitRepo } from "./git";
+import { isMarkdownPath, stripLeadingEmptyLines } from "./utils";
+
+type UnifiedDiffLine = {
+  kind: "add" | "remove" | "context";
+  lineNumber: number;
+  text: string;
+};
+
+export type RenderedLines = {
+  lines: string[];
+  rowGroups: number[];
+  logicalLines: string[];
+};
+
+function parseUnifiedDiff(diffOutput: string): UnifiedDiffLine[] {
+  const lines: UnifiedDiffLine[] = [];
+  let oldLine = 0;
+  let newLine = 0;
+  let inHunk = false;
+
+  for (const rawLine of diffOutput.split("\n")) {
+    const hunk = rawLine.match(/^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+    if (hunk) {
+      oldLine = Number(hunk[1]);
+      newLine = Number(hunk[2]);
+      inHunk = true;
+      continue;
+    }
+    if (!inHunk || rawLine.startsWith("\")) continue;
+
+    const text = rawLine.slice(1);
+    switch (rawLine[0]) {
+      case " ":
+        lines.push({ kind: "context", lineNumber: newLine, text });
+        oldLine++;
+        newLine++;
+        break;
+      case "-":
+        lines.push({ kind: "remove", lineNumber: oldLine++, text });
+        break;
+      case "+":
+        lines.push({ kind: "add", lineNumber: newLine++, text });
+        break;
+    }
+  }
+
+  return lines;
+}
+
+function wrapUnifiedDiffLine(line: string, width: number, wordWrap: boolean): string[] {
+  if (!wordWrap) return [line];
+  const separatorIndex = line.indexOf("│");
+  if (separatorIndex === -1 || width <= 0) return wrapTextWithAnsi(line, width);
+
+  const prefix = line.slice(0, separatorIndex + 2);
+  const contentWidth = Math.max(width - visibleWidth(prefix), 1);
+  const content = line.slice(separatorIndex + 2);
+  const continuationPrefix = prefix.replace(/\x1b\[[0-?]*[ -/]*[@-~]|\d/g, token => token.startsWith("\x1b") ? token : " ");
+  return wrapTextWithAnsi(content, contentWidth).map((chunk, index) =>
+    (index === 0 ? prefix : continuationPrefix) + chunk
+  );
+}
+
+function renderUnifiedDiff(diffOutput: string, width: number, theme: Theme, wordWrap: boolean): RenderedLines {
+  const parsed = parseUnifiedDiff(diffOutput);
+  if (parsed.length === 0) {
+    const lines = stripLeadingEmptyLines(diffOutput.split("\n"));
+    return { lines, rowGroups: lines.map((_, index) => index), logicalLines: lines };
+  }
+
+  const lineNumberWidth = String(Math.max(...parsed.map(line => line.lineNumber))).length;
+  const lines: string[] = [];
+  const rowGroups: number[] = [];
+  const logicalLines: string[] = [];
+  for (const [group, { kind, lineNumber, text }] of parsed.entries()) {
+    const marker = kind === "add" ? "+" : kind === "remove" ? "-" : " ";
+    const color =
+      kind === "add" ? "toolDiffAdded" : kind === "remove" ? "toolDiffRemoved" : "toolDiffContext";
+    const rendered = theme.fg(color, `${marker} ${String(lineNumber).padStart(lineNumberWidth)} │ ${text}`);
+    logicalLines.push(rendered);
+    const wrapped = wrapUnifiedDiffLine(rendered, width, wordWrap);
+    lines.push(...wrapped);
+    rowGroups.push(...wrapped.map(() => group));
+  }
+  return { lines, rowGroups, logicalLines };
+}
+export interface LoadedFileContent extends RenderedLines {
+  renderedMarkdown: boolean;
+}
+
+export interface LoadFileContentOptions {
+  cwd: string;
+  diffMode: boolean;
+  hasChanges: boolean;
+  width?: number;
+  renderMarkdown: boolean;
+  wordWrap: boolean;
+}
+
+export function loadFileContent(
+  filePath: string,
+  { cwd, diffMode, hasChanges, width, renderMarkdown, wordWrap }: LoadFileContentOptions,
+  theme: Theme
+): LoadedFileContent {
+  const isMarkdown = isMarkdownPath(filePath);
+  const termWidth = width || process.stdout.columns || 80;
+
+  try {
+    try {
+      if (statSync(filePath).isDirectory()) {
+        return { lines: ["Directory selected - expand it in the file tree instead of opening it."], rowGroups: [0], logicalLines: ["Directory selected - expand it in the file tree instead of opening it."], renderedMarkdown: false };
+      }
+    } catch {
+      // Ignore stat errors and fall through to normal handling
+    }
+
+    if (diffMode && hasChanges && isGitRepo(cwd)) {
+      try {
+        // Try different diff strategies
+        let diffOutput = "";
+
+        // First try: unstaged changes
+        const unstaged = execSync(`git diff --no-color -- "${filePath}"`, { cwd, encoding: "utf-8", timeout: 10000, stdio: "pipe" });
+        if (unstaged.trim()) {
+          diffOutput = unstaged;
+        } else {
+          // Second try: staged changes
+          const staged = execSync(`git diff --no-color --cached -- "${filePath}"`, { cwd, encoding: "utf-8", timeout: 10000, stdio: "pipe" });
+          if (staged.trim()) {
+            diffOutput = staged;
+          } else {
+            // Third try: diff against HEAD (for new files that are staged)
+            const headDiff = execSync(`git diff --no-color HEAD -- "${filePath}"`, { cwd, encoding: "utf-8", timeout: 10000, stdio: "pipe" });
+            if (headDiff.trim()) {
+              diffOutput = headDiff;
+            }
+          }
+        }
+
+        if (!diffOutput.trim()) {
+          return { lines: ["No diff available - file may be untracked or unchanged"], rowGroups: [0], logicalLines: ["No diff available - file may be untracked or unchanged"], renderedMarkdown: false };
+        }
+
+        return { ...renderUnifiedDiff(diffOutput, termWidth, theme, wordWrap), renderedMarkdown: false };
+      } catch (e: any) {
+        return { lines: [`Diff error: ${e.message}`], rowGroups: [0], logicalLines: [`Diff error: ${e.message}`], renderedMarkdown: false };
+      }
+    }
+
+    if (isMarkdown && renderMarkdown) {
+      const markdown = new Markdown(readFileSync(filePath, "utf-8"), 0, 0, getMarkdownTheme());
+      const lines = markdown.render(wordWrap ? termWidth : 10_000).map(line => line.trimEnd());
+      return { lines, rowGroups: lines.map((_, index) => index), logicalLines: lines, renderedMarkdown: true };
+    }
+
+    const raw = readFileSync(filePath, "utf-8");
+    const lineNumberWidth = Math.max(4, String(raw.split("\n").length).length);
+    const contentWidth = Math.max(1, termWidth - lineNumberWidth - 3);
+    const highlighted = highlightCode(raw, getLanguageFromPath(filePath));
+    const lines: string[] = [];
+    const rowGroups: number[] = [];
+    for (const [group, line] of highlighted.entries()) {
+      const lineNumber = theme.fg("dim", String(group + 1).padStart(lineNumberWidth));
+      const continuation = " ".repeat(lineNumberWidth);
+      const wrapped = wordWrap ? wrapTextWithAnsi(line, contentWidth) : [line];
+      lines.push(...wrapped.map((segment, segmentIndex) =>
+        `${segmentIndex === 0 ? lineNumber : continuation}${theme.fg("borderMuted", " │ ")}${segment}`
+      ));
+      rowGroups.push(...wrapped.map(() => group));
+    }
+    return { lines, rowGroups, logicalLines: raw.split("\n"), renderedMarkdown: false };
+  } catch (e: any) {
+    return { lines: [`Error loading file: ${e.message}`], rowGroups: [0], logicalLines: [`Error loading file: ${e.message}`], renderedMarkdown: false };
+  }
+}

package/src/git.ts

@@ -0,0 +1,129 @@
+import { execSync } from "node:child_process";
+
+import type { DiffStats } from "./types";
+
+const GIT_MAX_BUFFER = 32 * 1024 * 1024;
+
+type GitErrorReporter = (operation: string) => void;
+
+export function isGitRepo(cwd: string): boolean {
+  try {
+    execSync("git rev-parse --is-inside-work-tree", { cwd, encoding: "utf-8", timeout: 2000, stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Path of `cwd` relative to the repository top-level (e.g. "app/"), or "" when
+ * `cwd` is the top-level itself. `git status --porcelain` reports paths relative
+ * to the repository root, while `git ls-files` (and this widget's node keys) are
+ * relative to `cwd` — this prefix lets us translate between the two.
+ */
+function getGitPathPrefix(cwd: string): string {
+  try {
+    return execSync("git rev-parse --show-prefix", { cwd, encoding: "utf-8", timeout: 2000, stdio: "pipe" }).trim();
+  } catch {
+    return "";
+  }
+}
+
+/** Convert a repo-root-relative path to a cwd-relative one; null if outside cwd. */
+function stripPathPrefix(filePath: string, prefix: string): string | null {
+  if (!prefix) return filePath;
+  if (filePath.startsWith(prefix)) return filePath.slice(prefix.length);
+  return null;
+}
+
+export function getGitStatus(cwd: string, options: { includeIgnored?: boolean } = {}, onError?: GitErrorReporter): Map<string, string> {
+  const status = new Map<string, string>();
+  try {
+    const flags = ["--porcelain"];
+    if (options.includeIgnored !== false) flags.push("--ignored");
+    const prefix = getGitPathPrefix(cwd);
+    const output = execSync(`git status ${flags.join(" ")}`, { cwd, encoding: "utf-8", timeout: 5000, stdio: "pipe", maxBuffer: GIT_MAX_BUFFER });
+    for (const line of output.split("\n")) {
+      if (line.length < 3) continue;
+      const statusCode = line.slice(0, 2).trim() || "?";
+      const filePath = stripPathPrefix(line.slice(3), prefix)?.replace(/\/+$/, "");
+      if (filePath === null || !filePath) continue;
+      status.set(filePath, statusCode);
+    }
+  } catch {
+    onError?.("Git status");
+  }
+  return status;
+}
+
+export function getGitFileList(cwd: string, onError?: GitErrorReporter): string[] {
+  const files = new Set<string>();
+  try {
+    const tracked = execSync("git ls-files -z", { cwd, encoding: "utf-8", timeout: 5000, stdio: "pipe", maxBuffer: GIT_MAX_BUFFER });
+    for (const entry of tracked.split("\0")) {
+      if (entry) files.add(entry);
+    }
+  } catch {
+    onError?.("tracked file list");
+  }
+
+  try {
+    const prefix = getGitPathPrefix(cwd);
+    const statusOutput = execSync("git status --porcelain -uall -z", { cwd, encoding: "utf-8", timeout: 5000, stdio: "pipe", maxBuffer: GIT_MAX_BUFFER });
+    const entries = statusOutput.split("\0");
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if (!entry) continue;
+      const statusCode = entry.slice(0, 2).trim();
+      let filePath = entry.slice(3);
+      if ((statusCode.startsWith("R") || statusCode.startsWith("C")) && entries[i + 1]) {
+        i += 1;
+        filePath = entries[i];
+      } else if (filePath.includes(" -> ")) {
+        filePath = filePath.split(" -> ").pop() || filePath;
+      }
+      const relPath = filePath ? stripPathPrefix(filePath, prefix)?.replace(/\/+$/, "") : null;
+      if (relPath) files.add(relPath);
+    }
+  } catch {
+    onError?.("Git status");
+  }
+
+  return Array.from(files);
+}
+
+export function getGitBranch(cwd: string): string {
+  try {
+    return execSync("git branch --show-current", { cwd, encoding: "utf-8", timeout: 2000, stdio: "pipe" }).trim();
+  } catch {
+    return "";
+  }
+}
+
+export function getGitDiffStats(cwd: string, onError?: GitErrorReporter): Map<string, DiffStats> {
+  const stats = new Map<string, DiffStats>();
+  try {
+    // Get diff stats for modified files. --relative keeps paths relative to cwd
+    // (and scoped to it) so they match the widget's cwd-relative node keys even
+    // when cwd is a subdirectory of the repository.
+    const output = execSync("git diff --relative --numstat HEAD", { cwd, encoding: "utf-8", timeout: 5000, stdio: "pipe", maxBuffer: GIT_MAX_BUFFER });
+    for (const line of output.split("\n")) {
+      const parts = line.split("\t");
+      if (parts.length < 3) continue;
+      stats.set(parts[2], { additions: parseInt(parts[0], 10) || 0, deletions: parseInt(parts[1], 10) || 0 });
+    }
+
+    const stagedOutput = execSync("git diff --relative --numstat --cached", { cwd, encoding: "utf-8", timeout: 5000, stdio: "pipe", maxBuffer: GIT_MAX_BUFFER });
+    for (const line of stagedOutput.split("\n")) {
+      const parts = line.split("\t");
+      if (parts.length < 3) continue;
+      const additions = parseInt(parts[0], 10) || 0;
+      const deletions = parseInt(parts[1], 10) || 0;
+      const existing = stats.get(parts[2]);
+      stats.set(parts[2], existing ? { additions: existing.additions + additions, deletions: existing.deletions + deletions } : { additions, deletions });
+    }
+  } catch {
+    onError?.("Git diff statistics");
+  }
+  return stats;
+}