pi-fovea 0.21.2 → 0.22.0

package/README.md

@@ -259,6 +259,17 @@ partners, and decays with wall-clock time. Edits that resist symbol-level
 location fall back to the old file-node seed. New files, deletions, renames,
 untracked paths, and oversized diffs all take that path.
 
+Historical co-change is a decaying **heat prior**, never a permanent graph edge.
+It counts up to 400 first-parent integration boundaries: merge net changes count
+once, not again through their constituent commits. Explicit `fixup!`/`squash!`
+followups join only uniquely resolved older subjects in that window. Time,
+author, shared issue numbers, and unlabeled "forgot this" do not group work.
+Boundaries are not proof of a semantic feature (release merges can mix work).
+Aggregates above 24 tracked files emit no pairs but retain directional touch
+counts; two distinct retained units are needed for a pair, three for expectations.
+Raw history caching includes shallow-state identity; recency still applies at use.
+Focus, sketch, and the structural diffusion operator remain unchanged.
+
 The obligation ledger keeps the list. Every cascade merges its per-file
 residual mass into a session epoch. Entries stay until evidence moves them. A
 read marks `inspected`. An edit marks `changed` and raises the generation. A

package/dist/cli.mjs

@@ -46,7 +46,7 @@ var Semaphore = class {
   waiters = [];
   async run(fn) {
     if (this.active >= this.limit) {
-      await new Promise((resolve4) => this.waiters.push(resolve4));
+      await new Promise((resolve5) => this.waiters.push(resolve5));
     }
     this.active++;
     try {
@@ -58,7 +58,7 @@ var Semaphore = class {
   }
 };
 var spawnGate = new Semaphore(SPAWN_CONCURRENCY);
-var yieldToLoop = () => new Promise((resolve4) => setImmediate(resolve4));
+var yieldToLoop = () => new Promise((resolve5) => setImmediate(resolve5));
 var forEachChunked = async (items, batchSize, fn) => {
   for (let i = 0; i < items.length; i++) {
     if (i > 0 && i % batchSize === 0) await yieldToLoop();
@@ -69,7 +69,7 @@ var forEachChunked = async (items, batchSize, fn) => {
 // src/core/git.ts
 var GIT_TIMEOUT = 15e3;
 var gitOut = async (root, args, opts = {}) => spawnGate.run(
-  () => new Promise((resolve4) => {
+  () => new Promise((resolve5) => {
     execFile(
       "git",
       ["-C", root, ...args],
@@ -80,10 +80,10 @@ var gitOut = async (root, args, opts = {}) => spawnGate.run(
       },
       (error, stdout) => {
         if (error) {
-          resolve4(void 0);
+          resolve5(void 0);
           return;
         }
-        resolve4(stdout);
+        resolve5(stdout);
       }
     );
   })
@@ -1014,9 +1014,9 @@ var hasAstGrepAsync = () => {
   const pending = availabilityInflight.get(bin);
   if (pending) return pending;
   const probe = spawnGate.run(
-    () => new Promise((resolve4) => {
+    () => new Promise((resolve5) => {
       execFile2(bin, ["--version"], { encoding: "utf8", timeout: 5e3, maxBuffer: 1024 * 1024 }, (error) => {
-        resolve4(!error);
+        resolve5(!error);
       });
     })
   ).then((ok) => {
@@ -1035,30 +1035,30 @@ var drainExtractionFailures = () => failures.splice(0, failures.length);
 var RUN_TIMEOUT = 12e4;
 var RUN_MAX_BUFFER = 16 * 1024 * 1024;
 var run = async (args, cwd) => spawnGate.run(
-  () => new Promise((resolve4) => {
+  () => new Promise((resolve5) => {
     execFile2(
       binary(),
       args,
       { cwd, encoding: "utf8", timeout: RUN_TIMEOUT, maxBuffer: RUN_MAX_BUFFER },
       (error, stdout, stderr) => {
         if (error && (error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" || error.code === "E2BIG")) {
-          resolve4({ ok: false, stdout: "", split: true });
+          resolve5({ ok: false, stdout: "", split: true });
           return;
         }
         if (error && typeof error.code !== "number") {
-          resolve4({ ok: false, stdout: "", split: false });
+          resolve5({ ok: false, stdout: "", split: false });
           return;
         }
         const status = error && typeof error.code === "number" ? error.code : 0;
         if (status !== 0) {
           if ((stderr ?? "").trim()) {
-            resolve4({ ok: false, stdout: "", split: false });
+            resolve5({ ok: false, stdout: "", split: false });
             return;
           }
-          resolve4({ ok: true, stdout: "", split: false });
+          resolve5({ ok: true, stdout: "", split: false });
           return;
         }
-        resolve4({ ok: true, stdout: stdout ?? "", split: false });
+        resolve5({ ok: true, stdout: stdout ?? "", split: false });
       }
     );
   })
@@ -1150,9 +1150,9 @@ var hasRuleScan = () => {
   const pending = scanSupportInflight.get(bin);
   if (pending) return pending;
   const probe = spawnGate.run(
-    () => new Promise((resolve4) => {
+    () => new Promise((resolve5) => {
       execFile2(bin, ["scan", "--help"], { encoding: "utf8", timeout: 5e3, maxBuffer: 1024 * 1024 }, (error) => {
-        resolve4(!error);
+        resolve5(!error);
       });
     })
   ).then((ok) => {
@@ -1186,7 +1186,7 @@ var materializeRuleFile = (rules) => {
   return pending;
 };
 var scanChunk = (rulePath, files, cwd) => spawnGate.run(
-  () => new Promise((resolve4) => {
+  () => new Promise((resolve5) => {
     const child = spawn(
       binary(),
       ["scan", "--rule", rulePath, "--json=stream", ...files],
@@ -1201,7 +1201,7 @@ var scanChunk = (rulePath, files, cwd) => spawnGate.run(
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve4(value);
+      resolve5(value);
     };
     const accept = (line) => {
       if (!line || parseFailed) return;
@@ -1979,12 +1979,12 @@ var buildJoinIndex = (sites, resolveOccurrence) => {
 import { createHash } from "node:crypto";
 import { mkdir, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { dirname as dirname2, join as joinPath } from "node:path";
+import { dirname as dirname2, resolve as resolve3, join as joinPath } from "node:path";
 var LOG_COMMITS = 400;
-var MAX_FILES_PER_COMMIT = 24;
+var MAX_FILES_PER_UNIT = 24;
 var MIN_SHARED = 2;
 var MAX_PAIRS_PER_FILE = 16;
-var COCHANGE_CACHE_VERSION = 3;
+var COCHANGE_CACHE_VERSION = 4;
 var EXPECTATION_MIN_SUPPORT = 3;
 var WILSON_Z_95 = 1.96;
 var DAY_MS = 864e5;
@@ -2040,63 +2040,116 @@ var coChangeHistory = async (root, filesInGraph, now = Date.now()) => {
   if (!head) return /* @__PURE__ */ new Map();
   const prefix = await gitPrefix(root);
   if (prefix === void 0) return /* @__PURE__ */ new Map();
+  const shallowPath = await gitOut(root, ["rev-parse", "--git-path", "shallow"]);
+  if (shallowPath === void 0) return /* @__PURE__ */ new Map();
+  let shallowText = "";
+  try {
+    shallowText = await readFile2(resolve3(root, shallowPath.trim()), "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT") return /* @__PURE__ */ new Map();
+  }
+  const shallow = new Set(shallowText.trim().split(/\s+/));
   const tracked = new Set(filesInGraph);
-  const key = createHash("sha1").update(`v${COCHANGE_CACHE_VERSION}\0`).update([...tracked].sort().join("\n")).digest("hex").slice(0, 12);
+  const key = createHash("sha1").update(`v${COCHANGE_CACHE_VERSION}\0`).update(shallowText).update(JSON.stringify([...tracked].sort())).digest("hex").slice(0, 12);
   const cp = cachePath(root);
   try {
     const cached = JSON.parse(await readFile2(cp, "utf8"));
     if (cached.v === COCHANGE_CACHE_VERSION && cached.head === head && cached.key === key && Number.isInteger(cached.commits) && Array.isArray(cached.pairs)) return groupPairs(cached.pairs, cached.commits);
   } catch {
   }
-  const log = await gitOut(root, ["log", "--format=%x00%ct", "--numstat", "-n", String(LOG_COMMITS), "--no-renames", "--diff-filter=AMR", "--", "."]) ?? "";
+  const log = await gitOut(root, [
+    "log",
+    "--first-parent",
+    "--diff-merges=first-parent",
+    "--root",
+    "--format=%x00FOVEA%x00%H%x00%P%x00%ct%x00%s%x00",
+    "--name-status",
+    "-z",
+    "-n",
+    String(LOG_COMMITS),
+    "--no-renames",
+    "--no-ext-diff",
+    "--no-textconv",
+    "--no-relative",
+    "--no-notes",
+    "--no-show-signature",
+    "--no-color",
+    head,
+    "--"
+  ], { maxBuffer: 16 * 1024 * 1024 });
+  if (log === void 0) return /* @__PURE__ */ new Map();
+  const units = [];
+  const fields = log.split("\0");
+  let cursor = 0;
+  while (cursor < fields.length) {
+    if (fields[cursor] === "") {
+      cursor++;
+      continue;
+    }
+    if (fields[cursor++] !== "FOVEA") return /* @__PURE__ */ new Map();
+    const hash = fields[cursor++];
+    const parents = fields[cursor++];
+    const seconds = Number(fields[cursor++]);
+    const subject = fields[cursor++];
+    if (!hash || parents === void 0 || subject === void 0 || !Number.isFinite(seconds) || fields[cursor++] !== "") return /* @__PURE__ */ new Map();
+    const files = /* @__PURE__ */ new Set();
+    let first = true;
+    while (cursor < fields.length && fields[cursor] !== "") {
+      let status = fields[cursor++];
+      if (first) {
+        if (!status.startsWith("\n")) return /* @__PURE__ */ new Map();
+        status = status.slice(1);
+        first = false;
+      }
+      let file = fields[cursor++];
+      if (!/^[AMDTUXB]$/.test(status) || !file) return /* @__PURE__ */ new Map();
+      if ((status === "A" || status === "M") && file.startsWith(prefix)) {
+        file = file.slice(prefix.length);
+        if (tracked.has(file)) files.add(file);
+      }
+    }
+    if (!shallow.has(hash)) units.push({ subject, merge: parents.includes(" "), ts: seconds * 1e3, files });
+  }
+  const subjects = /* @__PURE__ */ new Map();
+  units.forEach((unit, i) => {
+    const hits = subjects.get(unit.subject) ?? [];
+    hits.push(i);
+    subjects.set(unit.subject, hits);
+  });
+  const consumed = /* @__PURE__ */ new Set();
+  units.forEach((unit, i) => {
+    if (unit.merge) return;
+    const target = /^(?:fixup!|squash!) (.+)$/.exec(unit.subject)?.[1];
+    if (!target) return;
+    const hits = subjects.get(target);
+    if (hits?.length !== 1 || hits[0] <= i) return;
+    const parent = units[hits[0]];
+    for (const file of unit.files) parent.files.add(file);
+    parent.ts = Math.max(parent.ts, unit.ts);
+    consumed.add(i);
+  });
   const pairCount = /* @__PURE__ */ new Map();
   const pairLast = /* @__PURE__ */ new Map();
   const touchCount = /* @__PURE__ */ new Map();
   let commits = 0;
-  let inCommit = false;
-  let cur = [];
-  let curTs = 0;
-  const flush = () => {
-    if (!inCommit) {
-      cur = [];
-      return;
-    }
-    inCommit = false;
-    const fs = [...new Set(cur)].filter((f) => tracked.has(f)).sort();
-    cur = [];
+  units.forEach((unit, index) => {
+    if (consumed.has(index)) return;
+    commits++;
+    const fs = [...unit.files].sort();
     for (const f of fs) touchCount.set(f, (touchCount.get(f) ?? 0) + 1);
-    if (fs.length < 2 || fs.length > MAX_FILES_PER_COMMIT) return;
+    if (fs.length < 2 || fs.length > MAX_FILES_PER_UNIT) return;
     for (let i = 0; i < fs.length; i++) {
       for (let j = i + 1; j < fs.length; j++) {
-        const k = `${fs[i]}|${fs[j]}`;
+        const k = JSON.stringify([fs[i], fs[j]]);
         pairCount.set(k, (pairCount.get(k) ?? 0) + 1);
-        if (curTs) pairLast.set(k, Math.max(pairLast.get(k) ?? 0, curTs));
+        pairLast.set(k, Math.max(pairLast.get(k) ?? 0, unit.ts));
       }
     }
-  };
-  for (const line of log.split("\n")) {
-    if (!line.trim()) continue;
-    if (line.includes("\0")) {
-      flush();
-      inCommit = true;
-      commits++;
-      curTs = 0;
-      const ts = Number(line.slice(line.indexOf("\0") + 1).trim());
-      if (Number.isFinite(ts)) curTs = ts * 1e3;
-      continue;
-    }
-    const tab = line.indexOf("	");
-    if (tab < 0) continue;
-    const secondTab = line.indexOf("	", tab + 1);
-    if (secondTab < 0) continue;
-    const file = gitRelativePath(line.slice(secondTab + 1).trim(), prefix);
-    if (file) cur.push(file);
-  }
-  flush();
+  });
   const scored = [];
   for (const [k, n] of pairCount) {
     if (n < MIN_SHARED) continue;
-    const [a, b] = k.split("|");
+    const [a, b] = JSON.parse(k);
     const nA = touchCount.get(a) ?? 0;
     const nB = touchCount.get(b) ?? 0;
     const w = scorePair(n, nA, nB);
@@ -2231,7 +2284,7 @@ var epochStats = (session) => {
 // src/core/state.ts
 import { createHash as createHash4 } from "node:crypto";
 import { stat as stat2 } from "node:fs/promises";
-import { isAbsolute as isAbsolute2, join as join3, relative as relative2, resolve as resolve3, sep as sep2 } from "node:path";
+import { isAbsolute as isAbsolute2, join as join3, relative as relative2, resolve as resolve4, sep as sep2 } from "node:path";
 
 // src/core/build.ts
 import { createHash as createHash3, randomUUID } from "node:crypto";
@@ -4775,8 +4828,8 @@ var ensureState = (root, opts = {}) => {
 };
 var relativeRequest = (root, input) => {
   const raw = input.startsWith("@") ? input.slice(1) : input;
-  const rootPath = resolve3(root);
-  const absolute = isAbsolute2(raw) ? resolve3(raw) : resolve3(rootPath, raw);
+  const rootPath = resolve4(root);
+  const absolute = isAbsolute2(raw) ? resolve4(raw) : resolve4(rootPath, raw);
   const rel = relative2(rootPath, absolute);
   if (!rel || rel === "." || rel === ".." || rel.startsWith(`..${sep2}`) || isAbsolute2(rel)) return void 0;
   return rel.split(sep2).join("/");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-fovea",
-  "version": "0.21.2",
+  "version": "0.22.0",
   "description": "Token-budgeted repo mapping for agent sessions: foveated heat diffusion over a cross-language code graph, with progressive disclosure.",
   "type": "module",
   "license": "MIT",

package/src/core/cochange.ts

@@ -3,11 +3,11 @@
 // Heat diffusion over the static graph says what is near what BY
 // CONSTRUCTION (imports, calls, routes, literals). Joint git history says
 // what ACTUALLY moves together — the signal `impact` needs when two files
-// share no static edge but are always edited in the same commits.
+// share no static edge but repeatedly move in the same integration units.
 //
 // Under the all-in heat model that signal is a seeded field, not permanent
 // structure. Each (a, b) pair records directional touch counts plus the
-// committer timestamp of the most recent joint commit; at wall-clock `now`
+// latest member timestamp of the most recent joint unit; at wall-clock `now`
 // its heat contribution is
 //
 //     w = w0(count, jaccard) * 2^(-ageDays / COCHANGE_HALF_LIFE_DAYS)
@@ -25,15 +25,15 @@
 import { createHash } from "node:crypto";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { dirname, join as joinPath } from "node:path";
+import { dirname, resolve, join as joinPath } from "node:path";
 import { envInt } from "./asyncutil.js";
-import { gitHead, gitOut, gitPrefix, gitRelativePath } from "./git.js";
+import { gitHead, gitOut, gitPrefix } from "./git.js";
 
 const LOG_COMMITS = 400;
-const MAX_FILES_PER_COMMIT = 24; // squashed monsters carry no pair signal
+const MAX_FILES_PER_UNIT = 24; // oversized integration units carry no pair signal
 const MIN_SHARED = 2;            // a single collision is noise
-const MAX_PAIRS_PER_FILE = 16;   // cap each file's history fan-out
-const COCHANGE_CACHE_VERSION = 3;
+const MAX_PAIRS_PER_FILE = 16;   // union of endpoint top-16 selections, not a hard degree cap
+const COCHANGE_CACHE_VERSION = 4;
 const EXPECTATION_MIN_SUPPORT = 3;
 const WILSON_Z_95 = 1.96;
 const DAY_MS = 86_400_000;
@@ -47,15 +47,15 @@ export interface CoChangePartner {
   partner: string;
   /** Base conductance from count + Jaccard, BEFORE recency decay. */
   w: number;
-  /** Committer epoch ms of the most recent joint commit of this pair. */
+  /** Latest member committer epoch ms of this pair's most recent joint unit. */
   lastTs: number;
-  /** Joint commits for this directional pair in the bounded history window. */
+  /** Joint integration units for this directional pair in the bounded window. */
   n_ij?: number;
-  /** Commits in the window that touch the source file. */
+  /** Integration units in the window that touch the source file. */
   n_i?: number;
-  /** Commits in the window that touch the partner file. */
+  /** Integration units in the window that touch the partner file. */
   n_j?: number;
-  /** Total commits observed in the bounded history window. */
+  /** Total integration units observed in the bounded history window. */
   N?: number;
 }
 
@@ -172,7 +172,7 @@ const cachePath = (root: string): string =>
   joinPath(tmpdir(), `pi-fovea-cochange-${createHash("sha1").update(root).digest("hex").slice(0, 16)}.json`);
 
 // coChangeHistory returns, for every tracked file, its past co-change partners
-// with base conductance and the most recent joint commit time. filesInGraph
+// with base conductance and the most recent joint unit time. filesInGraph
 // restricts to files we actually track, so vendored churn is excluded.
 export const coChangeHistory = async (
   root: string,
@@ -183,10 +183,21 @@ export const coChangeHistory = async (
   if (!head) return new Map(); // not a git repo
   const prefix = await gitPrefix(root);
   if (prefix === undefined) return new Map();
+  // Deepening can change evidence without changing HEAD. Do not mistake a
+  // shallow boundary's synthetic root diff for an integrated feature.
+  const shallowPath = await gitOut(root, ["rev-parse", "--git-path", "shallow"]);
+  if (shallowPath === undefined) return new Map();
+  let shallowText = "";
+  try { shallowText = await readFile(resolve(root, shallowPath.trim()), "utf8"); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") return new Map();
+  }
+  const shallow = new Set(shallowText.trim().split(/\s+/));
   const tracked = new Set(filesInGraph);
   const key = createHash("sha1")
     .update(`v${COCHANGE_CACHE_VERSION}\0`)
-    .update([...tracked].sort().join("\n"))
+    .update(shallowText)
+    .update(JSON.stringify([...tracked].sort()))
     .digest("hex")
     .slice(0, 12);
   const cp = cachePath(root);
@@ -198,60 +209,95 @@ export const coChangeHistory = async (
     ) return groupPairs(cached.pairs, cached.commits);
   } catch { /* recompute */ }
 
-  const log = await gitOut(root, ["log", "--format=%x00%ct", "--numstat", "-n", String(LOG_COMMITS), "--no-renames", "--diff-filter=AMR", "--", "."]) ?? "";
-  // numstat lines: "<added>\t<deleted>\t<file>"; each commit begins with a NUL
-  // line carrying its committer timestamp (%ct).
+  // No pathspec: history simplification could remove integration boundaries
+  // or make subroot denominators differ from the repository's observations.
+  const log = await gitOut(root, [
+    "log", "--first-parent", "--diff-merges=first-parent", "--root",
+    "--format=%x00FOVEA%x00%H%x00%P%x00%ct%x00%s%x00", "--name-status", "-z",
+    "-n", String(LOG_COMMITS), "--no-renames", "--no-ext-diff", "--no-textconv",
+    "--no-relative", "--no-notes", "--no-show-signature", "--no-color", head, "--",
+  ], { maxBuffer: 16 * 1024 * 1024 });
+  if (log === undefined) return new Map(); // never cache a failed/partial scan
+  type Unit = { subject: string; merge: boolean; ts: number; files: Set<string> };
+  const units: Unit[] = [];
+  const fields = log.split("\0");
+  let cursor = 0;
+  while (cursor < fields.length) {
+    if (fields[cursor] === "") { cursor++; continue; }
+    if (fields[cursor++] !== "FOVEA") return new Map();
+    const hash = fields[cursor++];
+    const parents = fields[cursor++];
+    const seconds = Number(fields[cursor++]);
+    const subject = fields[cursor++];
+    if (!hash || parents === undefined || subject === undefined || !Number.isFinite(seconds)
+      || fields[cursor++] !== "") return new Map();
+    const files = new Set<string>();
+    let first = true;
+    while (cursor < fields.length && fields[cursor] !== "") {
+      let status = fields[cursor++]!;
+      if (first) {
+        if (!status.startsWith("\n")) return new Map();
+        status = status.slice(1);
+        first = false;
+      }
+      let file = fields[cursor++];
+      if (!/^[AMDTUXB]$/.test(status) || !file) return new Map();
+      // NUL names are literal, including tabs, newlines and backslashes.
+      // Filter here, not in Git: --diff-filter drops empty observations and
+      // lets the scan walk arbitrarily far looking for 400 matching diffs.
+      if ((status === "A" || status === "M") && file.startsWith(prefix)) {
+        file = file.slice(prefix.length);
+        if (tracked.has(file)) files.add(file);
+      }
+    }
+    if (!shallow.has(hash)) units.push({ subject, merge: parents.includes(" "), ts: seconds * 1000, files });
+  }
+
+  // Match against the entire bounded window before mutating anything. An
+  // exact unique older subject is evidence; proximity and issue IDs are not.
+  const subjects = new Map<string, number[]>();
+  units.forEach((unit, i) => {
+    const hits = subjects.get(unit.subject) ?? [];
+    hits.push(i);
+    subjects.set(unit.subject, hits);
+  });
+  const consumed = new Set<number>();
+  units.forEach((unit, i) => {
+    if (unit.merge) return;
+    const target = /^(?:fixup!|squash!) (.+)$/.exec(unit.subject)?.[1];
+    if (!target) return;
+    const hits = subjects.get(target);
+    if (hits?.length !== 1 || hits[0]! <= i) return;
+    const parent = units[hits[0]!]!;
+    for (const file of unit.files) parent.files.add(file);
+    parent.ts = Math.max(parent.ts, unit.ts);
+    consumed.add(i);
+  });
+
   const pairCount = new Map<string, number>();
   const pairLast = new Map<string, number>();
   const touchCount = new Map<string, number>();
-  let commits = 0;
-  let inCommit = false;
-  let cur: string[] = [];
-  let curTs = 0;
-  const flush = (): void => {
-    if (!inCommit) {
-      cur = [];
-      return;
-    }
-    inCommit = false;
-    const fs = [...new Set(cur)].filter((f) => tracked.has(f)).sort();
-    cur = [];
-    // Directional denominators include solo touches and oversized commits;
-    // only pair production observes the monster-commit fan-out bound.
+  let commits = 0; // cache field retained: now independent integration units
+  units.forEach((unit, index) => {
+    if (consumed.has(index)) return;
+    commits++;
+    const fs = [...unit.files].sort();
+    // Solo and oversized units still contribute truthful denominators.
     for (const f of fs) touchCount.set(f, (touchCount.get(f) ?? 0) + 1);
-    if (fs.length < 2 || fs.length > MAX_FILES_PER_COMMIT) return;
+    if (fs.length < 2 || fs.length > MAX_FILES_PER_UNIT) return;
     for (let i = 0; i < fs.length; i++) {
       for (let j = i + 1; j < fs.length; j++) {
-        const k = `${fs[i]}|${fs[j]}`;
+        const k = JSON.stringify([fs[i], fs[j]]);
         pairCount.set(k, (pairCount.get(k) ?? 0) + 1);
-        if (curTs) pairLast.set(k, Math.max(pairLast.get(k) ?? 0, curTs));
+        pairLast.set(k, Math.max(pairLast.get(k) ?? 0, unit.ts));
       }
     }
-  };
-  for (const line of log.split("\n")) {
-    if (!line.trim()) continue;
-    if (line.includes("\0")) {
-      flush();
-      inCommit = true;
-      commits++;
-      curTs = 0;
-      const ts = Number(line.slice(line.indexOf("\0") + 1).trim());
-      if (Number.isFinite(ts)) curTs = ts * 1000;
-      continue;
-    }
-    const tab = line.indexOf("\t");
-    if (tab < 0) continue;
-    const secondTab = line.indexOf("\t", tab + 1);
-    if (secondTab < 0) continue;
-    const file = gitRelativePath(line.slice(secondTab + 1).trim(), prefix);
-    if (file) cur.push(file);
-  }
-  flush();
+  });
 
   const scored: CachedPair[] = [];
   for (const [k, n] of pairCount) {
     if (n < MIN_SHARED) continue;
-    const [a, b] = k.split("|") as [string, string];
+    const [a, b] = JSON.parse(k) as [string, string];
     const nA = touchCount.get(a) ?? 0;
     const nB = touchCount.get(b) ?? 0;
     const w = scorePair(n, nA, nB);

package/src/core/git.ts

@@ -92,7 +92,7 @@ export const gitPrefix = async (root: string): Promise<string | undefined> => {
   return prefix;
 };
 
-export const gitRelativePath = (path: string, prefix: string): string | undefined => {
+const gitRelativePath = (path: string, prefix: string): string | undefined => {
   const normalized = path.replace(/\\/g, "/");
   if (!prefix) return normalized;
   return normalized.startsWith(prefix) ? normalized.slice(prefix.length) : undefined;