@mrciphersmith/keryx 0.2.83 → 0.2.88

package/src/gdgraph/repomap.test.ts

@@ -1,110 +0,0 @@
-import { mkdtemp, readFile, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { expect, test } from "bun:test";
-import { DEFAULT_GDGRAPH_CONFIG, mergeGdgraphConfig } from "./config";
-import { personalizedPageRank } from "./pagerank";
-import { buildRankEdges, computeRepomap, estimateTokens, writeRepomap } from "./repomap";
-import type { GraphData } from "./types";
-
-const FIXTURE_DIR = fileURLToPath(new URL("../../fixtures/repomap/", import.meta.url));
-
-async function loadFixtureGraph(): Promise<GraphData> {
-  const raw = JSON.parse(await readFile(path.join(FIXTURE_DIR, "graph.json"), "utf8"));
-  return { nodes: raw.nodes, edges: raw.edges };
-}
-
-async function loadExpected(): Promise<any> {
-  return JSON.parse(await readFile(path.join(FIXTURE_DIR, "expected.json"), "utf8"));
-}
-
-test("AC3.3 — top-ranked entries match expected centrality ordering", async () => {
-  const graph = await loadFixtureGraph();
-  const expected = await loadExpected();
-  const nodes = graph.nodes.filter((node) => node.kind === "file").map((node) => node.path);
-  const edges = buildRankEdges(graph, DEFAULT_GDGRAPH_CONFIG);
-  const ranked = personalizedPageRank(nodes, edges, {
-    damping: DEFAULT_GDGRAPH_CONFIG.repomap.damping,
-    iterations: DEFAULT_GDGRAPH_CONFIG.repomap.iterations,
-    tolerance: DEFAULT_GDGRAPH_CONFIG.repomap.tolerance,
-  });
-  expect(ranked.map((entry) => entry.id)).toEqual(expected.centralityOrder);
-});
-
-test("AC3.2 — repomap fits the token budget with a stable omission marker", async () => {
-  const graph = await loadFixtureGraph();
-  const expected = await loadExpected();
-  const config = mergeGdgraphConfig({ repomap: { tokenBudget: expected.tokenBudget } });
-  const result = computeRepomap(graph, config, {});
-
-  expect(result.tokens).toBeLessThanOrEqual(expected.tokenBudget);
-  expect(estimateTokens(result.content)).toBeLessThanOrEqual(expected.tokenBudget);
-  expect(result.entries.map((entry) => entry.path)).toEqual(expected.topWithinBudget);
-  expect(result.omitted).toBe(expected.omitted);
-  expect(result.content).toContain(`… ${expected.omitted} entries omitted …`);
-});
-
-test("AC3.2 — --budget override is honored and bounds the output", async () => {
-  const graph = await loadFixtureGraph();
-  const result = computeRepomap(graph, DEFAULT_GDGRAPH_CONFIG, { budget: 30 });
-  expect(result.tokens).toBeLessThanOrEqual(30);
-  expect(result.omitted).toBeGreaterThan(0);
-});
-
-test("AC3.4 — re-running repomap yields a byte-identical file", async () => {
-  const graph = await loadFixtureGraph();
-  const root = await mkdtemp(path.join(tmpdir(), "keryx-repomap-"));
-  try {
-    const config = mergeGdgraphConfig({ repomap: { tokenBudget: 40 } });
-    const first = await writeRepomap(root, graph, config, {});
-    const firstBytes = await readFile(first.path, "utf8");
-    const second = await writeRepomap(root, graph, config, {});
-    const secondBytes = await readFile(second.path, "utf8");
-    expect(secondBytes).toBe(firstBytes);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("AC3.6 — --seed biases personalization; seeded/unseeded each reproducible", async () => {
-  const graph = await loadFixtureGraph();
-  const unseeded = computeRepomap(graph, DEFAULT_GDGRAPH_CONFIG, {});
-  const seeded = computeRepomap(graph, DEFAULT_GDGRAPH_CONFIG, { seed: ["src/a.ts"] });
-  const seededAgain = computeRepomap(graph, DEFAULT_GDGRAPH_CONFIG, { seed: ["src/a.ts"] });
-
-  // Each run reproducible.
-  expect(seeded.content).toBe(seededAgain.content);
-  // Seeding on a.ts lifts it above its unseeded rank position.
-  const unseededRank = unseeded.entries.findIndex((entry) => entry.path === "src/a.ts");
-  const seededRank = seeded.entries.findIndex((entry) => entry.path === "src/a.ts");
-  expect(seededRank).toBeGreaterThanOrEqual(0);
-  expect(seededRank).toBeLessThan(unseededRank === -1 ? Number.MAX_SAFE_INTEGER : unseededRank + 1);
-});
-
-test("AC3.5 — repomap ranks symbol-aware weights when the layer is present", async () => {
-  const graph = await loadFixtureGraph();
-  // Add a tiny symbol layer so buildRankEdges exercises calls/defines weights.
-  const withSymbols: GraphData = {
-    ...graph,
-    symbols: [
-      {
-        id: "src/core.ts#run",
-        kind: "function",
-        path: "src/core.ts",
-        name: "run",
-        container: null,
-        startLine: 1,
-        endLine: 2,
-        language: "typescript",
-        signature: "run()",
-      },
-    ],
-    calls: [
-      { id: "d", from: "src/core.ts", to: "src/core.ts#run", kind: "defines", resolved: true },
-    ],
-  };
-  const result = computeRepomap(withSymbols, DEFAULT_GDGRAPH_CONFIG, { budget: 400 });
-  const core = result.entries.find((entry) => entry.path === "src/core.ts");
-  expect(core?.symbols).toEqual(["run()"]);
-});

package/src/gdgraph/service.test.ts

@@ -1,89 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { expect, test } from "bun:test";
-import { createGdgraphService, UnknownGraphTargetError } from "./service";
-
-async function makeProject(): Promise<string> {
-  const root = await mkdtemp(path.join(tmpdir(), "keryx-svc-"));
-  await mkdir(path.join(root, "src"), { recursive: true });
-  await writeFile(path.join(root, "src", "a.ts"), "export const a = 1;\n");
-  await writeFile(path.join(root, "src", "b.ts"), "import { a } from './a';\nexport const b = a;\n");
-  await writeFile(path.join(root, "src", "c.ts"), "import { b } from './b';\nexport const c = b;\n");
-  return root;
-}
-
-test("AC5.3/T-1 — service.affected is a pure in-process method (transport-independent)", async () => {
-  const root = await makeProject();
-  try {
-    const service = createGdgraphService();
-    await service.build(root);
-    // depth 2 closure of a: b (hop1) + c (hop2).
-    const affected = await service.affected(root, "src/a.ts", { depth: 2 });
-    expect(affected.dependents).toEqual(["src/b.ts", "src/c.ts"]);
-    // default depth (config) = 1 ⇒ only direct dependents.
-    const shallow = await service.affected(root, "src/a.ts");
-    expect(shallow.dependents).toEqual(["src/b.ts"]);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("AC5.3/T-1 — service.repomap writes artifacts/repomap.md deterministically", async () => {
-  const root = await makeProject();
-  try {
-    const service = createGdgraphService();
-    await service.build(root);
-    const first = await service.repomap(root, { budget: 2000 });
-    expect(first.path).toContain(path.join("artifacts", "repomap.md"));
-    expect(first.tokens).toBeLessThanOrEqual(2000);
-    const second = await service.repomap(root, { budget: 2000 });
-    expect(second.content).toBe(first.content);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-// AFC-10 (flow 234, phase 2): before this task, `service.affected` for a
-// target the graph never indexed and a target the graph indexed but found no
-// edges for returned byte-identical shapes — `{dependencies: [], dependents:
-// [], ranked: []}` — differing only in the echoed-back `target` string.
-// Measured directly against this exact fixture: an unknown path
-// ("src/does-not-exist.ts") and a real, indexed, edge-less leaf file
-// produced the same `{dependencies, dependents, ranked}`. That is the same
-// defect class phase 1 closed at eight other sites — a failure rendered as a
-// legitimate empty success — so an unknown target must now be reported
-// distinguishably instead of silently resolving to an empty result.
-test("AFC-10 — service.affected on a target the graph never indexed throws UnknownGraphTargetError, distinct from an indexed-but-edgeless target", async () => {
-  const root = await makeProject();
-  try {
-    await writeFile(path.join(root, "src", "isolated.ts"), "export const iso = 1;\n");
-    const service = createGdgraphService();
-    await service.build(root);
-
-    // Indexed, legitimately no edges at all: a real success, not an error.
-    const indexedNoEdges = await service.affected(root, "src/isolated.ts");
-    expect(indexedNoEdges.dependencies).toEqual([]);
-    expect(indexedNoEdges.dependents).toEqual([]);
-
-    // Never indexed: must be distinguishable from the above, not the same
-    // `{dependencies: [], dependents: []}` shape under a different `target`.
-    await expect(service.affected(root, "src/does-not-exist.ts")).rejects.toThrow(UnknownGraphTargetError);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("service.query returns cycles + orphans over the built graph", async () => {
-  const root = await makeProject();
-  try {
-    const service = createGdgraphService();
-    await service.build(root);
-    const cycles = await service.query(root, "cycles");
-    expect(Array.isArray(cycles)).toBe(true);
-    const orphans = await service.query(root, "orphans");
-    expect(Array.isArray(orphans)).toBe(true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});

package/src/gdgraph/staleness.test.ts

@@ -1,208 +0,0 @@
-// AFC-10 (flow 234, phase 2): the graph "staleness" signal must actually track
-// the five triggers the frozen AC3 names — new commit, untracked, delete,
-// rename, config change — and a git failure must never collapse into "fresh".
-//
-// Before this task, `graphMaybeStale` compared `.git/HEAD`'s own mtime to
-// `nodes.jsonl`'s. That misses every trigger here: `.git/HEAD` is a symbolic
-// ref ("ref: refs/heads/<branch>") whose CONTENT (and often mtime) does not
-// change on an ordinary commit to the current branch, and it never reflects
-// untracked/deleted/renamed working-tree state or a config-file edit at all.
-// These tests build a real git fixture per trigger (never the project repo
-// itself) and assert against `checkGraphStaleness`'s structured result.
-
-import { execFileSync } from "node:child_process";
-import { mkdir, mkdtemp, rm, utimes, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { afterEach, beforeEach, expect, test } from "bun:test";
-import { checkGraphStaleness, graphMaybeStale } from "./staleness";
-import { recordProvenance } from "../sync/provenance";
-
-let root: string;
-
-function git(cwd: string, args: string[]): void {
-  execFileSync("git", args, { cwd, stdio: "ignore" });
-}
-
-/**
- * A minimal built-graph fixture: a real git repo with one committed source
- * file, a `nodes.jsonl` "graph storage" file, and recorded build provenance
- * pointing at the current HEAD — i.e. the state right after a clean
- * `keryx gdgraph build` with nothing having moved since.
- */
-async function makeBuiltFixture(): Promise<string> {
-  const dir = await mkdtemp(path.join(tmpdir(), "keryx-staleness-"));
-  git(dir, ["init", "-q"]);
-  git(dir, ["config", "user.email", "test@test.com"]);
-  git(dir, ["config", "user.name", "test"]);
-  await mkdir(path.join(dir, "src"), { recursive: true });
-  await mkdir(path.join(dir, ".metaproject", "data", "gdgraph", "storage"), { recursive: true });
-  await writeFile(path.join(dir, "src", "a.ts"), "export const a = 1;\n");
-  await writeFile(
-    path.join(dir, ".metaproject", "data", "gdgraph", "storage", "nodes.jsonl"),
-    '{"id":"src/a.ts","kind":"file","path":"src/a.ts","language":"typescript"}\n',
-  );
-  git(dir, ["add", "-A"]);
-  git(dir, ["commit", "-q", "-m", "initial build fixture"]);
-  // `recordProvenance` reads `git rev-parse HEAD`, which fails with zero
-  // commits — it must run AFTER the first commit exists, or it silently
-  // no-ops (by design: "no-op outside a git repo", which a HEAD-less repo
-  // with no commits yet also satisfies). It is deliberately left UNCOMMITTED
-  // here, matching the real project's own state (`.provenance.json` sits
-  // modified/untracked in the working tree right after every build) — the
-  // staleness check must treat that as normal build residue, not a trigger.
-  await recordProvenance(dir, "gdgraph", new Date().toISOString());
-  // Ensure nodes.jsonl's mtime is not accidentally newer than a config file
-  // written a moment later in the same test (mtime resolution on some
-  // filesystems is coarse) by nudging it slightly into the past.
-  const past = new Date(Date.now() - 5000);
-  await utimes(path.join(dir, ".metaproject", "data", "gdgraph", "storage", "nodes.jsonl"), past, past);
-  return dir;
-}
-
-beforeEach(async () => {
-  root = await makeBuiltFixture();
-});
-
-afterEach(async () => {
-  await rm(root, { recursive: true, force: true });
-});
-
-test("AFC-10 control — a clean tree right after build reports fresh", async () => {
-  const result = await checkGraphStaleness(root);
-  expect(result.status).toBe("fresh");
-  expect(await graphMaybeStale(root)).toBe(false);
-});
-
-test("AFC-10 trigger 1/5 — a new commit since the build invalidates the snapshot", async () => {
-  await writeFile(path.join(root, "src", "b.ts"), "export const b = 1;\n");
-  git(root, ["add", "-A"]);
-  git(root, ["commit", "-q", "-m", "a new commit after the graph was built"]);
-
-  const result = await checkGraphStaleness(root);
-  expect(result.status).not.toBe("fresh");
-  expect(await graphMaybeStale(root)).toBe(true);
-});
-
-test("AFC-10 trigger 2/5 — an untracked file invalidates the snapshot", async () => {
-  await writeFile(path.join(root, "src", "untracked.ts"), "export const u = 1;\n");
-
-  const result = await checkGraphStaleness(root);
-  expect(result.status).not.toBe("fresh");
-  expect(await graphMaybeStale(root)).toBe(true);
-});
-
-test("AFC-10 trigger 3/5 — a deleted tracked file invalidates the snapshot", async () => {
-  await rm(path.join(root, "src", "a.ts"));
-
-  const result = await checkGraphStaleness(root);
-  expect(result.status).not.toBe("fresh");
-  expect(await graphMaybeStale(root)).toBe(true);
-});
-
-test("AFC-10 trigger 4/5 — a rename invalidates the snapshot even though file count and content are unchanged", async () => {
-  // The subtle case: `git mv` keeps the file count and byte content identical
-  // to the fixture's committed state — only the path moved.
-  git(root, ["mv", "src/a.ts", "src/a-renamed.ts"]);
-
-  const result = await checkGraphStaleness(root);
-  expect(result.status).not.toBe("fresh");
-  expect(await graphMaybeStale(root)).toBe(true);
-});
-
-test("AFC-10 trigger 5/5 — a gdgraph.config.json change invalidates the snapshot", async () => {
-  await writeFile(
-    path.join(root, ".metaproject", "gdgraph.config.json"),
-    JSON.stringify({ affected: { defaultDepth: 2 } }) + "\n",
-  );
-
-  const result = await checkGraphStaleness(root);
-  expect(result.status).not.toBe("fresh");
-  expect(await graphMaybeStale(root)).toBe(true);
-});
-
-test("AFC-10 group 3 — a git failure is reported as unknown, never as fresh", async () => {
-  // Delete the .git directory entirely so every git invocation the check
-  // makes fails (spawn succeeds, git exits non-zero / "not a git repository").
-  await rm(path.join(root, ".git"), { recursive: true, force: true });
-
-  const result = await checkGraphStaleness(root);
-  expect(result.status).toBe("unknown");
-  expect(result.reasons.length).toBeGreaterThan(0);
-  // The boolean back-compat wrapper must still never read as "fresh" (false)
-  // on a git failure — "unknown" collapses to "treat as maybe-stale", not to
-  // the safe-looking "false" the old mtime-diff check silently returned.
-  expect(await graphMaybeStale(root)).toBe(true);
-});
-
-test("AFC-10 — graph never built at all is reported as stale (not fresh), not a git failure", async () => {
-  await rm(path.join(root, ".metaproject", "data", "gdgraph", "storage", "nodes.jsonl"));
-
-  const result = await checkGraphStaleness(root);
-  expect(result.status).toBe("stale");
-  expect(await graphMaybeStale(root)).toBe(true);
-});
-
-// ---------------------------------------------------------------------------
-// T19 finding 3 (flow 234 review) — `git status --porcelain` prints paths
-// relative to the REPOSITORY ROOT, not to the directory git was invoked in.
-// The `.metaproject/` exclusion in `categorizeStatusLines` compared a bare
-// `.metaproject/` prefix against those repo-root-relative paths, which only
-// ever matches when the project root IS the git root. In a monorepo where the
-// project root sits below the git root, the prefix never matches, so the
-// graph's own build residue (`.provenance.json`, `artifacts/*` — expected to
-// sit modified/untracked right after every build) reads as a real untracked
-// file and the graph reports stale immediately after every clean build.
-// ---------------------------------------------------------------------------
-
-test("AFC-10 / T19 finding 3 — at the git root, the .metaproject exclusion behaves exactly as before", async () => {
-  // `root` (from `makeBuiltFixture`) already IS the git root — this is the
-  // control case the fix must not change. `--show-prefix` there resolves to
-  // "" and the fix must produce the identical "fresh" result as pre-fix.
-  const result = await checkGraphStaleness(root);
-  expect(result.status).toBe("fresh");
-});
-
-test("T19 finding 3 — a project root below the git root still excludes its own .metaproject build residue", async () => {
-  const gitRoot = await mkdtemp(path.join(tmpdir(), "keryx-staleness-monorepo-"));
-  try {
-    git(gitRoot, ["init", "-q"]);
-    git(gitRoot, ["config", "user.email", "test@test.com"]);
-    git(gitRoot, ["config", "user.name", "test"]);
-
-    const projectDir = path.join(gitRoot, "packages", "proj");
-    await mkdir(path.join(projectDir, "src"), { recursive: true });
-    await mkdir(path.join(projectDir, ".metaproject", "data", "gdgraph", "storage"), { recursive: true });
-    await writeFile(path.join(projectDir, "src", "a.ts"), "export const a = 1;\n");
-    await writeFile(
-      path.join(projectDir, ".metaproject", "data", "gdgraph", "storage", "nodes.jsonl"),
-      '{"id":"src/a.ts","kind":"file","path":"src/a.ts","language":"typescript"}\n',
-    );
-    git(gitRoot, ["add", "-A"]);
-    git(gitRoot, ["commit", "-q", "-m", "initial monorepo build fixture"]);
-
-    // Mirrors `makeBuiltFixture`: `recordProvenance` leaves `.provenance.json`
-    // UNCOMMITTED, exactly like a real `keryx gdgraph build` does — this is
-    // the graph's own bookkeeping the exclusion exists to skip, and (per the
-    // reviewer's repro) the ONLY dirty entry in the working tree here.
-    await recordProvenance(projectDir, "gdgraph", new Date().toISOString());
-    const past = new Date(Date.now() - 5000);
-    await utimes(
-      path.join(projectDir, ".metaproject", "data", "gdgraph", "storage", "nodes.jsonl"),
-      past,
-      past,
-    );
-
-    const result = await checkGraphStaleness(projectDir);
-    // Before the fix: `git status --porcelain` (run with cwd=projectDir)
-    // prints "packages/proj/.metaproject/data/gdgraph/.provenance.json",
-    // which does not start with the bare ".metaproject/" prefix the old
-    // check compared against — so it read as a real untracked file and this
-    // was "stale" on a repo with nothing but the graph's own residue dirty.
-    expect(result.status).toBe("fresh");
-    expect(result.reasons).toEqual([]);
-    expect(await graphMaybeStale(projectDir)).toBe(false);
-  } finally {
-    await rm(gitRoot, { recursive: true, force: true });
-  }
-});

package/src/gdgraph/symbol.test.ts

@@ -1,89 +0,0 @@
-import { expect, test } from "bun:test";
-import { querySymbol, resolveSymbols, transitiveCallers } from "./symbol";
-import type { GraphData, SymbolNode, CallEdge } from "./types";
-
-function sym(id: string, name: string, path: string, startLine: number): SymbolNode {
-  return { id, kind: "function", path, name, container: null, startLine, endLine: startLine + 5, language: "typescript" };
-}
-function call(from: string, to: string, resolved: boolean): CallEdge {
-  return { id: `${from}->${to}`, from, to, kind: resolved ? "calls" : "unresolved-call", resolved };
-}
-
-const A = sym("src/a.ts#foo", "foo", "src/a.ts", 10);
-const B = sym("src/b.ts#bar", "bar", "src/b.ts", 20);
-const C = sym("src/c.ts#Foo", "Foo", "src/c.ts", 5);
-
-const GRAPH: GraphData = {
-  nodes: [],
-  edges: [],
-  symbols: [A, B, C],
-  calls: [
-    call("src/b.ts#bar", "src/a.ts#foo", true), // bar calls foo
-    call("src/a.ts#foo", "src/c.ts#Foo", true), // foo calls Foo
-    call("src/a.ts#foo", "someUnknown.method", false), // foo calls unresolved
-  ],
-};
-
-test("resolveSymbols prefers exact name, then case-insensitive, then substring", () => {
-  expect(resolveSymbols(GRAPH.symbols!, "foo").map((s) => s.id)).toEqual(["src/a.ts#foo"]);
-  // case-insensitive tier only when no exact: "FOO" -> foo (exact 'foo'? no; ci matches foo AND Foo)
-  const ci = resolveSymbols(GRAPH.symbols!, "FOO").map((s) => s.name).sort();
-  expect(ci).toEqual(["Foo", "foo"]);
-  // substring tier
-  expect(resolveSymbols(GRAPH.symbols!, "ba").map((s) => s.name)).toEqual(["bar"]);
-});
-
-test("querySymbol returns definition, callers, and callees", () => {
-  const r = querySymbol(GRAPH, "foo");
-  expect(r.definitions.map((d) => d.id)).toEqual(["src/a.ts#foo"]);
-  // bar calls foo -> caller
-  expect(r.callers.map((c) => c.label)).toEqual(["bar (src/b.ts:20)"]);
-  // foo calls Foo (resolved) + someUnknown.method (unresolved)
-  const labels = r.callees.map((c) => c.label);
-  expect(labels).toContain("Foo (src/c.ts:5)");
-  expect(labels).toContain("someUnknown.method");
-  const unresolved = r.callees.find((c) => c.label === "someUnknown.method");
-  expect(unresolved?.resolved).toBe(false);
-});
-
-test("querySymbol on no match returns empty definitions", () => {
-  expect(querySymbol(GRAPH, "nonexistent").definitions).toEqual([]);
-});
-
-test("querySymbol tolerates a graph with no symbol layer", () => {
-  const r = querySymbol({ nodes: [], edges: [] }, "foo");
-  expect(r.definitions).toEqual([]);
-  expect(r.callers).toEqual([]);
-});
-
-test("transitiveCallers walks the reverse call graph with hop distances", () => {
-  // chain: baz -> bar -> foo (bar calls foo, baz calls bar)
-  const graph: GraphData = {
-    nodes: [],
-    edges: [],
-    symbols: [A, B, sym("src/d.ts#baz", "baz", "src/d.ts", 40)],
-    calls: [
-      call("src/b.ts#bar", "src/a.ts#foo", true),
-      call("src/d.ts#baz", "src/b.ts#bar", true),
-    ],
-  };
-  const impact = transitiveCallers(graph, ["src/a.ts#foo"], 5);
-  const byName = Object.fromEntries(impact.map((n) => [n.label.split(" ")[0], n.hop]));
-  expect(byName["bar"]).toBe(1);
-  expect(byName["baz"]).toBe(2);
-  expect(impact.some((n) => n.label.startsWith("foo"))).toBe(false); // seed excluded
-});
-
-test("transitiveCallers respects maxDepth", () => {
-  const graph: GraphData = {
-    nodes: [],
-    edges: [],
-    symbols: [A, B, sym("src/d.ts#baz", "baz", "src/d.ts", 40)],
-    calls: [
-      call("src/b.ts#bar", "src/a.ts#foo", true),
-      call("src/d.ts#baz", "src/b.ts#bar", true),
-    ],
-  };
-  const impact = transitiveCallers(graph, ["src/a.ts#foo"], 1);
-  expect(impact.map((n) => n.label.split(" ")[0])).toEqual(["bar"]); // baz is hop 2, excluded
-});

package/src/gdgraph/symbols-capability.test.ts

@@ -1,138 +0,0 @@
-import { expect, test } from "bun:test";
-import {
-  isTreesitterEnabled,
-  requireSymbols,
-  setTreesitterEnabled,
-  SymbolsUnavailableError,
-  TREESITTER_CAPABILITY,
-  type SymbolsLayerCarrier,
-} from "./symbols-capability";
-import type { GrammarDiagnosis } from "./treesitter/adapter";
-
-test("enable adds the capability entry to an empty manifest", () => {
-  const next = setTreesitterEnabled({}, true);
-  expect(isTreesitterEnabled(next)).toBe(true);
-  const caps = (next.modules as any).gdgraph.capabilities;
-  expect(caps).toHaveLength(1);
-  expect(caps[0]).toMatchObject({ id: TREESITTER_CAPABILITY, enabled: true, kind: "ceiling" });
-});
-
-test("disable flips enabled to false", () => {
-  const enabled = setTreesitterEnabled({}, true);
-  const disabled = setTreesitterEnabled(enabled, false);
-  expect(isTreesitterEnabled(disabled)).toBe(false);
-});
-
-test("is idempotent — never duplicates the capability entry", () => {
-  let m: Record<string, unknown> = {};
-  m = setTreesitterEnabled(m, true);
-  m = setTreesitterEnabled(m, true);
-  const caps = (m.modules as any).gdgraph.capabilities.filter(
-    (c: any) => c.id === TREESITTER_CAPABILITY,
-  );
-  expect(caps).toHaveLength(1);
-});
-
-test("preserves other gdgraph capabilities and other modules", () => {
-  const manifest = {
-    modules: {
-      gdgraph: { enabled: true, capabilities: [{ id: "gdgraph.other", enabled: true }] },
-      security: { enabled: true },
-    },
-    schemaVersion: 1,
-  };
-  const next = setTreesitterEnabled(manifest, true) as any;
-  const ids = next.modules.gdgraph.capabilities.map((c: any) => c.id).sort();
-  expect(ids).toEqual(["gdgraph.other", "gdgraph.treesitter"]);
-  expect(next.modules.security).toEqual({ enabled: true });
-  expect(next.schemaVersion).toBe(1);
-});
-
-// --- AFC-13 / AC5 requirement 2: requireSymbols gives a typed, actionable
-// error — never undefined, never an empty result, never a generic Error. ---
-
-test("AC5.req2 — requireSymbols returns graph.symbols when the symbol layer is present (including an empty array — the layer RAN, it just found nothing)", () => {
-  const withSymbols = { symbols: [{ id: "a" }] };
-  expect(requireSymbols(withSymbols)).toEqual(withSymbols.symbols);
-
-  const ranButEmpty = { symbols: [] };
-  expect(requireSymbols(ranButEmpty)).toEqual([]);
-});
-
-test("AC5.req2 — requireSymbols throws SymbolsUnavailableError (not undefined, not an empty result, not a generic Error) when the symbol layer never ran", () => {
-  // A `GraphData`-shaped object with no `symbols` key — exactly what the
-  // graph looks like when the symbol layer never ran. The cast (rather than a
-  // bare literal) is only to satisfy TS's weak-object-literal check, which
-  // otherwise flags "no properties in common" for a fresh literal compared
-  // against a type with a single optional property; a real `GraphData` value
-  // (a named type, not a fresh literal) never triggers this.
-  const graphWithNoLayer = { nodes: [], edges: [] } as unknown as SymbolsLayerCarrier;
-  expect(() => requireSymbols(graphWithNoLayer)).toThrow(SymbolsUnavailableError);
-
-  let caught: unknown;
-  try {
-    requireSymbols(graphWithNoLayer);
-  } catch (err) {
-    caught = err;
-  }
-  expect(caught).toBeInstanceOf(SymbolsUnavailableError);
-  expect(caught).toBeInstanceOf(Error);
-  const typed = caught as SymbolsUnavailableError;
-  // Typed and actionable: a stable `code`, a non-empty `remedy`, a non-empty
-  // `message` — not a bare string thrown, not `err.message === ""`.
-  expect(typed.code).toBe("no-symbol-layer");
-  expect(typeof typed.remedy).toBe("string");
-  expect(typed.remedy.length).toBeGreaterThan(0);
-  expect(typed.message.length).toBeGreaterThan(0);
-});
-
-// --- AFC-13 / AC5 requirement 3: missing vs incompatible must be
-// distinguishable, not collapsed into one outcome. ---
-
-test("AC5.req3 — requireSymbols reports grammar-missing when diagnoses say the grammar never resolved", () => {
-  const diagnoses: GrammarDiagnosis[] = [
-    { language: "typescript", status: "missing", reason: 'grammar asset "tree-sitter-typescript" is not resolved' },
-  ];
-  let caught: SymbolsUnavailableError | undefined;
-  try {
-    requireSymbols({}, diagnoses);
-  } catch (err) {
-    caught = err as SymbolsUnavailableError;
-  }
-  expect(caught?.code).toBe("grammar-missing");
-  expect(caught?.message).toContain("typescript");
-});
-
-test("AC5.req3 — requireSymbols reports grammar-incompatible when diagnoses say the grammar resolved but failed to load (ABI mismatch), and this is a DIFFERENT code/message/remedy than grammar-missing", () => {
-  const incompatible: GrammarDiagnosis[] = [
-    {
-      language: "typescript",
-      status: "incompatible",
-      reason: 'grammar at "/cache/tree-sitter-typescript" failed to load (likely an ABI/version mismatch): Incompatible language version 13. Expected minimum 14',
-    },
-  ];
-  let caught: SymbolsUnavailableError | undefined;
-  try {
-    requireSymbols({}, incompatible);
-  } catch (err) {
-    caught = err as SymbolsUnavailableError;
-  }
-  expect(caught?.code).toBe("grammar-incompatible");
-  expect(caught?.message).toContain("incompatible");
-
-  // Same missing-grammar case as the previous test, compared directly here so
-  // the distinction is asserted in one place: two different real-world
-  // conditions must never collapse into the same code/message/remedy.
-  const missing: GrammarDiagnosis[] = [
-    { language: "typescript", status: "missing", reason: 'grammar asset "tree-sitter-typescript" is not resolved' },
-  ];
-  let missingCaught: SymbolsUnavailableError | undefined;
-  try {
-    requireSymbols({}, missing);
-  } catch (err) {
-    missingCaught = err as SymbolsUnavailableError;
-  }
-  expect(missingCaught?.code).not.toBe(caught?.code);
-  expect(missingCaught?.message).not.toBe(caught?.message);
-  expect(missingCaught?.remedy).not.toBe(caught?.remedy);
-});