pi-plans 0.2.0 → 0.3.1

package/tests/code-graph-index.test.ts

@@ -0,0 +1,175 @@
+/**
+ * End-to-end index integration test: write a small fixture into a git
+ * worktree, run the indexer, and verify function rows and edges.
+ */
+
+import { test } from "node:test";
+import * as assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { spawnSync } from "node:child_process";
+import { Store } from "../src/code-graph/store.ts";
+import { makeBackend } from "../src/code-graph/parsers/javascript.ts";
+import { PythonBackend } from "../src/code-graph/parsers/python.ts";
+import { runIndex } from "../src/code-graph/indexer.ts";
+import { loadGraphRuntime } from "../src/code-graph/runtime.ts";
+import { screeningQuery } from "../src/code-graph/screening.ts";
+import { hashText } from "../src/code-graph/parser.ts";
+import type { ParserBackend } from "../src/code-graph/parser.ts";
+import type { Language } from "../src/code-graph/types.ts";
+
+function git(cwd: string, args: string[]): string {
+	const env: Record<string, string | undefined> = { ...process.env };
+	for (const key of ["GIT_DIR", "GIT_COMMON_DIR", "GIT_WORK_TREE"]) delete env[key];
+	const result = spawnSync("git", args, { cwd, env, encoding: "utf8" });
+	return (result.stdout ?? "").trim();
+}
+
+function initRepo(): { worktreeRoot: string; cleanup: () => void } {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "code-graph-index-"));
+	git(dir, ["init", "--initial-branch=main"]);
+	git(dir, ["config", "user.email", "test@example.com"]);
+	git(dir, ["config", "user.name", "test"]);
+	const subdir = path.join(dir, "pkg");
+	fs.mkdirSync(subdir, { recursive: true });
+	fs.writeFileSync(path.join(subdir, "math.js"), `function add(a, b) { return a + b; }\nfunction mul(a, b) { return a * b; }\nfunction same() { return 1; }\nfunction same() { return 2; }\n`);
+	fs.writeFileSync(path.join(subdir, "note.py"), `def hello(name):\n    return f"hi {name}"\n`);
+	fs.writeFileSync(path.join(subdir, "api.ts"), `function overloaded(value: string): string;\nfunction overloaded(value: number): number;\nfunction overloaded(value: string | number): string | number { return value; }\n\nclass Accessors {\n\tget value(): string { return "value"; }\n\tset value(next: string) { void next; }\n}\n`);
+	git(subdir, ["add", "-A"]);
+	git(subdir, ["commit", "-m", "init"]);
+	return {
+		worktreeRoot: subdir,
+		cleanup: () => {
+			try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+		},
+	};
+}
+
+test("runIndex indexes files, writes rows, and screening excludes full_code", async (t) => {
+	const { worktreeRoot, cleanup } = initRepo();
+	t.after(cleanup);
+	const runtime = await loadGraphRuntime();
+	if (!runtime.status.parserAvailable || !runtime.status.sqliteAvailable) return;
+	const ParserCtor = runtime.runtime.parser.Parser as unknown as new () => {
+		parse(input: string | Buffer): unknown;
+		setLanguage(language: unknown): void;
+	};
+	const parsers: Record<Language, ParserBackend> = {
+		javascript: makeBackend("javascript", ParserCtor, runtime.runtime.parser.javascript),
+		typescript: makeBackend("typescript", ParserCtor, runtime.runtime.parser.typescript),
+		tsx: makeBackend("tsx", ParserCtor, runtime.runtime.parser.tsx),
+		python: new PythonBackend(ParserCtor, runtime.runtime.parser.python),
+	};
+	const sqlite = await import("node:sqlite");
+	const commonDir = git(worktreeRoot, ["rev-parse", "--git-common-dir"]);
+	const dbDir = path.join(path.resolve(worktreeRoot, commonDir), "pi_plans");
+	fs.mkdirSync(dbDir, { recursive: true });
+	const dbPath = path.join(dbDir, "code_graph.db");
+	try { fs.unlinkSync(dbPath); } catch { /* ignore */ }
+	const store = new Store(
+		{ dbPath, worktreeRoot, gitCommonDir: path.resolve(worktreeRoot, commonDir) },
+		sqlite,
+	);
+	t.after(() => {
+		store.close();
+		try { fs.unlinkSync(dbPath); } catch { /* ignore */ }
+	});
+	const report = await runIndex({ store, worktreeRoot, parsers });
+	assert.equal(report.filesScanned >= 2, true, `expected >=2 files, got ${report.filesScanned}`);
+	assert.equal(report.functionsIndexed >= 3, true, `expected >=3 functions, got ${report.functionsIndexed}`);
+	const screening = screeningQuery({ store, functionNameLike: "add", limit: 50 });
+	assert.equal(screening.length, 1);
+	assert.equal(screening[0].fullCode, undefined);
+	assert.equal(screening[0].functionName, "add");
+	const same = screeningQuery({ store, functionNameLike: "same", limit: 50 });
+	assert.deepEqual(same.map((item) => item.functionName), ["same", "same#2"]);
+	const manifestNames = store.read(() =>
+		store.db.prepare("SELECT function_name FROM file_entries WHERE file_dir = '.' AND file_name = 'math.js' AND function_name IS NOT NULL ORDER BY ordinal").all(),
+	) as Array<{ function_name: string }>;
+	assert.deepEqual(manifestNames.map((row) => row.function_name), ["add", "mul", "same", "same#2"]);
+	const overload = store.read(() =>
+		store.db.prepare("SELECT function_name, overload_signatures FROM functions WHERE file_name = 'api.ts' AND function_name = 'overloaded'").all(),
+	) as Array<{ function_name: string; overload_signatures: string | null }>;
+	assert.equal(overload.length, 1);
+	assert.equal(overload[0].function_name, "overloaded");
+	assert.deepEqual(JSON.parse(overload[0].overload_signatures ?? "[]"), [
+		"function overloaded(value: string): string;",
+		"function overloaded(value: number): number;",
+	]);
+	const accessorRows = store.read(() =>
+		store.db.prepare("SELECT function_name, kind FROM functions WHERE file_name = 'api.ts' AND kind = 'accessor' ORDER BY provenance_start_byte").all(),
+	) as Array<{ function_name: string; kind: string }>;
+	assert.deepEqual(accessorRows.map((row) => [row.function_name, row.kind]), [
+		["Accessors.value", "accessor"],
+		["Accessors.value#2", "accessor"],
+	]);
+	const initialSource = fs.readFileSync(path.join(worktreeRoot, "math.js"), "utf8");
+	const initialFile = store.read(() =>
+		store.db.prepare("SELECT source_hash FROM files WHERE file_dir = '.' AND file_name = 'math.js'").get(),
+	) as { source_hash: string };
+	assert.equal(initialFile.source_hash, hashText(initialSource));
+
+	const mul = screeningQuery({ store, functionNameLike: "mul", limit: 50 });
+	assert.equal(mul.length, 1);
+	assert.equal(mul[0].functionName, "mul");
+
+	fs.writeFileSync(path.join(worktreeRoot, "math.js"), `function add(a, b) { return a + b; }\nfunction mul(a, b) { return a * b; }\nfunction same() { return 3; }\nfunction later() { return same(); }\n`);
+	const reindexReport = await runIndex({ store, worktreeRoot, parsers, reindex: true });
+	assert.equal(reindexReport.conflicts >= 1, true);
+	const updatedSource = fs.readFileSync(path.join(worktreeRoot, "math.js"), "utf8");
+	const updatedFile = store.read(() =>
+		store.db.prepare("SELECT source_hash FROM files WHERE file_dir = '.' AND file_name = 'math.js'").get(),
+	) as { source_hash: string };
+	assert.equal(updatedFile.source_hash, hashText(updatedSource));
+	const names = store.read(() =>
+		store.db.prepare("SELECT function_name FROM functions WHERE file_dir = '.' AND file_name = 'math.js' ORDER BY provenance_start_byte").all(),
+	) as Array<{ function_name: string }>;
+	const edgeRows = store.read(() =>
+		store.db.prepare("SELECT from_function FROM call_edges WHERE from_file_dir = '.' AND from_file_name = 'math.js' ORDER BY from_function").all(),
+	) as Array<{ from_function: string }>;
+	assert.ok(edgeRows.some((row) => row.from_function === "later"));
+	assert.deepEqual(names.map((row) => row.function_name), ["add", "mul", "same", "later"]);
+	const remainingManifest = store.read(() =>
+		store.db.prepare("SELECT function_name FROM file_entries WHERE file_dir = '.' AND file_name = 'math.js' AND function_name IS NOT NULL ORDER BY ordinal").all(),
+	) as Array<{ function_name: string }>;
+	assert.deepEqual(remainingManifest.map((row) => row.function_name), ["add", "mul", "same", "later"]);
+});
+
+test("runIndex with opts.paths indexes only hit paths and purges missing ones", async (t) => {
+	const { worktreeRoot, cleanup } = initRepo();
+	t.after(cleanup);
+	const runtime = await loadGraphRuntime();
+	if (!runtime.status.parserAvailable || !runtime.status.sqliteAvailable) return;
+	const ParserCtor = runtime.runtime.parser.Parser as unknown as new () => {
+		parse(input: string | Buffer): unknown;
+		setLanguage(language: unknown): void;
+	};
+	const parsers: Record<Language, ParserBackend> = {
+		javascript: makeBackend("javascript", ParserCtor, runtime.runtime.parser.javascript),
+		typescript: makeBackend("typescript", ParserCtor, runtime.runtime.parser.typescript),
+		tsx: makeBackend("tsx", ParserCtor, runtime.runtime.parser.tsx),
+		python: new PythonBackend(ParserCtor, runtime.runtime.parser.python),
+	};
+	const stateRoot = path.join(worktreeRoot, ".git", "pi_plans");
+	fs.mkdirSync(stateRoot, { recursive: true });
+	const store = new Store({ dbPath: path.join(stateRoot, "code_graph.db"), worktreeRoot, gitCommonDir: path.join(worktreeRoot, ".git") }, runtime.runtime.sqlite);
+	t.after(() => store.close());
+	await runIndex({ store, worktreeRoot, parsers });
+
+	// Modify one file, delete another.
+	fs.writeFileSync(path.join(worktreeRoot, "math.js"), "function add(a, b) { return a + b + 1; }\n");
+	fs.rmSync(path.join(worktreeRoot, "note.py"));
+
+	const report = await runIndex({ store, worktreeRoot, parsers, paths: ["./math.js", "./note.py"] });
+	assert.deepEqual(report.reindexedPaths.sort(), ["./math.js"]);
+	assert.deepEqual(report.purgedPaths.sort(), ["./note.py"]);
+	const noteRows = store.read(() => store.db.prepare("SELECT COUNT(*) AS c FROM files WHERE file_name = 'note.py'").get()) as { c: number };
+	assert.equal(noteRows.c, 0, "deleted file rows must be purged");
+	const noteFunctions = store.read(() => store.db.prepare("SELECT COUNT(*) AS c FROM functions WHERE file_name = 'note.py'").get()) as { c: number };
+	assert.equal(noteFunctions.c, 0);
+	const apiRows = store.read(() => store.db.prepare("SELECT COUNT(*) AS c FROM files WHERE file_name = 'api.ts'").get()) as { c: number };
+	assert.equal(apiRows.c, 1, "untouched files must remain indexed");
+	const mathHash = store.read(() => store.db.prepare("SELECT source_hash FROM files WHERE file_name = 'math.js'").get()) as { source_hash: string };
+	assert.equal(mathHash.source_hash, hashText("function add(a, b) { return a + b + 1; }\n"));
+});

package/tests/code-graph-loop.e2e.test.ts

@@ -0,0 +1,159 @@
+/**
+ * End-to-end code-graph loop test: chore commit + snapshot → DB-first
+ * mutation → apply → drift → final-commit → clean init; plus the human-edit
+ * (update-graph) and deletion branches.
+ */
+
+import { test } from "node:test";
+import * as assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { spawnSync } from "node:child_process";
+import { Store } from "../src/code-graph/store.ts";
+import { runIndex } from "../src/code-graph/indexer.ts";
+import { materializeFile } from "../src/code-graph/materialize.ts";
+import { makeBackend } from "../src/code-graph/parsers/javascript.ts";
+import { hashText } from "../src/code-graph/parser.ts";
+import { loadGraphRuntime } from "../src/code-graph/runtime.ts";
+import { computeDrift } from "../src/code-graph/commands.ts";
+import { gitAddAllAndCommit, gitHead } from "../src/code-graph/git.ts";
+import { finalCommit } from "../tools/plans.ts";
+import type { ParserBackend } from "../src/code-graph/parser.ts";
+import type { Language } from "../src/code-graph/types.ts";
+
+function git(cwd: string, args: string[]): { code: number; stdout: string } {
+	const env: Record<string, string | undefined> = { ...process.env };
+	for (const key of ["GIT_DIR", "GIT_COMMON_DIR", "GIT_WORK_TREE"]) delete env[key];
+	const result = spawnSync("git", args, { cwd, env, encoding: "utf8" });
+	return { code: result.status ?? 1, stdout: result.stdout ?? "" };
+}
+
+function initRepo(): { root: string; cleanup: () => void } {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "code-graph-loop-"));
+	git(dir, ["init", "--initial-branch=main"]);
+	git(dir, ["config", "user.email", "test@example.com"]);
+	git(dir, ["config", "user.name", "test"]);
+	fs.writeFileSync(path.join(dir, "math.js"), "function add(a, b) { return a + b; }\n");
+	fs.writeFileSync(path.join(dir, "helper.ts"), "function twice(n: number): number { return n * 2; }\n");
+	git(dir, ["add", "-A"]);
+	git(dir, ["commit", "-m", "init"]);
+	return {
+		root: dir,
+		cleanup: () => {
+			try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+		},
+	};
+}
+
+function makeNotify(): { lines: string[]; notify: (message: string, kind?: "info" | "warning" | "error") => void } {
+	const lines: string[] = [];
+	return { lines, notify: (message) => { lines.push(message); } };
+}
+
+test("closed loop: init → mutation → apply → drift → final-commit → clean init", async (t) => {
+	const runtime = await loadGraphRuntime();
+	if (!runtime.status.parserAvailable || !runtime.status.sqliteAvailable) return;
+	const { root, cleanup } = initRepo();
+	t.after(cleanup);
+
+	const stateRoot = path.join(root, ".git", "pi_plans");
+	fs.mkdirSync(stateRoot, { recursive: true });
+	const dbPath = path.join(stateRoot, "code_graph.db");
+	const store = new Store({ dbPath, worktreeRoot: root, gitCommonDir: path.join(root, ".git") }, runtime.runtime.sqlite);
+	t.after(() => store.close());
+
+	const ParserCtor = runtime.runtime.parser.Parser as unknown as new () => {
+		parse(input: string | Buffer): unknown;
+		setLanguage(language: unknown): void;
+	};
+	const parsers: Record<Language, ParserBackend> = {
+		javascript: makeBackend("javascript", ParserCtor, runtime.runtime.parser.javascript),
+		typescript: makeBackend("typescript", ParserCtor, runtime.runtime.parser.typescript),
+		tsx: makeBackend("tsx", ParserCtor, runtime.runtime.parser.tsx),
+		python: new (await import("../src/code-graph/parsers/python.ts")).PythonBackend(ParserCtor, runtime.runtime.parser.python),
+	};
+
+	// 1. init-graph: dirty? no (we committed). index + snapshot.
+	fs.writeFileSync(path.join(root, "dirty.js"), "// stray\n");
+	const chore = gitAddAllAndCommit(root, "chore(code-graph): pre-init snapshot");
+	assert.notEqual(chore, "", "chore commit created for dirty tree");
+	await runIndex({ store, worktreeRoot: root, parsers });
+	store.upsertSnapshot(gitHead(root), []);
+	assert.ok(store.readLatestSnapshot(), "snapshot written");
+
+	// 2. DB-first mutation: update-function on math.js:add. Maintains
+	// functions.full_code and files.source_text (the canonical new content).
+	const newBody = "function add(a, b) { return a + b + 100; }\n";
+	const manifest = store.read(() =>
+		store.db.prepare(`SELECT ordinal, start_byte, end_byte, text FROM file_entries WHERE file_name = 'math.js' ORDER BY ordinal`).all(),
+	) as Array<{ ordinal: number; start_byte: number; end_byte: number; text: string }>;
+	void manifest;
+	store.tx(() => {
+		store.db
+			.prepare(`UPDATE functions SET full_code = ?, full_code_hash = ?, render_code = ?, render_code_hash = ? WHERE file_name = 'math.js' AND function_name = 'add'`)
+			.run(newBody, "h1", newBody, "h1");
+		const manifest2 = manifest;
+		for (const row of manifest2) {
+			if (!row.text.includes("return a + b;")) continue;
+			const delta = newBody.length - row.text.length;
+			store.db.prepare(`UPDATE file_entries SET text = ?, end_byte = ? WHERE file_name = 'math.js' AND ordinal = ?`).run(newBody, row.end_byte + delta, row.ordinal);
+		}
+		store.db.prepare(`UPDATE files SET source_text = ?, source_hash = ?, pending_kind = 'update' WHERE file_name = 'math.js'`).run(newBody, hashText(newBody));
+		store.db.prepare(`INSERT INTO change_log (kind, detail, recorded_at) VALUES ('update-function', './math.js:add', ?)`).run(new Date().toISOString());
+	});
+
+	// 3. drift: pending reported, ok-with-note semantics → recommendation = apply.
+	let drift = computeDrift(store, root);
+	assert.ok(drift.pending.some((item) => item.path === "./math.js" && item.kind === "update"));
+
+	// 4. apply: writes the file, clears pending.
+	const applied = materializeFile(store, root, ".", "math.js");
+	assert.equal(applied.status, "ok");
+	assert.ok(fs.readFileSync(path.join(root, "math.js"), "utf8").includes("+ 100"));
+	drift = computeDrift(store, root);
+	assert.equal(drift.pending.length, 0, "pending cleared after apply");
+
+	// 5. final-commit: drift clean → commits; second call is a no-op.
+	const commit1 = await finalCommit(root, "feat(loop): add +100");
+	assert.equal(commit1.ok, true);
+	assert.equal(commit1.noop, false);
+	assert.ok(commit1.committed);
+	const commit2 = await finalCommit(root, "noop attempt");
+	assert.equal(commit2.ok, true);
+	assert.equal(commit2.noop, true, "clean tree is a safe no-op");
+
+	// 6. Human-edit branch: change source directly, update-graph reindexes.
+	fs.writeFileSync(path.join(root, "helper.ts"), "function twice(n: number): number { return n * 3; }\n");
+	drift = computeDrift(store, root);
+	assert.ok(drift.hashDrift.some((item) => item.path === "./helper.ts" && item.kind === "hash-mismatch"));
+	const upd = await runIndex({ store, worktreeRoot: root, parsers, paths: ["./helper.ts"] });
+	assert.deepEqual(upd.reindexedPaths, ["./helper.ts"]);
+	drift = computeDrift(store, root);
+	assert.ok(!drift.hashDrift.some((item) => item.path === "./helper.ts"));
+
+	// 7. Deletion branch: remove file, update-graph purges rows; apply does not resurrect.
+	fs.rmSync(path.join(root, "helper.ts"));
+	drift = computeDrift(store, root);
+	assert.ok(drift.hashDrift.some((item) => item.path === "./helper.ts"));
+	const upd2 = await runIndex({ store, worktreeRoot: root, parsers, paths: ["./helper.ts"] });
+	assert.deepEqual(upd2.purgedPaths, ["./helper.ts"]);
+	const applyDeleted = materializeFile(store, root, ".", "helper.ts");
+	assert.equal(applyDeleted.status, "error", "row gone; not resurrected");
+	assert.equal(fs.existsSync(path.join(root, "helper.ts")), false);
+
+	// 8. final-commit with pending set must refuse.
+	store.tx(() => {
+		store.db.prepare(`UPDATE files SET pending_kind = 'update' WHERE file_name = 'math.js'`).run();
+	});
+	const refused = await finalCommit(root, "should refuse");
+	assert.equal(refused.ok, false);
+	assert.match(refused.reason ?? "", /apply-graph/);
+	store.tx(() => {
+		store.db.prepare(`UPDATE files SET pending_kind = NULL WHERE file_name = 'math.js'`).run();
+	});
+
+	const { lines, notify } = makeNotify();
+	void notify;
+	assert.ok(lines !== undefined);
+});

package/tests/code-graph-mutations.test.ts

@@ -0,0 +1,117 @@
+/**
+ * Tool-path mutation tests against src/code-graph/mutations.ts: real indexer
+ * output (multi-function file with inter-function gaps), exact post-apply
+ * bytes, zero-match refusal, and the full mutation→apply convergence.
+ */
+
+import { test } from "node:test";
+import * as assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { spawnSync } from "node:child_process";
+import { Store } from "../src/code-graph/store.ts";
+import { runIndex } from "../src/code-graph/indexer.ts";
+import { materializeFile } from "../src/code-graph/materialize.ts";
+import { makeBackend } from "../src/code-graph/parsers/javascript.ts";
+import { PythonBackend } from "../src/code-graph/parsers/python.ts";
+import { loadGraphRuntime } from "../src/code-graph/runtime.ts";
+import { updateFunction, updateFile, deleteFile, listPending } from "../src/code-graph/mutations.ts";
+import type { ParserBackend } from "../src/code-graph/parser.ts";
+import type { Language } from "../src/code-graph/types.ts";
+
+function git(cwd: string, args: string[]): void {
+	const env: Record<string, string | undefined> = { ...process.env };
+	for (const key of ["GIT_DIR", "GIT_COMMON_DIR", "GIT_WORK_TREE"]) delete env[key];
+	spawnSync("git", args, { cwd, env, encoding: "utf8" });
+}
+
+// Two functions with a comment gap between them — the offset-propagation case.
+const SOURCE = "function first(a) { return a + 1; }\n// inter-function gap\nfunction second(b) { return b * 2; }\n";
+const NEW_FIRST = "function first(a) { return a + 42; }";
+
+function initRepo(): { root: string; cleanup: () => void } {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "code-graph-mut-"));
+	git(dir, ["init", "--initial-branch=main"]);
+	git(dir, ["config", "user.email", "test@example.com"]);
+	git(dir, ["config", "user.name", "test"]);
+	fs.writeFileSync(path.join(dir, "two.js"), SOURCE);
+	git(dir, ["add", "-A"]);
+	git(dir, ["commit", "-m", "init"]);
+	return {
+		root: dir,
+		cleanup: () => {
+			try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+		},
+	};
+}
+
+test("updateFunction propagates offsets, rebuilds source exactly, and applies byte-for-byte", async (t) => {
+	const runtime = await loadGraphRuntime();
+	if (!runtime.status.parserAvailable || !runtime.status.sqliteAvailable) return;
+	const { root, cleanup } = initRepo();
+	t.after(cleanup);
+	const stateRoot = path.join(root, ".git", "pi_plans");
+	fs.mkdirSync(stateRoot, { recursive: true });
+	const store = new Store({ dbPath: path.join(stateRoot, "g.db"), worktreeRoot: root, gitCommonDir: path.join(root, ".git") }, runtime.runtime.sqlite);
+	t.after(() => store.close());
+	const ParserCtor = runtime.runtime.parser.Parser as unknown as new () => {
+		parse(input: string | Buffer): unknown;
+		setLanguage(language: unknown): void;
+	};
+	const parsers: Record<Language, ParserBackend> = {
+		javascript: makeBackend("javascript", ParserCtor, runtime.runtime.parser.javascript),
+		typescript: makeBackend("typescript", ParserCtor, runtime.runtime.parser.typescript),
+		tsx: makeBackend("tsx", ParserCtor, runtime.runtime.parser.tsx),
+		python: new PythonBackend(ParserCtor, runtime.runtime.parser.python),
+	};
+	await runIndex({ store, worktreeRoot: root, parsers });
+
+	const result = updateFunction(store, { fileDir: ".", fileName: "two.js", functionName: "first", fullCode: NEW_FIRST });
+	assert.equal(result.ok, true, result.reason ?? "");
+
+	// Rebuilt source keeps the gap and the untouched second function intact.
+	const rebuilt = store.read(() =>
+		store.db.prepare(`SELECT source_text, pending_kind FROM files WHERE file_name = 'two.js'`).get(),
+	) as { source_text: string; pending_kind: string };
+	assert.equal(rebuilt.pending_kind, "update");
+	const expected = NEW_FIRST + "\n// inter-function gap\nfunction second(b) { return b * 2; }\n";
+	assert.equal(rebuilt.source_text, expected, "gap + later function preserved with shifted offsets");
+
+	// Apply writes the exact bytes; pending cleared; second fn intact on disk.
+	const applied = materializeFile(store, root, ".", "two.js");
+	assert.equal(applied.status, "ok");
+	assert.equal(fs.readFileSync(path.join(root, "two.js"), "utf8"), expected);
+
+	// Zero-match refusal carries a repair path.
+	const bad = updateFunction(store, { fileDir: ".", fileName: "two.js", functionName: "nonexistent", fullCode: "x" });
+	assert.equal(bad.ok, false);
+	assert.match(bad.reason ?? "", /not found|manifest entry|get-function/);
+});
+
+test("updateFile / deleteFile / listPending round-trip", async (t) => {
+	const runtime = await loadGraphRuntime();
+	if (!runtime.status.sqliteAvailable) return;
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "code-graph-mut2-"));
+	t.after(() => { try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ } });
+	const store = new Store({ dbPath: path.join(dir, "g.db"), worktreeRoot: dir, gitCommonDir: path.join(dir, ".git") }, runtime.runtime.sqlite);
+	t.after(() => store.close());
+
+	const created = updateFile(store, { fileDir: ".", fileName: "brand-new.ts", text: "export const x = 1;\n", language: "typescript" });
+	assert.equal(created.ok, true);
+	assert.equal(created.created, true);
+	const applied = materializeFile(store, dir, ".", "brand-new.ts");
+	assert.equal(applied.status, "ok", "new file created from DB");
+	assert.equal(fs.readFileSync(path.join(dir, "brand-new.ts"), "utf8"), "export const x = 1;\n");
+
+	const replaced = updateFile(store, { fileDir: ".", fileName: "brand-new.ts", text: "export const x = 2;\n" });
+	assert.equal(replaced.ok, true);
+	assert.equal(replaced.created, false);
+
+	const marked = deleteFile(store, { fileDir: ".", fileName: "brand-new.ts" });
+	assert.equal(marked.ok, true);
+	assert.deepEqual(listPending(store), [{ path: "./brand-new.ts", kind: "delete" }]);
+	const purged = materializeFile(store, dir, ".", "brand-new.ts");
+	assert.equal(purged.status, "deleted");
+	assert.equal(fs.existsSync(path.join(dir, "brand-new.ts")), false);
+});

package/tests/code-graph-parser.test.ts

@@ -0,0 +1,85 @@
+/**
+ * Verifies the parser backends produce stable identities for the JS/TS/Python
+ * fixtures. Skipped when the runtime cannot provide node:sqlite or
+ * tree-sitter.
+ */
+
+import { test } from "node:test";
+import * as assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadGraphRuntime } from "../src/code-graph/runtime.ts";
+import { makeBackend } from "../src/code-graph/parsers/javascript.ts";
+import { PythonBackend } from "../src/code-graph/parsers/python.ts";
+import { normalizeFunctionIdentities } from "../src/code-graph/identity.ts";
+import type { ParserBackend } from "../../src/code-graph/parser.ts";
+import type { Language } from "../../src/code-graph/types.ts";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const fixturesDir = path.join(__dirname, "fixtures", "code-graph");
+
+async function backends(): Promise<Record<Language, ParserBackend> | null> {
+	try {
+		const { runtime, status } = await loadGraphRuntime();
+		if (!status.parserAvailable) return null;
+		const ParserCtor = runtime.parser.Parser as unknown as new () => {
+			parse(input: string | Buffer): unknown;
+			setLanguage(language: unknown): void;
+		};
+		return {
+			javascript: makeBackend("javascript", ParserCtor, runtime.parser.javascript),
+			typescript: makeBackend("typescript", ParserCtor, runtime.parser.typescript),
+			tsx: makeBackend("tsx", ParserCtor, runtime.parser.tsx),
+			python: new PythonBackend(ParserCtor, runtime.parser.python),
+		};
+	} catch {
+		return null;
+	}
+}
+
+test("parsers yield function records without overlapping provenance", async () => {
+	const bs = await backends();
+	if (!bs) return; // skip when tree-sitter unavailable
+	const jsSource = fs.readFileSync(path.join(fixturesDir, "sample.js"), "utf8");
+	const pySource = fs.readFileSync(path.join(fixturesDir, "sample.py"), "utf8");
+	const js = bs.javascript.parse(jsSource);
+	const py = bs.python.parse(pySource);
+	assert.ok(js.functions.length > 0);
+	assert.ok(py.functions.length > 0);
+	const jsNames = js.functions.map((f) => f.functionName);
+	const pyNames = py.functions.map((f) => f.functionName);
+	assert.ok(jsNames.includes("alpha"));
+	assert.ok(pyNames.includes("alpha"));
+	const lambda = py.functions.find((f) => f.kind === "lambda");
+	assert.ok(lambda, "expected a lambda record in python fixture");
+	// Every function has a non-empty hash and provenance.
+	for (const fn of [...js.functions, ...py.functions]) {
+		assert.equal(typeof fn.fullCodeHash, "string");
+		assert.ok(fn.fullCodeHash.length > 0);
+		assert.ok(fn.provenance.startByte < fn.provenance.endByte);
+	}
+});
+
+test("parser metadata and identity normalization handle overloads and accessors", async () => {
+	const bs = await backends();
+	if (!bs) return;
+	const js = bs.javascript.parse(fs.readFileSync(path.join(fixturesDir, "sample.js"), "utf8"));
+	const normalized = normalizeFunctionIdentities(js);
+	const accessorNames = normalized.functions
+		.filter((fn) => fn.kind === "accessor")
+		.map((fn) => fn.functionName);
+	assert.deepEqual(accessorNames, ["Container.foo", "Container.foo#2"]);
+	assert.ok(normalized.functions.some((fn) => fn.functionName === "Container.delta"));
+
+	const ts = bs.typescript.parse(fs.readFileSync(path.join(fixturesDir, "sample.ts"), "utf8"));
+	const overloaded = ts.functions.filter((fn) => fn.functionName === "overloaded");
+	assert.equal(overloaded.length, 1, "overload signatures must not create separate function rows");
+	assert.deepEqual(overloaded[0].overloadSignatures, [
+		"function overloaded(value: string): string;",
+		"function overloaded(value: number): number;",
+	]);
+	const tsAccessors = ts.functions.filter((fn) => fn.kind === "accessor");
+	assert.deepEqual(tsAccessors.map((fn) => fn.functionName), ["Accessors.value", "Accessors.value"]);
+});

package/tests/code-graph-rollback.test.ts

@@ -0,0 +1,100 @@
+/** End-to-end indexer rollback: an injected failure during write must leave no
+ * half-written rows for the file being indexed. */
+
+import { test } from "node:test";
+import * as assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { spawnSync } from "node:child_process";
+import { Store } from "../src/code-graph/store.ts";
+import { runIndex } from "../src/code-graph/indexer.ts";
+import { loadGraphRuntime } from "../src/code-graph/runtime.ts";
+import { makeBackend } from "../src/code-graph/parsers/javascript.ts";
+import { PythonBackend } from "../src/code-graph/parsers/python.ts";
+import type { ParserBackend } from "../src/code-graph/parser.ts";
+import type { Language } from "../src/code-graph/types.ts";
+
+function git(cwd: string, args: string[]): string {
+	const env: Record<string, string | undefined> = { ...process.env };
+	for (const key of ["GIT_DIR", "GIT_COMMON_DIR", "GIT_WORK_TREE"]) delete env[key];
+	const result = spawnSync("git", args, { cwd, env, encoding: "utf8" });
+	if (args[0] === "rev-parse") return (result.stdout ?? "").trim();
+	assert.equal(result.status, 0, `${args.join(" ")} failed: ${result.stderr}`);
+	return (result.stdout ?? "").trim();
+}
+
+function initRepo(): { worktreeRoot: string; cleanup: () => void } {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "code-graph-rollback-"));
+	git(dir, ["init", "--initial-branch=main"]);
+	git(dir, ["config", "user.email", "test@example.com"]);
+	git(dir, ["config", "user.name", "test"]);
+	const subdir = path.join(dir, "pkg");
+	fs.mkdirSync(subdir, { recursive: true });
+	fs.writeFileSync(path.join(subdir, "math.js"), "function add(a, b) { return a + b; }\n");
+	git(subdir, ["add", "-A"]);
+	git(subdir, ["commit", "-m", "init"]);
+	return {
+		worktreeRoot: subdir,
+		cleanup: () => {
+			try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+		},
+	};
+}
+
+test("indexer rolls back the whole file batch when an emit step throws", async (t) => {
+	const { worktreeRoot, cleanup } = initRepo();
+	t.after(cleanup);
+	const runtime = await loadGraphRuntime();
+	if (!runtime.status.parserAvailable || !runtime.status.sqliteAvailable) return;
+	const ParserCtor = runtime.runtime.parser.Parser as unknown as new () => {
+		parse(input: string | Buffer): unknown;
+		setLanguage(language: unknown): void;
+	};
+	const parsers: Record<Language, ParserBackend> = {
+		javascript: makeBackend("javascript", ParserCtor, runtime.runtime.parser.javascript),
+		typescript: makeBackend("typescript", ParserCtor, runtime.runtime.parser.typescript),
+		tsx: makeBackend("tsx", ParserCtor, runtime.runtime.parser.tsx),
+		python: new PythonBackend(ParserCtor, runtime.runtime.parser.python),
+	};
+	const sqlite = await import("node:sqlite");
+	const commonDir = git(worktreeRoot, ["rev-parse", "--git-common-dir"]);
+	const dbDir = path.join(path.resolve(worktreeRoot, commonDir), "pi_plans");
+	fs.mkdirSync(dbDir, { recursive: true });
+	const dbPath = path.join(dbDir, "code_graph.db");
+	try { fs.unlinkSync(dbPath); } catch { /* ignore */ }
+	const store = new Store(
+		{ dbPath, worktreeRoot, gitCommonDir: path.resolve(worktreeRoot, commonDir) },
+		sqlite,
+	);
+	t.after(() => {
+		store.close();
+		try { fs.unlinkSync(dbPath); } catch { /* ignore */ }
+	});
+
+	const original = store.prepare.bind(store);
+	const prepare = (key: string, sql: string) => {
+		if (key === "insert_edge") throw new Error("injected emit failure");
+		return original(key, sql);
+	};
+	(store as unknown as { prepare: typeof prepare }).prepare = prepare;
+
+	await assert.rejects(() => runIndex({ store, worktreeRoot, parsers }), /injected emit failure/);
+
+	const fileRows = store.read(() =>
+		store.db.prepare("SELECT file_dir, file_name FROM files WHERE file_dir = '.' AND file_name = 'math.js'").all(),
+	) as Array<{ file_dir: string; file_name: string }>;
+	const functionRows = store.read(() =>
+		store.db.prepare("SELECT function_name FROM functions WHERE file_dir = '.' AND file_name = 'math.js'").all(),
+	) as Array<{ function_name: string }>;
+	const entryRows = store.read(() =>
+		store.db.prepare("SELECT function_name FROM file_entries WHERE file_dir = '.' AND file_name = 'math.js'").all(),
+	) as Array<{ function_name: string }>;
+	const edgeRows = store.read(() =>
+		store.db.prepare("SELECT from_function FROM call_edges WHERE from_file_dir = '.' AND from_file_name = 'math.js'").all(),
+	) as Array<{ from_function: string }>;
+	assert.equal(fileRows.length, 0);
+	assert.equal(functionRows.length, 0);
+	assert.equal(entryRows.length, 0);
+	assert.equal(edgeRows.length, 0);
+});