@remnic/coding-graph 9.3.759

package/src/detect-changes.test.ts

@@ -0,0 +1,533 @@
+/**
+ * detect_changes + blast radius tests (issue #1553).
+ *
+ * Blast-radius rubric fixtures: a fixture graph where the same change
+ * yields direct/near/transitive classifications; fan-in escalation
+ * boundary tested at the exact threshold.
+ *
+ * detect_changes output for a fixture diff is byte-stable (same diff +
+ * graph → same output, regardless of Set iteration order).
+ */
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import {
+  GraphStore,
+  nodeIdFor,
+  type EdgeIR,
+  type StoreFileIR,
+  type SymbolIR,
+} from "./graph-store.js";
+import {
+  classifyRisk,
+  computeBlastRadius,
+  type AffectedSymbol,
+  findDirectlyAffectedSymbols,
+  byteSpanToLines,
+  rangesOverlap,
+  FAN_IN_ESCALATION_THRESHOLD,
+} from "./detect-changes.js";
+import type { DiffHunk } from "./git-invoker.js";
+import type { FileIR } from "@remnic/core";
+
+// ──────────────────────────────────────────────────────────────────────────
+// Fixture helpers
+// ──────────────────────────────────────────────────────────────────────────
+
+function sym(
+  qualifiedName: string,
+  name: string,
+  startByte: number,
+  endByte: number,
+  kind: SymbolIR["kind"] = "function",
+): SymbolIR {
+  return { qualifiedName, name, span: { startByte, endByte }, kind };
+}
+
+function edge(
+  srcQualifiedName: string,
+  dstQualifiedName: string,
+  type = "CALLS",
+  confidence = 0.9,
+  provenance: EdgeIR["provenance"] = "heuristic",
+): EdgeIR {
+  return { srcQualifiedName, dstQualifiedName, type, confidence, provenance };
+}
+
+async function tempStore(): Promise<{ store: GraphStore; dir: string }> {
+  const dir = await mkdtemp(path.join(tmpdir(), "detect-changes-test-"));
+  const store = await GraphStore.open({
+    dbPath: path.join(dir, "graph.sqlite"),
+    repoRoot: dir,
+  });
+  return { store, dir };
+}
+
+/**
+ * Unwrap computeBlastRadius for characterization tests — the store is
+ * healthy here so the result is always ok. Regression tests for the
+ * store-failure path call computeBlastRadius directly and assert the
+ * tagged shape (rule 22).
+ */
+function blast(
+  store: GraphStore,
+  ids: ReadonlySet<string>,
+  depth: number,
+): readonly AffectedSymbol[] {
+  const r = computeBlastRadius(store, ids, depth);
+  if (!r.ok) throw new Error("expected blast radius ok in characterization test");
+  return r.affected;
+}
+
+async function dispose(store: GraphStore, dir: string): Promise<void> {
+  await store.close();
+  await rm(dir, { recursive: true, force: true });
+}
+
+// ──────────────────────────────────────────────────────────────────────────
+// Line-range overlap tests (rule 35: half-open intervals)
+// ──────────────────────────────────────────────────────────────────────────
+
+test("rangesOverlap: half-open boundaries", () => {
+  // [1,5) vs [5,10) → NO overlap (boundary touch)
+  assert.equal(
+    rangesOverlap({ startLine: 1, endLine: 5 }, { startLine: 5, endLine: 10 }),
+    false,
+  );
+  // [1,5) vs [4,10) → overlap
+  assert.equal(
+    rangesOverlap({ startLine: 1, endLine: 5 }, { startLine: 4, endLine: 10 }),
+    true,
+  );
+  // [1,5) vs [1,5) → overlap (same range)
+  assert.equal(
+    rangesOverlap({ startLine: 1, endLine: 5 }, { startLine: 1, endLine: 5 }),
+    true,
+  );
+  // [1,5) vs [0,1) → NO overlap (hunk ends exactly at symbol start)
+  assert.equal(
+    rangesOverlap({ startLine: 1, endLine: 5 }, { startLine: 0, endLine: 1 }),
+    false,
+  );
+  // Single-line: [3,4) vs [3,4) → overlap
+  assert.equal(
+    rangesOverlap({ startLine: 3, endLine: 4 }, { startLine: 3, endLine: 4 }),
+    true,
+  );
+});
+
+test("byteSpanToLines: basic conversion", () => {
+  const content = new TextEncoder().encode("line1\nline2\nline3");
+  // Bytes 0-5 = "line1" → lines {1, 2} (exclusive end)
+  const r1 = byteSpanToLines(content, 0, 5);
+  assert.equal(r1.startLine, 1);
+  assert.equal(r1.endLine, 2);
+  // Bytes 6-11 = "line2" → lines {2, 3}
+  const r2 = byteSpanToLines(content, 6, 11);
+  assert.equal(r2.startLine, 2);
+  assert.equal(r2.endLine, 3);
+});
+
+// ──────────────────────────────────────────────────────────────────────────
+// Risk classification rubric
+// ──────────────────────────────────────────────────────────────────────────
+
+test("classifyRisk: depth → risk mapping", () => {
+  assert.equal(classifyRisk(0, 0), "direct");
+  assert.equal(classifyRisk(1, 0), "near");
+  assert.equal(classifyRisk(2, 0), "transitive");
+  assert.equal(classifyRisk(3, 0), "transitive");
+});
+
+test("classifyRisk: fan-in escalation at exact threshold", () => {
+  // Threshold is 5. At threshold-1 (4), no escalation.
+  assert.equal(classifyRisk(1, FAN_IN_ESCALATION_THRESHOLD - 1), "near");
+  // At threshold (5), near → direct.
+  assert.equal(classifyRisk(1, FAN_IN_ESCALATION_THRESHOLD), "direct");
+  // At threshold (5), transitive → near.
+  assert.equal(classifyRisk(2, FAN_IN_ESCALATION_THRESHOLD), "near");
+  // Direct stays direct (capped).
+  assert.equal(classifyRisk(0, FAN_IN_ESCALATION_THRESHOLD), "direct");
+});
+
+// ──────────────────────────────────────────────────────────────────────────
+// Blast-radius fixtures — same change yields direct/near/transitive
+// ──────────────────────────────────────────────────────────────────────────
+
+/**
+ * Fixture: a → b → c → d (chain). Changing `a` should classify:
+ *   a → direct (depth 0)
+ *   (nothing calls a, so no near/transitive from a)
+ *
+ * Changing `d` should classify via reverse BFS:
+ *   d → direct (depth 0)
+ *   c → near (depth 1, c calls d)
+ *   b → transitive (depth 2, b calls c)
+ *   a → transitive (depth 3, a calls b)
+ */
+const CHAIN_FILE: StoreFileIR = {
+  path: "src/chain.ts",
+  language: "typescript",
+  contentHash: "h-chain",
+  symbols: [
+    sym("chain.a", "a", 0, 10),
+    sym("chain.b", "b", 10, 20),
+    sym("chain.c", "c", 20, 30),
+    sym("chain.d", "d", 30, 40),
+  ],
+  edges: [
+    edge("chain.a", "chain.b"), // a calls b
+    edge("chain.b", "chain.c"), // b calls c
+    edge("chain.c", "chain.d"), // c calls d
+  ],
+};
+
+test("computeBlastRadius: chain fixture — d changed yields direct/near/transitive", async () => {
+  const { store, dir } = await tempStore();
+  try {
+    const result = await store.upsertFileBatch([CHAIN_FILE]);
+    assert.equal(result.ok, true);
+
+    // Simulate: `d` is directly affected. Reverse BFS finds who depends on d.
+    const affected = blast(store, new Set(["chain.d"]), 3);
+    assert.equal(affected.length, 4);
+
+    // d is direct (depth 0).
+    const d = affected.find((a) => a.qualifiedName === "chain.d");
+    assert.ok(d);
+    assert.equal(d!.risk, "direct");
+    assert.equal(d!.depth, 0);
+
+    // c is near (depth 1 — c calls d).
+    const c = affected.find((a) => a.qualifiedName === "chain.c");
+    assert.ok(c);
+    assert.equal(c!.risk, "near");
+    assert.equal(c!.depth, 1);
+
+    // b is transitive (depth 2).
+    const b = affected.find((a) => a.qualifiedName === "chain.b");
+    assert.ok(b);
+    assert.equal(b!.risk, "transitive");
+    assert.equal(b!.depth, 2);
+
+    // a is transitive (depth 3).
+    const a = affected.find((a) => a.qualifiedName === "chain.a");
+    assert.ok(a);
+    assert.equal(a!.risk, "transitive");
+    assert.equal(a!.depth, 3);
+  } finally {
+    await dispose(store, dir);
+  }
+});
+
+test("computeBlastRadius: byte-stable — same input, same output", async () => {
+  const { store, dir } = await tempStore();
+  try {
+    await store.upsertFileBatch([CHAIN_FILE]);
+
+    const affected1 = blast(store, new Set(["chain.d"]), 3);
+    const affected2 = blast(store, new Set(["chain.d"]), 3);
+
+    // Deep equal — same order, same classifications.
+  assert.deepEqual(
+    affected1.map((a) => ({ q: a.qualifiedName, r: a.risk, d: a.depth })),
+    affected2.map((a) => ({ q: a.qualifiedName, r: a.risk, d: a.depth })),
+  );
+  } finally {
+    await dispose(store, dir);
+  }
+});
+
+test("computeBlastRadius: empty affected set → empty result", async () => {
+  const { store, dir } = await tempStore();
+  try {
+    const affected = blast(store, new Set(), 3);
+    assert.equal(affected.length, 0);
+  } finally {
+    await dispose(store, dir);
+  }
+});
+
+/**
+ * Fixture for fan-in escalation:
+ *   caller1 → mid → target
+ *   caller2 → mid
+ *   caller3 → mid
+ *   caller4 → mid
+ *   caller5 → mid
+ *
+ * When `target` is directly affected:
+ *   target → direct (depth 0)
+ *   mid → near (depth 1, mid calls target). mid has fanIn=5 ≥ threshold.
+ *        Fan-in escalates near → direct.
+ *   caller1-5 → transitive (depth 2).
+ */
+const FAN_IN_FILE: StoreFileIR = {
+  path: "src/fanin.ts",
+  language: "typescript",
+  contentHash: "h-fanin",
+  symbols: [
+    sym("fanin.target", "target", 0, 10),
+    sym("fanin.mid", "mid", 10, 20),
+    sym("fanin.caller1", "caller1", 20, 30),
+    sym("fanin.caller2", "caller2", 30, 40),
+    sym("fanin.caller3", "caller3", 40, 50),
+    sym("fanin.caller4", "caller4", 50, 60),
+    sym("fanin.caller5", "caller5", 60, 70),
+  ],
+  edges: [
+    edge("fanin.mid", "fanin.target"),
+    edge("fanin.caller1", "fanin.mid"),
+    edge("fanin.caller2", "fanin.mid"),
+    edge("fanin.caller3", "fanin.mid"),
+    edge("fanin.caller4", "fanin.mid"),
+    edge("fanin.caller5", "fanin.mid"),
+  ],
+};
+
+test("computeBlastRadius: fan-in escalation — mid escalates near→direct", async () => {
+  const { store, dir } = await tempStore();
+  try {
+    await store.upsertFileBatch([FAN_IN_FILE]);
+
+    // Change target. mid is 1 hop away (near) but has fanIn=5 ≥ 5.
+    const affected = blast(store, new Set(["fanin.target"]), 3);
+    const mid = affected.find((a) => a.qualifiedName === "fanin.mid");
+    assert.ok(mid, "mid should be in blast radius");
+    assert.equal(mid!.depth, 1);
+    // Fan-in escalates near → direct.
+    assert.equal(mid!.risk, "direct");
+    assert.ok(mid!.fanIn >= FAN_IN_ESCALATION_THRESHOLD);
+  } finally {
+    await dispose(store, dir);
+  }
+});
+
+// ──────────────────────────────────────────────────────────────────────────
+// findDirectlyAffectedSymbols — hunk → span overlap
+// ──────────────────────────────────────────────────────────────────────────
+
+test("findDirectlyAffectedSymbols: hunk overlapping a symbol span", () => {
+  const content = new TextEncoder().encode("function foo() {\n  return 1;\n}\n");
+  // foo spans bytes 0-23 (lines 1-3).
+  const ir: FileIR = {
+    path: "src/a.ts",
+    language: "typescript",
+    contentHash: "h",
+    symbols: [
+      {
+        kind: "function",
+        name: "foo",
+        qualifiedName: "a::foo",
+        span: { startByte: 0, endByte: 23 },
+      },
+    ],
+    imports: [],
+    exports: [],
+    callSites: [],
+    routes: [],
+  };
+  const hunks = new Map<string, readonly DiffHunk[]>([
+    ["src/a.ts", [{ path: "src/a.ts", newRange: { startLine: 2, endLine: 3 } }]],
+  ]);
+  const irs = new Map([["src/a.ts", ir]]);
+  const contents = new Map([["src/a.ts", content]]);
+  const affected = findDirectlyAffectedSymbols(hunks, irs, contents);
+  // Returns node ids (qualifiedName + filePath + label identity).
+  assert.ok(
+    affected.has(nodeIdFor({ qualifiedName: "a::foo", filePath: "src/a.ts", label: "function" })),
+    "foo's node id is affected",
+  );
+});
+
+test("findDirectlyAffectedSymbols: hunk NOT overlapping → not affected", () => {
+  // Content with clear line boundaries:
+  // Line 1: "function foo() {"
+  // Line 2: "  return 1;"
+  // Line 3: "}"
+  // Line 4: "function bar() {}"
+  // Byte layout: "function foo() {\n  return 1;\n}\nfunction bar() {}\n"
+  // foo = bytes [0, 31) = lines [1, 4)
+  // bar = bytes [31, 49) = line [4, 5)
+  const content = new TextEncoder().encode("function foo() {\n  return 1;\n}\nfunction bar() {}\n");
+  const fooEnd = "function foo() {\n  return 1;\n}\n".length; // 31
+  const ir: FileIR = {
+    path: "src/a.ts",
+    language: "typescript",
+    contentHash: "h",
+    symbols: [
+      {
+        kind: "function",
+        name: "foo",
+        qualifiedName: "a::foo",
+        span: { startByte: 0, endByte: fooEnd },
+      },
+      {
+        kind: "function",
+        name: "bar",
+        qualifiedName: "a::bar",
+        span: { startByte: fooEnd, endByte: content.length },
+      },
+    ],
+    imports: [],
+    exports: [],
+    callSites: [],
+    routes: [],
+  };
+  // Hunk on line 4 (bar's line), not foo (lines 1-3).
+  const hunks = new Map<string, readonly DiffHunk[]>([
+    ["src/a.ts", [{ path: "src/a.ts", newRange: { startLine: 4, endLine: 5 } }]],
+  ]);
+  const irs = new Map([["src/a.ts", ir]]);
+  const contents = new Map([["src/a.ts", content]]);
+  const affected = findDirectlyAffectedSymbols(hunks, irs, contents);
+  assert.ok(
+    !affected.has(nodeIdFor({ qualifiedName: "a::foo", filePath: "src/a.ts", label: "function" })),
+    "foo should NOT be affected",
+  );
+  assert.ok(
+    affected.has(nodeIdFor({ qualifiedName: "a::bar", filePath: "src/a.ts", label: "function" })),
+    "bar should be affected",
+  );
+});
+
+// ──────────────────────────────────────────────────────────────────────────
+// cursor Bugbot fix — filePath resolution for duplicate simple names
+// ──────────────────────────────────────────────────────────────────────────
+
+/**
+ * Fixture: two files both declaring a symbol named `foo` (same simple
+ * name, different qualified names). a.ts::foo CALLS b.ts::foo. When b's
+ * foo changes, the blast radius must report a.ts::foo with filePath
+ * `src/a.ts` — NOT the wrong file resolved by a name-only search.
+ *
+ * Before the fix, computeBlastRadius resolved filePath via searchGraph
+ * ({ namePattern: "foo", limit: 1 }), which could attach either file's
+ * path to the affected symbol (cursor Bugbot: 'Blast radius wrong file
+ * path'). The fix reads filePath straight from the traverse hit.
+ */
+const DUP_A: StoreFileIR = {
+  path: "src/a.ts",
+  language: "typescript",
+  contentHash: "h-dup-a",
+  symbols: [sym("a.foo", "foo", 0, 30)],
+  edges: [edge("a.foo", "b.foo")], // a.ts::foo calls b.ts::foo
+  exports: [],
+};
+const DUP_B: StoreFileIR = {
+  path: "src/b.ts",
+  language: "typescript",
+  contentHash: "h-dup-b",
+  symbols: [sym("b.foo", "foo", 0, 30)],
+  edges: [],
+  exports: [],
+};
+
+test("computeBlastRadius: duplicate simple names keep the correct filePath (cursor Bugbot: 'Blast radius wrong file path')", async () => {
+  const { store, dir } = await tempStore();
+  try {
+    await store.upsertFileBatch([DUP_A, DUP_B]);
+
+    // b.foo changed directly. Reverse BFS finds a.foo (a calls b).
+    const affected = blast(store, new Set(["b.foo"]), 3);
+    // Both symbols appear (b.foo direct, a.foo near).
+    assert.equal(affected.length, 2);
+
+    const aHit = affected.find((x) => x.qualifiedName === "a.foo");
+    assert.ok(aHit, "a.foo is in the blast radius (it calls the changed b.foo)");
+    // The load-bearing assertion: a.foo's filePath is src/a.ts, not the
+    // wrong src/b.ts that a name-only search could return.
+    assert.equal(aHit!.filePath, "src/a.ts");
+
+    const bHit = affected.find((x) => x.qualifiedName === "b.foo");
+    assert.ok(bHit);
+    assert.equal(bHit!.filePath, "src/b.ts");
+    assert.equal(bHit!.risk, "direct");
+  } finally {
+    await dispose(store, dir);
+  }
+});
+
+
+test("findDirectlyAffectedSymbols: duplicate qualifiedName across files yields distinct node ids (chatgpt-codex-connector: 'Preserve node identity')", () => {
+  // Two files both declaring a symbol with the SAME qualifiedName "dup::fn".
+  // findDirectlyAffectedSymbols must return BOTH node ids (distinct because
+  // identity includes filePath), not collapse them into one.
+  const content = new TextEncoder().encode("function fn() {}\n");
+  const irA: FileIR = {
+    path: "src/a.ts", language: "typescript", contentHash: "h",
+    symbols: [{ kind: "function", name: "fn", qualifiedName: "dup::fn", span: { startByte: 0, endByte: 16 } }],
+    imports: [], exports: [], callSites: [], routes: [],
+  };
+  const irB: FileIR = {
+    path: "src/b.ts", language: "typescript", contentHash: "h",
+    symbols: [{ kind: "function", name: "fn", qualifiedName: "dup::fn", span: { startByte: 0, endByte: 16 } }],
+    imports: [], exports: [], callSites: [], routes: [],
+  };
+  const hunks = new Map<string, readonly DiffHunk[]>([
+    ["src/a.ts", [{ path: "src/a.ts", newRange: { startLine: 1, endLine: 2 } }]],
+    ["src/b.ts", [{ path: "src/b.ts", newRange: { startLine: 1, endLine: 2 } }]],
+  ]);
+  const irs = new Map([["src/a.ts", irA], ["src/b.ts", irB]]);
+  const contents = new Map([["src/a.ts", content], ["src/b.ts", content]]);
+  const affected = findDirectlyAffectedSymbols(hunks, irs, contents);
+  const idA = nodeIdFor({ qualifiedName: "dup::fn", filePath: "src/a.ts", label: "function" });
+  const idB = nodeIdFor({ qualifiedName: "dup::fn", filePath: "src/b.ts", label: "function" });
+  assert.notEqual(idA, idB, "node ids must differ by filePath");
+  assert.ok(affected.has(idA), "a.ts node affected");
+  assert.ok(affected.has(idB), "b.ts node affected");
+});
+
+test("computeBlastRadius: byte-stable sort with duplicate qualifiedNames (cursor Bugbot: 'Blast radius sort not byte-stable')", async () => {
+  const { store, dir } = await tempStore();
+  try {
+    await store.upsertFileBatch([DUP_A, DUP_B]);
+    const r1 = blast(store, new Set(["b.foo"]), 3);
+    const r2 = blast(store, new Set(["b.foo"]), 3);
+    // Same risk/qualifiedName for a.foo across runs — order must be
+    // identical (filePath + nodeId tiebreaker makes it total).
+    assert.deepEqual(
+      r1.map((a) => ({ q: a.qualifiedName, f: a.filePath, r: a.risk })),
+      r2.map((a) => ({ q: a.qualifiedName, f: a.filePath, r: a.risk })),
+    );
+    // Both files' foo are present and distinguishable.
+    assert.equal(r1.length, 2);
+    assert.equal(new Set(r1.map((a) => a.filePath)).size, 2);
+  } finally {
+    await dispose(store, dir);
+  }
+});
+
+
+// ──────────────────────────────────────────────────────────────────────────
+// Rule 22 — computeBlastRadius surfaces store failures instead of masking
+// them as an empty affected set (cursor Bugbot: 'computeBlastRadius masks
+// traverse failures'). Before the fix, `if (!result.ok) continue` conflated
+// a backend failure with "no inbound edges".
+// ──────────────────────────────────────────────────────────────────────────
+
+test("computeBlastRadius: store failure surfaces as store_error, not masked as empty (rule 22)", async () => {
+  const { store, dir } = await tempStore();
+  try {
+    await store.upsertFileBatch([CHAIN_FILE]);
+    const ids = new Set(["chain.d"]);
+    // Sanity: a healthy store resolves the blast radius.
+    const ok = computeBlastRadius(store, ids, 3);
+    assert.equal(ok.ok, true);
+
+    // Close the store — traverse now returns store_closed. Before the fix
+    // this was silently skipped (continue), yielding an empty affected set
+    // indistinguishable from "no dependents". Now it surfaces a tagged
+    // store_error so the caller knows the computation is unreliable.
+    await store.close();
+    const failed = computeBlastRadius(store, ids, 3);
+    assert.equal(failed.ok, false);
+    if (failed.ok) throw new Error("expected store_error");
+    assert.equal(failed.code, "store_error");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});