@gethmy/harness 1.0.0

package/src/git-diff-stat.ts

@@ -0,0 +1,148 @@
+import { execFileSync } from "node:child_process";
+import { log } from "./log.js";
+
+const TAG = "git-diff-stat";
+
+/** Default cap on the number of changed-file paths captured per episode. */
+export const MAX_CHANGED_FILES = 30;
+
+export interface DiffStat {
+  /** Changed file paths (authoritative — derived from the diff itself). */
+  files: string[];
+  /** Total lines added across the diff (best-effort, may be 0). */
+  insertions: number;
+  /** Total lines removed across the diff (best-effort, may be 0). */
+  deletions: number;
+}
+
+/**
+ * Parse `git diff --numstat` output into a changed-file list + churn totals.
+ * Pure — exported for testing. numstat lines look like:
+ *   `12\t3\tpath/to/file.ts`
+ * Binary files report `-\t-\t<path>`; those contribute 0 churn but still count
+ * as a changed file. The file list is capped at `maxFiles`.
+ */
+export function parseNumstat(
+  raw: string,
+  maxFiles = MAX_CHANGED_FILES,
+): DiffStat {
+  const files: string[] = [];
+  let insertions = 0;
+  let deletions = 0;
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    const parts = trimmed.split("\t");
+    if (parts.length < 3) continue;
+    const [add, del, ...pathParts] = parts;
+    const path = pathParts.join("\t");
+    if (!path) continue;
+    const addN = Number.parseInt(add, 10);
+    const delN = Number.parseInt(del, 10);
+    if (Number.isFinite(addN)) insertions += addN;
+    if (Number.isFinite(delN)) deletions += delN;
+    if (files.length < maxFiles) files.push(path);
+  }
+  return { files, insertions, deletions };
+}
+
+/** Per-file add/remove counts derived from a unified diff. */
+export interface DiffFileSummary {
+  path: string;
+  added: number;
+  removed: number;
+}
+
+/**
+ * Parse a unified diff (the text from `git diff`) into a per-file
+ * added/removed line tally. Pure — works on whatever diff string the caller
+ * already has, so no second git invocation is needed (and it handles diffs
+ * stitched together from multiple commits in local-review mode). Used by
+ * `formatDiffSummary` to build the compact stat block for the review prompt
+ * (#348) instead of inlining the full diff.
+ */
+export function summarizeUnifiedDiff(diff: string): {
+  files: DiffFileSummary[];
+  totalAdded: number;
+  totalRemoved: number;
+} {
+  const files: DiffFileSummary[] = [];
+  let current: DiffFileSummary | null = null;
+  let totalAdded = 0;
+  let totalRemoved = 0;
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("diff --git")) {
+      // "diff --git a/<path> b/<path>" — prefer the new (b/) path.
+      const m = line.match(/ b\/(.+)$/);
+      current = {
+        path: m ? m[1] : line.slice("diff --git ".length),
+        added: 0,
+        removed: 0,
+      };
+      files.push(current);
+      continue;
+    }
+    if (!current) continue;
+    // Skip the file headers (+++ / ---) — only count actual content lines.
+    if (line.startsWith("+++") || line.startsWith("---")) continue;
+    if (line.startsWith("+")) {
+      current.added++;
+      totalAdded++;
+    } else if (line.startsWith("-")) {
+      current.removed++;
+      totalRemoved++;
+    }
+  }
+  return { files, totalAdded, totalRemoved };
+}
+
+/**
+ * Render a compact `git diff --stat`-style summary from a unified diff: a
+ * changed-file list with per-file churn plus a totals line. The review agent
+ * reads the actual file contents itself (Read/Grep + read-only `git diff`), so
+ * this map is all the prompt needs — far cheaper than inlining up to 80K chars
+ * of diff (#348). The file list is capped at `maxFiles`.
+ */
+export function formatDiffSummary(diff: string, maxFiles = 100): string {
+  const trimmed = diff.trim();
+  if (!trimmed || diff === "(unable to retrieve diff)") {
+    return trimmed ? diff : "(no diff available)";
+  }
+  const { files, totalAdded, totalRemoved } = summarizeUnifiedDiff(diff);
+  if (files.length === 0) return "(no file changes detected in diff)";
+  const shown = files.slice(0, maxFiles);
+  const lines = shown.map((f) => ` ${f.path} | +${f.added} -${f.removed}`);
+  if (files.length > maxFiles) {
+    lines.push(` ... and ${files.length - maxFiles} more file(s)`);
+  }
+  lines.push(
+    ` ${files.length} file(s) changed, ${totalAdded} insertion(s)(+), ${totalRemoved} deletion(s)(-)`,
+  );
+  return lines.join("\n");
+}
+
+/**
+ * Capture a changed-file list + churn for the work on a branch versus its base,
+ * via `git diff --numstat`. Best-effort and guarded: returns null on any
+ * failure so callers can fall back to tracked paths (#272). Never throws.
+ */
+export function captureDiffStat(
+  worktreePath: string,
+  baseBranch: string,
+  maxFiles = MAX_CHANGED_FILES,
+): DiffStat | null {
+  try {
+    const raw = execFileSync(
+      "git",
+      ["diff", "--numstat", `${baseBranch}...HEAD`],
+      { cwd: worktreePath, encoding: "utf-8", timeout: 30_000 },
+    );
+    return parseNumstat(raw, maxFiles);
+  } catch (err) {
+    log.warn(TAG, "git diff --numstat failed", {
+      event: "diff_stat_failed",
+      error: err instanceof Error ? err.message : String(err),
+    });
+    return null;
+  }
+}