@stigmer/runner 3.1.2 → 3.1.4

package/src/shared/filereview/__tests__/events.test.ts

@@ -138,6 +138,111 @@ describe("buildCapturedFileChange", () => {
     }
   });
 
+  it("stamps display line counts from inline sides", () => {
+    const modify = buildCapturedFileChange({
+      id: "fc-counts",
+      pathBefore: "src/a.ts",
+      pathAfter: "src/a.ts",
+      kind: FileChangeKind.MODIFY,
+      captureClass: FileCaptureClass.GIT_TRACKED,
+      before: "one\ntwo\n",
+      after: "one\nTWO\nthree\n",
+    });
+    expect(modify.linesAdded).toBe(2);
+    expect(modify.linesRemoved).toBe(1);
+
+    const add = buildCapturedFileChange({
+      id: "fc-add-counts",
+      pathBefore: "",
+      pathAfter: "src/new.ts",
+      kind: FileChangeKind.ADD,
+      captureClass: FileCaptureClass.GIT_TRACKED,
+      after: "a\nb\nc\n",
+    });
+    expect(add.linesAdded).toBe(3);
+    expect(add.linesRemoved).toBe(0);
+  });
+
+  it("prefers explicit lineCounts (the CAS substrate's capture-time counts) over inline counting", () => {
+    const change = buildCapturedFileChange({
+      id: "fc-explicit",
+      pathBefore: "notes.txt",
+      pathAfter: "notes.txt",
+      kind: FileChangeKind.MODIFY,
+      captureClass: FileCaptureClass.NON_GIT_CAS,
+      before: {
+        kind: "ref", sha256: "s1", storageKey: "k1", sizeBytes: 10, isBinary: false,
+      },
+      after: {
+        kind: "ref", sha256: "s2", storageKey: "k2", sizeBytes: 12, isBinary: false,
+      },
+      lineCounts: { linesAdded: 7, linesRemoved: 4 },
+    });
+    expect(change.linesAdded).toBe(7);
+    expect(change.linesRemoved).toBe(4);
+  });
+
+  it("leaves counts at zero when a side is not countable (binary / ref without explicit counts / withheld)", () => {
+    // Binary side: no text diff exists, so no count may claim one does.
+    const binary = binaryChange("bin");
+    expect(binary.linesAdded).toBe(0);
+    expect(binary.linesRemoved).toBe(0);
+
+    // Ref side without explicit counts: the bytes are not here to count.
+    const ref = buildCapturedFileChange({
+      id: "fc-ref",
+      pathBefore: "big.txt",
+      pathAfter: "big.txt",
+      kind: FileChangeKind.MODIFY,
+      captureClass: FileCaptureClass.NON_GIT_CAS,
+      before: { kind: "ref", sha256: "s1", storageKey: "k1", sizeBytes: 9, isBinary: false },
+      after: { kind: "ref", sha256: "s2", storageKey: "k2", sizeBytes: 9, isBinary: false },
+    });
+    expect(ref.linesAdded).toBe(0);
+    expect(ref.linesRemoved).toBe(0);
+
+    // Secret-withheld: content-less by design.
+    const withheld = unavailableChange("secret");
+    expect(withheld.linesAdded).toBe(0);
+    expect(withheld.linesRemoved).toBe(0);
+  });
+
+  it("keeps line counts out of the enforcement digests (informational only)", () => {
+    const common = {
+      id: "fc-digest",
+      pathBefore: "a",
+      pathAfter: "a",
+      kind: FileChangeKind.MODIFY,
+      captureClass: FileCaptureClass.NON_GIT_CAS,
+      before: {
+        kind: "ref", sha256: "s1", storageKey: "k1", sizeBytes: 3, isBinary: false,
+      },
+      after: {
+        kind: "ref", sha256: "s2", storageKey: "k2", sizeBytes: 3, isBinary: false,
+      },
+    } as const;
+    // Identical content with and without counts must be digest-indistinguishable —
+    // structurally guaranteed (FileDigestInput excludes counts), locked here so a
+    // future refactor cannot silently fold display data into enforcement.
+    const withoutCounts = buildCapturedFileChange(common);
+    const withCounts = buildCapturedFileChange({
+      ...common,
+      lineCounts: { linesAdded: 5, linesRemoved: 2 },
+    });
+    expect(withCounts.fileDigest).toBe(withoutCounts.fileDigest);
+
+    const aggWithout = buildCandidateCapturedEvent(ctx, undefined, [withoutCounts]);
+    const aggWith = buildCandidateCapturedEvent(ctx, undefined, [withCounts]);
+    if (
+      aggWithout.payload.case === "candidateCaptured" &&
+      aggWith.payload.case === "candidateCaptured"
+    ) {
+      expect(aggWith.payload.value.aggregateDigest).toBe(
+        aggWithout.payload.value.aggregateDigest,
+      );
+    }
+  });
+
   it("omits the before side for an ADD and the after side for a DELETE", () => {
     const add = buildCapturedFileChange({
       id: "fc-add",

package/src/shared/filereview/__tests__/line-counts.test.ts

@@ -0,0 +1,73 @@
+/**
+ * Capture-time line counting: the `+N −M` semantics must mirror what the SDK's
+ * jsdiff-based diff renderer shows (same algorithm, same "\ No newline"
+ * exclusion), with absent sides treated as the empty document and a byte-size
+ * guard that skips counting rather than stalling capture.
+ */
+
+import { describe, expect, it } from "vitest";
+import { countLineChanges, LINE_COUNT_MAX_BYTES } from "../line-counts.js";
+
+describe("countLineChanges", () => {
+  it("counts a plain modify", () => {
+    expect(countLineChanges("a\nb\nc\n", "a\nB\nc\nd\n")).toEqual({
+      linesAdded: 2,
+      linesRemoved: 1,
+    });
+  });
+
+  it("counts an ADD (absent before) as all lines added", () => {
+    expect(countLineChanges(undefined, "one\ntwo\nthree\n")).toEqual({
+      linesAdded: 3,
+      linesRemoved: 0,
+    });
+  });
+
+  it("counts a DELETE (absent after) as all lines removed", () => {
+    expect(countLineChanges("one\ntwo\n", undefined)).toEqual({
+      linesAdded: 0,
+      linesRemoved: 2,
+    });
+  });
+
+  it("returns zero counts for identical sides", () => {
+    expect(countLineChanges("same\n", "same\n")).toEqual({
+      linesAdded: 0,
+      linesRemoved: 0,
+    });
+  });
+
+  it("returns undefined when both sides are absent", () => {
+    expect(countLineChanges(undefined, undefined)).toBeUndefined();
+  });
+
+  it("excludes the no-trailing-newline marker from the counts", () => {
+    // "a" -> "a\n": jsdiff models this as the "a" line replaced (one removed,
+    // one added) plus "\ No newline" metadata, which must not be counted —
+    // exactly the population the SDK's mapPatchHunks renders.
+    expect(countLineChanges("a", "a\n")).toEqual({
+      linesAdded: 1,
+      linesRemoved: 1,
+    });
+  });
+
+  it("counts an added file with no trailing newline by its real line count", () => {
+    expect(countLineChanges(undefined, "one\ntwo")).toEqual({
+      linesAdded: 2,
+      linesRemoved: 0,
+    });
+  });
+
+  it("skips counting when a side exceeds the byte guard", () => {
+    const huge = "x\n".repeat(LINE_COUNT_MAX_BYTES / 2 + 1);
+    expect(countLineChanges(huge, "small\n")).toBeUndefined();
+    expect(countLineChanges("small\n", huge)).toBeUndefined();
+  });
+
+  it("guards on UTF-8 byte length, not character count", () => {
+    // Each "€" is 3 bytes; a string just over the guard in bytes while well
+    // under it in characters must still be skipped.
+    const wide = "€".repeat(Math.ceil(LINE_COUNT_MAX_BYTES / 3) + 1);
+    expect(countLineChanges(wide, "")).toBeUndefined();
+  });
+});

package/src/shared/filereview/__tests__/progress.test.ts

@@ -0,0 +1,338 @@
+/**
+ * Unit tests for mid-run live capture (DD-32):
+ *  - `captureProgressDelta` (git-substrate) against a REAL temp git repo — the
+ *    only faithful test for git plumbing (kinds, counts, binary, rename→add+del,
+ *    tree-unchanged short-circuit, excludePaths).
+ *  - `buildFileChangeProgress` (pure) — secret zeroing, entry cap with honest
+ *    totals, aggregate sums.
+ *  - `shouldCaptureProgress` (pure) — the debounce floor.
+ */
+
+import { execFile } from "node:child_process";
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { beforeEach, afterEach, describe, expect, it } from "vitest";
+import { FileChangeKind, FileChangeType } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import {
+  captureProgressDelta,
+  snapshotBaseline,
+  dropCaptureRefs,
+  type GitProgressEntry,
+  type GitProgressDelta,
+} from "../git-substrate.js";
+import {
+  buildFileChangeProgress,
+  createGitProgressSubstrate,
+  createHybridProgressSubstrate,
+  PROGRESS_MAX_ENTRIES,
+  shouldCaptureProgress,
+  type ProgressCapture,
+  type ProgressDelta,
+  type ProgressEntry,
+  type ProgressSubstrate,
+} from "../progress.js";
+
+const execFileAsync = promisify(execFile);
+const EXEC_ID = "exec-progress-1";
+const CHANGE_SET_ID = "exec-progress-1:0";
+const RUNNER_OWNED_PATHS: readonly string[] = [".cursor/hooks.json"];
+
+let repo: string;
+
+async function git(args: string[]): Promise<void> {
+  await execFileAsync("git", args, { cwd: repo });
+}
+
+async function write(rel: string, content: string): Promise<void> {
+  await mkdir(join(repo, rel, ".."), { recursive: true });
+  await writeFile(join(repo, rel), content, "utf-8");
+}
+
+async function writeBytes(rel: string, bytes: Uint8Array): Promise<void> {
+  await mkdir(join(repo, rel, ".."), { recursive: true });
+  await writeFile(join(repo, rel), bytes);
+}
+
+function entryFor(delta: GitProgressDelta, path: string): GitProgressEntry | undefined {
+  return delta.entries.find((e) => e.pathAfter === path || e.pathBefore === path);
+}
+
+beforeEach(async () => {
+  repo = await mkdtemp(join(tmpdir(), "stigmer-progress-"));
+  await git(["init", "-q"]);
+  await git(["config", "user.email", "t@t.local"]);
+  await git(["config", "user.name", "t"]);
+  await write("src/main.ts", "export const x = 1;\n");
+  await write("keep.txt", "line1\nline2\nline3\n");
+  await git(["add", "-A"]);
+  await git(["commit", "-q", "-m", "initial"]);
+});
+
+afterEach(async () => {
+  await dropCaptureRefs(repo, EXEC_ID).catch(() => {});
+  await rm(repo, { recursive: true, force: true });
+});
+
+describe("captureProgressDelta (real git repo)", () => {
+  it("reports ADD / MODIFY / DELETE with line counts and honest path sides", async () => {
+    const baseline = await snapshotBaseline(repo, EXEC_ID);
+
+    await write("src/new.ts", "a\nb\nc\n"); // ADD (3 added)
+    await write("src/main.ts", "export const x = 2;\nexport const y = 3;\n"); // MODIFY
+    await rm(join(repo, "keep.txt")); // DELETE (3 removed)
+
+    const delta = await captureProgressDelta(repo, EXEC_ID, baseline);
+    expect(delta).toBeDefined();
+    expect(delta!.entries).toHaveLength(3);
+
+    const added = entryFor(delta!, "src/new.ts")!;
+    expect(added.changeType).toBe(FileChangeType.CREATE);
+    expect(added.pathBefore).toBe("");
+    expect(added.pathAfter).toBe("src/new.ts");
+    expect(added.linesAdded).toBe(3);
+    expect(added.linesRemoved).toBe(0);
+
+    const modified = entryFor(delta!, "src/main.ts")!;
+    expect(modified.changeType).toBe(FileChangeType.MODIFY);
+    expect(modified.pathBefore).toBe("src/main.ts");
+    expect(modified.pathAfter).toBe("src/main.ts");
+    expect(modified.linesAdded).toBeGreaterThan(0);
+
+    const deleted = entryFor(delta!, "keep.txt")!;
+    expect(deleted.changeType).toBe(FileChangeType.DELETE);
+    expect(deleted.pathBefore).toBe("keep.txt");
+    expect(deleted.pathAfter).toBe("");
+    expect(deleted.linesRemoved).toBe(3);
+    expect(deleted.linesAdded).toBe(0);
+  });
+
+  it("surfaces a binary change with zero counts (numstat reports '-')", async () => {
+    const baseline = await snapshotBaseline(repo, EXEC_ID);
+    await writeBytes("blob.bin", new Uint8Array([0, 1, 2, 0, 255, 0, 3]));
+
+    const delta = await captureProgressDelta(repo, EXEC_ID, baseline);
+    const bin = entryFor(delta!, "blob.bin")!;
+    expect(bin.changeType).toBe(FileChangeType.CREATE);
+    expect(bin.linesAdded).toBe(0);
+    expect(bin.linesRemoved).toBe(0);
+  });
+
+  it("splits a rename into a delete + create (--no-renames)", async () => {
+    const baseline = await snapshotBaseline(repo, EXEC_ID);
+    await rm(join(repo, "keep.txt"));
+    await write("renamed.txt", "line1\nline2\nline3\n");
+
+    const delta = await captureProgressDelta(repo, EXEC_ID, baseline);
+    expect(entryFor(delta!, "keep.txt")!.changeType).toBe(FileChangeType.DELETE);
+    expect(entryFor(delta!, "renamed.txt")!.changeType).toBe(FileChangeType.CREATE);
+  });
+
+  it("short-circuits (returns undefined) when the tree is unchanged since lastTreeSha", async () => {
+    const baseline = await snapshotBaseline(repo, EXEC_ID);
+    await write("src/new.ts", "a\nb\n");
+
+    const first = await captureProgressDelta(repo, EXEC_ID, baseline);
+    expect(first).toBeDefined();
+
+    const second = await captureProgressDelta(repo, EXEC_ID, baseline, [], first!.afterTree);
+    expect(second).toBeUndefined();
+  });
+
+  it("recomputes (0 entries) after the agent reverts its own edits", async () => {
+    const baseline = await snapshotBaseline(repo, EXEC_ID);
+    await write("src/new.ts", "a\nb\n");
+    const first = await captureProgressDelta(repo, EXEC_ID, baseline);
+
+    await rm(join(repo, "src/new.ts")); // revert to clean
+    const second = await captureProgressDelta(repo, EXEC_ID, baseline, [], first!.afterTree);
+    expect(second).toBeDefined();
+    expect(second!.entries).toHaveLength(0);
+  });
+
+  it("excludes runner-owned gate files from the delta", async () => {
+    const baseline = await snapshotBaseline(repo, EXEC_ID, RUNNER_OWNED_PATHS);
+    await write(".cursor/hooks.json", "{}\n");
+    await write("real.ts", "x\n");
+
+    const delta = await captureProgressDelta(repo, EXEC_ID, baseline, RUNNER_OWNED_PATHS);
+    expect(entryFor(delta!, ".cursor/hooks.json")).toBeUndefined();
+    expect(entryFor(delta!, "real.ts")).toBeDefined();
+  });
+});
+
+describe("buildFileChangeProgress (pure)", () => {
+  function delta(entries: ProgressEntry[], totalFilesChanged?: number): ProgressDelta {
+    return totalFilesChanged === undefined ? { entries } : { entries, totalFilesChanged };
+  }
+  function entry(
+    path: string,
+    added: number,
+    removed: number,
+    kind: FileChangeKind = FileChangeKind.MODIFY,
+  ): ProgressEntry {
+    return {
+      pathBefore: kind === FileChangeKind.ADD ? "" : path,
+      pathAfter: path,
+      kind,
+      linesAdded: added,
+      linesRemoved: removed,
+    };
+  }
+
+  it("sums aggregate counts and carries the per-entry kind through unchanged", () => {
+    const progress = buildFileChangeProgress(
+      delta([
+        entry("a.ts", 5, 0, FileChangeKind.ADD),
+        entry("b.ts", 2, 3),
+      ]),
+      CHANGE_SET_ID,
+    );
+    expect(progress.changeSetId).toBe(CHANGE_SET_ID);
+    expect(progress.filesChanged).toBe(2);
+    expect(progress.linesAdded).toBe(7);
+    expect(progress.linesRemoved).toBe(3);
+    expect(progress.entries[0].kind).toBe(FileChangeKind.ADD);
+    expect(progress.entries[1].kind).toBe(FileChangeKind.MODIFY);
+    expect(progress.capturedAt).not.toBe("");
+  });
+
+  it("reports totalFilesChanged when a substrate capped its reads, else the entry count", () => {
+    // git substrate leaves totalFilesChanged undefined -> filesChanged = entries.length.
+    const gitLike = buildFileChangeProgress(delta([entry("a.ts", 1, 0)]), CHANGE_SET_ID);
+    expect(gitLike.filesChanged).toBe(1);
+
+    // cas substrate read only a bounded prefix -> filesChanged reflects the honest
+    // total even though fewer entries were emitted.
+    const casLike = buildFileChangeProgress(delta([entry("a.ts", 1, 0)], 7), CHANGE_SET_ID);
+    expect(casLike.filesChanged).toBe(7);
+    expect(casLike.entries).toHaveLength(1);
+  });
+
+  it("zeroes counts for secret-like paths (path visible, magnitude withheld)", () => {
+    const progress = buildFileChangeProgress(
+      delta([entry(".env", 10, 2), entry("app.ts", 4, 1)]),
+      CHANGE_SET_ID,
+    );
+    // The secret path is still counted as a changed file and its path is present…
+    expect(progress.filesChanged).toBe(2);
+    const secret = progress.entries.find((e) => e.pathAfter === ".env")!;
+    expect(secret.linesAdded).toBe(0);
+    expect(secret.linesRemoved).toBe(0);
+    // …but its magnitude is excluded from the aggregate.
+    expect(progress.linesAdded).toBe(4);
+    expect(progress.linesRemoved).toBe(1);
+  });
+
+  it("caps entries but keeps files_changed and totals honest over all files", () => {
+    const entries: ProgressEntry[] = [];
+    for (let i = 0; i < PROGRESS_MAX_ENTRIES + 25; i++) {
+      entries.push(entry(`f${i}.ts`, 1, 1));
+    }
+    const progress = buildFileChangeProgress(delta(entries), CHANGE_SET_ID);
+    expect(progress.entries).toHaveLength(PROGRESS_MAX_ENTRIES);
+    expect(progress.filesChanged).toBe(PROGRESS_MAX_ENTRIES + 25);
+    expect(progress.linesAdded).toBe(PROGRESS_MAX_ENTRIES + 25);
+    expect(progress.linesRemoved).toBe(PROGRESS_MAX_ENTRIES + 25);
+  });
+
+  it("produces a zero-file snapshot for an empty delta (revert-to-clean)", () => {
+    const progress = buildFileChangeProgress(delta([]), CHANGE_SET_ID);
+    expect(progress.filesChanged).toBe(0);
+    expect(progress.entries).toHaveLength(0);
+  });
+});
+
+describe("shouldCaptureProgress (pure)", () => {
+  it("always captures on the first call (lastAtMs = 0, real clock)", () => {
+    // The caller starts a fresh turn with lastAtMs = 0 and now = Date.now(),
+    // which is always far past any floor.
+    expect(shouldCaptureProgress(0, Date.now(), 2000)).toBe(true);
+  });
+
+  it("gates within the floor and allows once it elapses", () => {
+    expect(shouldCaptureProgress(1000, 2500, 2000)).toBe(false);
+    expect(shouldCaptureProgress(1000, 3000, 2000)).toBe(true);
+    expect(shouldCaptureProgress(1000, 3001, 2000)).toBe(true);
+  });
+});
+
+describe("createGitProgressSubstrate (real git repo)", () => {
+  it("reports changed:true then reuses the cached full delta on an unchanged tree", async () => {
+    const baseline = await snapshotBaseline(repo, EXEC_ID);
+    const sub = createGitProgressSubstrate({
+      workspaceRoot: repo,
+      executionId: EXEC_ID,
+      baselineTree: baseline,
+    });
+
+    await write("src/new.ts", "a\nb\n");
+    const first = await sub.capture();
+    expect(first.changed).toBe(true);
+    expect(first.delta.entries.length).toBeGreaterThan(0);
+
+    // Nothing moved since the last capture: the tree-sha short-circuits, but the
+    // full delta is still returned (changed:false) so a hybrid can merge it.
+    const second = await sub.capture();
+    expect(second.changed).toBe(false);
+    expect(second.delta.entries).toEqual(first.delta.entries);
+  });
+});
+
+/** A fake substrate returning a fixed capture — for merge/short-circuit logic. */
+function fakeSubstrate(capture: ProgressCapture): ProgressSubstrate {
+  return { capture: () => Promise.resolve(capture) };
+}
+
+function progressEntry(path: string): ProgressEntry {
+  return { pathBefore: "", pathAfter: path, kind: FileChangeKind.ADD, linesAdded: 1, linesRemoved: 0 };
+}
+
+describe("createHybridProgressSubstrate", () => {
+  it("concatenates disjoint git + cas slices and sums the honest totals", async () => {
+    const git = fakeSubstrate({
+      delta: { entries: [progressEntry("tracked.ts")] }, // git: total = entries.length
+      changed: true,
+    });
+    const cas = fakeSubstrate({
+      delta: { entries: [progressEntry(".env.local")], totalFilesChanged: 3 }, // cas capped
+      changed: true,
+    });
+    const hybrid = createHybridProgressSubstrate(git, cas);
+
+    const { delta, changed } = await hybrid.capture();
+    expect(changed).toBe(true);
+    expect(delta.entries.map((e) => e.pathAfter)).toEqual(["tracked.ts", ".env.local"]);
+    // 1 (git entries) + 3 (cas honest total) = 4.
+    expect(delta.totalFilesChanged).toBe(4);
+  });
+
+  it("still emits the full git slice when only the cas slice changed", async () => {
+    // Git unchanged returns its cached full delta with changed:false; the hybrid
+    // must keep it (a `ProgressDelta | undefined` contract would have dropped it).
+    const git = fakeSubstrate({
+      delta: { entries: [progressEntry("tracked.ts")] },
+      changed: false,
+    });
+    const cas = fakeSubstrate({
+      delta: { entries: [progressEntry("build/out.js")], totalFilesChanged: 1 },
+      changed: true,
+    });
+    const hybrid = createHybridProgressSubstrate(git, cas);
+
+    const { delta, changed } = await hybrid.capture();
+    expect(changed).toBe(true);
+    expect(delta.entries.map((e) => e.pathAfter)).toEqual(["tracked.ts", "build/out.js"]);
+    expect(delta.totalFilesChanged).toBe(2);
+  });
+
+  it("reports changed:false only when NEITHER slice moved", async () => {
+    const git = fakeSubstrate({ delta: { entries: [] }, changed: false });
+    const cas = fakeSubstrate({ delta: { entries: [], totalFilesChanged: 0 }, changed: false });
+    const hybrid = createHybridProgressSubstrate(git, cas);
+
+    const { changed } = await hybrid.capture();
+    expect(changed).toBe(false);
+  });
+});