pi-plans 0.2.0 → 0.3.0

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

@@ -0,0 +1,185 @@
+/**
+ * Verifies the DB-to-source materializer refuses stale source unless force,
+ * and roundtrips bytes for unchanged content.
+ */
+
+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 { Store } from "../src/code-graph/store.ts";
+import { materialize, materializeFile } from "../src/code-graph/materialize.ts";
+import { runIndex } from "../src/code-graph/indexer.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 type { ParserBackend } from "../src/code-graph/parser.ts";
+import type { Language } from "../src/code-graph/types.ts";
+
+async function setup(): Promise<{ store: Store; cleanup: () => void } | null> {
+	try {
+		const sqlite = await import("node:sqlite");
+		const worktreeRoot = fs.realpathSync(os.tmpdir());
+		const dbPath = path.join(os.tmpdir(), `code-graph-apply-${process.pid}-${Date.now()}.db`);
+		const store = new Store({ dbPath, worktreeRoot, gitCommonDir: worktreeRoot }, sqlite);
+		store.close();
+		const reopened = new Store({ dbPath, worktreeRoot, gitCommonDir: worktreeRoot }, sqlite);
+		return { store: reopened, cleanup: () => {
+			reopened.close();
+			try { fs.unlinkSync(dbPath); } catch { /* ignore */ }
+		} };
+	} catch {
+		return null;
+	}
+}
+
+function hashText(text: string): string {
+	let h = 0x811c9dc5;
+	for (let i = 0; i < text.length; i++) {
+		h ^= text.charCodeAt(i);
+		h = Math.imul(h, 0x01000193);
+	}
+	return (h >>> 0).toString(16).padStart(8, "0");
+}
+
+test("materialize refuses stale source unless force is set", async (t) => {
+	const opened = await setup();
+	if (!opened) return;
+	t.after(() => opened.cleanup());
+	const { store } = opened;
+	const worktreeRoot = fs.realpathSync(os.tmpdir());
+	const fileDir = "graph-apply-fixture";
+	const fileName = "demo.txt";
+	const absoluteDir = path.join(worktreeRoot, fileDir);
+	fs.mkdirSync(absoluteDir, { recursive: true });
+	const original = "hello graph";
+	fs.writeFileSync(path.join(absoluteDir, fileName), original);
+	const sourceHash = hashText(original);
+	store.tx(() => {
+		store.db
+			.prepare(
+				`INSERT INTO files (file_dir, file_name, language, source_hash, source_text, updated_at)
+				 VALUES (?, ?, ?, ?, ?, ?)`,
+			)
+			.run(fileDir, fileName, "javascript", sourceHash, original, new Date().toISOString());
+		store.db
+			.prepare(
+				`INSERT INTO file_entries (file_dir, file_name, ordinal, kind, function_name, start_byte, end_byte, text)
+				 VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+			)
+			.run(fileDir, fileName, 0, "raw", null, 0, original.length, original);
+	});
+	// File matches DB hash: write succeeds.
+	const okResult = materializeFile(store, worktreeRoot, fileDir, fileName);
+	assert.equal(okResult.status, "ok");
+	// Now mutate the source on disk to be stale.
+	fs.writeFileSync(path.join(absoluteDir, fileName), "external change");
+	const staleResult = materializeFile(store, worktreeRoot, fileDir, fileName);
+	assert.equal(staleResult.status, "stale");
+	const forceResult = materializeFile(store, worktreeRoot, fileDir, fileName, { force: true });
+	assert.equal(forceResult.status, "ok");
+	assert.equal(fs.readFileSync(path.join(absoluteDir, fileName), "utf8"), original);
+	fs.rmSync(absoluteDir, { recursive: true, force: true });
+});
+
+test("pending_kind drives convergence: update writes/creates, delete purges, missing skips", async (t) => {
+	const sqliteAvailable = (async () => { try { await import("node:sqlite"); return true; } catch { return false; } })();
+	if (!(await sqliteAvailable)) return;
+	const sqlite = await import("node:sqlite");
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "code-graph-pending-"));
+	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") }, sqlite);
+	t.after(() => store.close());
+	const now = new Date().toISOString();
+
+	// 1. pending update creates a missing file (new-file path).
+	store.tx(() => {
+		store.db.prepare(
+			`INSERT INTO files (file_dir, file_name, language, source_hash, source_text, pending_kind, updated_at)
+			 VALUES ('.', 'new.js', 'javascript', 'x', 'function n() { return 1; }\n', 'update', ?)`,
+		).run(now);
+	});
+	const created = materializeFile(store, dir, ".", "new.js");
+	assert.equal(created.status, "ok");
+	assert.equal(fs.readFileSync(path.join(dir, "new.js"), "utf8"), "function n() { return 1; }\n");
+	const cleared = store.read(() => store.db.prepare(`SELECT pending_kind FROM files WHERE file_name = 'new.js'`).get()) as { pending_kind: string | null };
+	assert.equal(cleared.pending_kind, null, "pending cleared after apply");
+
+	// 2. pending delete removes disk file and DB rows.
+	fs.writeFileSync(path.join(dir, "doomed.js"), "function d() {}\n");
+	store.tx(() => {
+		store.db.prepare(
+			`INSERT INTO files (file_dir, file_name, language, source_hash, source_text, pending_kind, updated_at)
+			 VALUES ('.', 'doomed.js', 'javascript', 'x', 'function d() {}\n', 'delete', ?)`,
+		).run(now);
+		store.db.prepare(
+			`INSERT INTO functions (file_dir, file_name, function_name, language, kind, full_code, full_code_hash, render_code, render_code_hash,
+			 move_supported, is_primary, provenance_start_byte, provenance_end_byte, provenance_start_line, provenance_start_col,
+			 provenance_end_line, provenance_end_col, version)
+			 VALUES ('.', 'doomed.js', 'd', 'javascript', 'declaration', 'function d() {}', 'h', 'function d() {}', 'h', 1, 1, 0, 18, 1, 1, 1, 19, 1)`,
+		).run();
+	});
+	const deleted = materializeFile(store, dir, ".", "doomed.js");
+	assert.equal(deleted.status, "deleted");
+	assert.equal(fs.existsSync(path.join(dir, "doomed.js")), false, "disk file removed");
+	const rows = store.read(() => store.db.prepare(`SELECT COUNT(*) AS c FROM files WHERE file_name = 'doomed.js'`).get()) as { c: number };
+	assert.equal(rows.c, 0, "DB rows purged");
+
+	// 3. pending-NULL + missing on disk: skipped, not resurrected.
+	store.tx(() => {
+		store.db.prepare(
+			`INSERT INTO files (file_dir, file_name, language, source_hash, source_text, pending_kind, updated_at)
+			 VALUES ('.', 'ghost.js', 'javascript', 'x', 'function g() {}\n', NULL, ?)`,
+		).run(now);
+	});
+	const skipped = materializeFile(store, dir, ".", "ghost.js");
+	assert.equal(skipped.status, "skipped-missing");
+	assert.equal(fs.existsSync(path.join(dir, "ghost.js")), false, "ghost not resurrected");
+});
+
+test("materialize never rewrites pending-NULL files from real-index manifests", async (t) => {
+	let sqlite: typeof import("node:sqlite");
+	try {
+		sqlite = await import("node:sqlite");
+	} catch {
+		return;
+	}
+	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 dir = fs.mkdtempSync(path.join(os.tmpdir(), "code-graph-apply-real-"));
+	t.after(() => {
+		try {
+			fs.rmSync(dir, { recursive: true, force: true });
+		} catch {
+			/* ignore */
+		}
+	});
+	const source = "export function add(a: number, b: number): number { return a + b; }\n";
+	fs.writeFileSync(path.join(dir, "math.ts"), source);
+	const store = new Store({ dbPath: path.join(dir, "g.db"), worktreeRoot: dir, gitCommonDir: path.join(dir, ".git") }, sqlite);
+	t.after(() => store.close());
+	await runIndex({ store, worktreeRoot: dir, parsers });
+
+	// Real indexes store empty/overlapping render-unit texts; a pending-NULL
+	// apply must treat source_text as canonical and not rewrite the file.
+	const report = materialize({ store, worktreeRoot: dir });
+	assert.ok(report.files.every((file) => file.status === "ok"), JSON.stringify(report.files));
+	assert.equal(fs.readFileSync(path.join(dir, "math.ts"), "utf8"), source);
+
+	// force converges from source_text, never from manifest reassembly.
+	fs.writeFileSync(path.join(dir, "math.ts"), "tampered\n");
+	const forced = materialize({ store, worktreeRoot: dir, force: true });
+	assert.ok(forced.files.every((file) => file.status === "ok"), JSON.stringify(forced.files));
+	assert.equal(fs.readFileSync(path.join(dir, "math.ts"), "utf8"), source);
+});

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

@@ -0,0 +1,211 @@
+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 { after, test } from "node:test";
+import { Store } from "../src/code-graph/store.ts";
+import { runIndex } from "../src/code-graph/indexer.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 { gitHead } from "../src/code-graph/git.ts";
+import { initGraphCommand } from "../src/code-graph/commands.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[]): void {
+	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" });
+	assert.equal(result.status, 0, `${args.join(" ")} failed: ${result.stderr}`);
+}
+
+function initRepo(): { root: string; cleanup: () => void } {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-init-graph-"));
+	git(root, ["init", "--initial-branch=main"]);
+	git(root, ["config", "user.email", "test@example.com"]);
+	git(root, ["config", "user.name", "test"]);
+	fs.writeFileSync(path.join(root, "math.js"), "function add(a, b) { return a + b; }\n");
+	fs.writeFileSync(path.join(root, "helper.ts"), "export function twice(n: number): number { return n * 2; }\n");
+	git(root, ["add", "-A"]);
+	git(root, ["commit", "-m", "init"]);
+	fs.mkdirSync(path.join(root, ".git", "pi_plans"), { recursive: true });
+	const canonicalRoot = fs.realpathSync(root);
+	return {
+		root: canonicalRoot,
+		cleanup: () => {
+			try {
+				fs.rmSync(root, { recursive: true, force: true });
+			} catch {
+				/* ignore */
+			}
+		},
+	};
+}
+
+async function loadParsers() {
+	const runtime = await loadGraphRuntime();
+	if (!runtime.status.parserAvailable || !runtime.status.sqliteAvailable) return null;
+	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),
+	};
+	return { runtime, parsers };
+}
+
+function openStore(root: string, sqlite: typeof import("node:sqlite")): Store {
+	const canonicalRoot = fs.realpathSync(root);
+	const dbPath = path.join(canonicalRoot, ".git", "pi_plans", "code_graph.db");
+	fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+	return new Store({ dbPath, worktreeRoot: canonicalRoot, gitCommonDir: path.join(canonicalRoot, ".git") }, sqlite);
+}
+
+function makeCtx(root: string, confirmResult: boolean, hasUI = true) {
+	const confirmations: Array<{ title: string; body: string }> = [];
+	const notifications: Array<{ message: string; kind?: string }> = [];
+	return {
+		cwd: root,
+		hasUI,
+		ui: {
+			notify: (message: string, kind?: "info" | "warning" | "error") => {
+				notifications.push({ message, kind });
+			},
+			confirm: async (title: string, body: string) => {
+				confirmations.push({ title, body });
+				return confirmResult;
+			},
+		},
+		confirmations,
+		notifications,
+	};
+}
+
+test("initGraphCommand keeps the fresh-init path prompt-free", async (t) => {
+	const loaded = await loadParsers();
+	if (!loaded) return;
+	const { runtime, parsers } = loaded;
+	const { root, cleanup } = initRepo();
+	t.after(cleanup);
+	const ctx = makeCtx(root, false);
+	await initGraphCommand("", ctx as never);
+	assert.equal(ctx.confirmations.length, 0, "fresh init must not prompt");
+
+	const store = openStore(root, runtime.runtime.sqlite);
+	t.after(() => store.close());
+	const fileCount = store.read(() => store.db.prepare("SELECT COUNT(*) AS c FROM files").get()) as { c: number };
+	assert.ok(fileCount.c > 0, "fresh init should populate files");
+	const functionsCount = store.read(() => store.db.prepare("SELECT COUNT(*) AS c FROM functions").get()) as { c: number };
+	assert.ok(functionsCount.c > 0, "fresh init should populate functions");
+	void parsers;
+});
+
+test("initGraphCommand routes an existing DB to changed-path sync and ignores rebuild-only flags", async (t) => {
+	const loaded = await loadParsers();
+	if (!loaded) return;
+	const { runtime, parsers } = loaded;
+	const { root, cleanup } = initRepo();
+	t.after(cleanup);
+	const sqlite = runtime.runtime.sqlite;
+	const seedStore = openStore(root, sqlite);
+	t.after(() => seedStore.close());
+	await runIndex({ store: seedStore, worktreeRoot: root, parsers });
+	seedStore.upsertSnapshot(gitHead(root), []);
+	seedStore.close();
+
+	const updatedSource = "function add(a, b) { return a + b + 100; }\n";
+	fs.writeFileSync(path.join(root, "math.js"), updatedSource);
+	const headBefore = gitHead(root);
+	const ctx = makeCtx(root, false);
+	await initGraphCommand("--no-summary --no-commit", ctx as never);
+
+	assert.equal(ctx.confirmations.length, 1, "existing DB should prompt once");
+	assert.match(ctx.confirmations[0]!.body, /\/update-graph/);
+	assert.equal(gitHead(root), headBefore, "incremental branch must not create the pre-init commit");
+
+	const checkStore = openStore(root, sqlite);
+	t.after(() => checkStore.close());
+	const row = checkStore.read(() =>
+		checkStore.db.prepare("SELECT source_hash FROM files WHERE file_dir = '.' AND file_name = 'math.js'").get(),
+	) as { source_hash: string } | undefined;
+	assert.ok(row, "math.js should remain indexed");
+	assert.equal(row!.source_hash, hashText(updatedSource));
+	const conflicts = checkStore.read(() => checkStore.db.prepare("SELECT COUNT(*) AS c FROM reindex_conflicts").get()) as { c: number };
+	assert.equal(conflicts.c, 0, "incremental sync should ignore rebuild-only reindex conflicts");
+	void runtime;
+});
+
+test("initGraphCommand rebuild branch skips prompt when --reindex is explicit", async (t) => {
+	const loaded = await loadParsers();
+	if (!loaded) return;
+	const { runtime, parsers } = loaded;
+	const { root, cleanup } = initRepo();
+	t.after(cleanup);
+	const sqlite = runtime.runtime.sqlite;
+	const seedStore = openStore(root, sqlite);
+	t.after(() => seedStore.close());
+	await runIndex({ store: seedStore, worktreeRoot: root, parsers });
+	seedStore.upsertSnapshot(gitHead(root), []);
+	seedStore.close();
+
+	const changedSource = "function add(a, b) { return a + b + 200; }\n";
+	fs.writeFileSync(path.join(root, "math.js"), changedSource);
+	const headBefore = gitHead(root);
+	const ctx = makeCtx(root, true);
+	await initGraphCommand("--reindex --no-commit", ctx as never);
+
+	assert.equal(ctx.confirmations.length, 0, "existing DB with --reindex should skip the prompt");
+	assert.equal(gitHead(root), headBefore, "--no-commit must still suppress the pre-init commit on rebuild");
+
+	const checkStore = openStore(root, sqlite);
+	t.after(() => checkStore.close());
+	const row = checkStore.read(() =>
+		checkStore.db.prepare("SELECT source_hash FROM files WHERE file_dir = '.' AND file_name = 'math.js'").get(),
+	) as { source_hash: string } | undefined;
+	assert.ok(row, "math.js should remain indexed");
+	assert.equal(row!.source_hash, hashText(changedSource));
+	const conflicts = checkStore.read(() => checkStore.db.prepare("SELECT COUNT(*) AS c FROM reindex_conflicts").get()) as { c: number };
+	assert.ok(conflicts.c > 0, "--reindex must still record conflicts on the rebuild path");
+	void runtime;
+});
+
+test("initGraphCommand rebuilds without prompting in headless mode", async (t) => {
+	const loaded = await loadParsers();
+	if (!loaded) return;
+	const { runtime, parsers } = loaded;
+	const { root, cleanup } = initRepo();
+	t.after(cleanup);
+	const sqlite = runtime.runtime.sqlite;
+	const seedStore = openStore(root, sqlite);
+	t.after(() => seedStore.close());
+	await runIndex({ store: seedStore, worktreeRoot: root, parsers });
+	seedStore.upsertSnapshot(gitHead(root), []);
+	seedStore.close();
+
+	const updatedSource = "function add(a, b) { return a + b + 300; }\n";
+	fs.writeFileSync(path.join(root, "math.js"), updatedSource);
+	const headBefore = gitHead(root);
+	const ctx = makeCtx(root, false, false);
+	await initGraphCommand("", ctx as never);
+
+	assert.equal(ctx.confirmations.length, 0, "headless runs must not prompt");
+	assert.notEqual(gitHead(root), headBefore, "headless existing DB should rebuild and create the pre-init commit");
+
+	const checkStore = openStore(root, sqlite);
+	t.after(() => checkStore.close());
+	const row = checkStore.read(() =>
+		checkStore.db.prepare("SELECT source_hash FROM files WHERE file_dir = '.' AND file_name = 'math.js'").get(),
+	) as { source_hash: string } | undefined;
+	assert.ok(row, "math.js should remain indexed");
+	assert.equal(row!.source_hash, hashText(updatedSource));
+	const conflicts = checkStore.read(() => checkStore.db.prepare("SELECT COUNT(*) AS c FROM reindex_conflicts").get()) as { c: number };
+	assert.equal(conflicts.c, 0, "headless rebuild without --reindex should keep the normal rebuild path");
+	void runtime;
+});

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

@@ -0,0 +1,166 @@
+/**
+ * Verifies the SQLite schema migrations, worktree binding, and BEGIN
+ * IMMEDIATE transactions. Skipped when node:sqlite is not available.
+ */
+
+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 { Store } from "../src/code-graph/store.ts";
+import { PathError, resolveCanonicalWorktree } from "../src/code-graph/paths.ts";
+
+async function openInMemory(): Promise<{ store: Store; cleanup: () => void } | null> {
+	try {
+		const sqlite = await import("node:sqlite");
+		const worktreeRoot = fs.realpathSync(os.tmpdir());
+		const dbPath = path.join(os.tmpdir(), `code-graph-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+		const store = new Store({ dbPath, worktreeRoot, gitCommonDir: worktreeRoot }, sqlite);
+		store.close();
+		const reopened = new Store({ dbPath, worktreeRoot, gitCommonDir: worktreeRoot }, sqlite);
+		return { store: reopened, cleanup: () => {
+			reopened.close();
+			try { fs.unlinkSync(dbPath); } catch { /* ignore */ }
+		} };
+	} catch {
+		return null;
+	}
+}
+
+test("schema migrations are idempotent and create required tables", async (t) => {
+	const opened = await openInMemory();
+	if (!opened) return;
+	t.after(() => opened.cleanup());
+	const { store } = opened;
+	const tables = store.read(() =>
+		store.db.prepare(`SELECT name FROM sqlite_master WHERE type IN ('table', 'view') ORDER BY name`).all(),
+	) as Array<{ name: string }>;
+	const names = new Set(tables.map((row) => row.name));
+	for (const required of ["call_edges", "files", "file_entries", "functions", "graph_meta", "function_records", "code_graph_snapshot"]) {
+		assert.ok(names.has(required), `expected table or view ${required}`);
+	}
+	const meta = store.readMeta();
+	assert.ok(meta, "graph_meta should be populated");
+	assert.equal(meta.worktreeRoot.length > 0, true);
+	const columns = store.db.prepare("PRAGMA table_info(files)").all() as Array<{ name: string }>;
+	assert.ok(columns.some((column) => column.name === "pending_kind"), "files.pending_kind must exist");
+});
+
+test("v1 database upgrades to v2 with initial snapshot and re-entrant migration", async (t) => {
+	let sqlite: typeof import("node:sqlite");
+	try {
+		sqlite = await import("node:sqlite");
+	} catch {
+		return;
+	}
+	const dbPath = path.join(os.tmpdir(), `code-graph-v1-upgrade-${process.pid}-${Date.now()}.db`);
+	t.after(() => {
+		try { fs.unlinkSync(dbPath); } catch { /* ignore */ }
+	});
+	// Build a v1 database: old files schema (no pending_kind), no snapshot table.
+	const raw = new sqlite.DatabaseSync(dbPath, { open: true });
+	raw.exec(`
+		CREATE TABLE graph_meta (schema_version INTEGER PRIMARY KEY, worktree_root TEXT NOT NULL, git_common_dir TEXT NOT NULL, parser_versions TEXT NOT NULL, updated_at TEXT NOT NULL);
+		CREATE TABLE files (file_dir TEXT NOT NULL, file_name TEXT NOT NULL, language TEXT NOT NULL, source_hash TEXT NOT NULL, source_text TEXT NOT NULL, updated_at TEXT NOT NULL, PRIMARY KEY (file_dir, file_name));
+		INSERT INTO graph_meta VALUES (1, '${fs.realpathSync(os.tmpdir())}', '${fs.realpathSync(os.tmpdir())}', '{}', '2026-01-01T00:00:00Z');
+		INSERT INTO files (file_dir, file_name, language, source_hash, source_text, updated_at) VALUES ('.', 'a.js', 'javascript', 'h1', 'source', '2026-01-01T00:00:00Z');
+	`);
+	raw.close();
+	const worktreeRoot = fs.realpathSync(os.tmpdir());
+	const store = new Store({ dbPath, worktreeRoot, gitCommonDir: worktreeRoot }, sqlite);
+	try {
+		assert.equal(store.readMeta()?.schemaVersion, 2, "v1 DB must upgrade to v2 on open");
+		const columns = store.db.prepare("PRAGMA table_info(files)").all() as Array<{ name: string }>;
+		assert.ok(columns.some((column) => column.name === "pending_kind"));
+		const snapshot = store.readLatestSnapshot();
+		assert.ok(snapshot, "initial snapshot row must exist after migration");
+		assert.deepEqual(snapshot.uncommittedPaths, []);
+		// Re-open again: migration must be a safe no-op (step-idempotent).
+		store.close();
+		const reopened = new Store({ dbPath, worktreeRoot, gitCommonDir: worktreeRoot }, sqlite);
+		assert.equal(reopened.readMeta()?.schemaVersion, 2);
+		assert.ok(reopened.readLatestSnapshot(), "snapshot survives re-open");
+		const snapshots = reopened.read(() => reopened.db.prepare("SELECT COUNT(*) AS c FROM code_graph_snapshot").get()) as { c: number };
+		assert.equal(snapshots.c, 1, "no duplicate snapshot rows on re-entry");
+		reopened.close();
+	} finally {
+		try { store.close(); } catch { /* already closed */ }
+	}
+});
+
+test("snapshot upsert and readLatestSnapshot round-trip", async (t) => {
+	const opened = await openInMemory();
+	if (!opened) return;
+	t.after(() => opened.cleanup());
+	const { store } = opened;
+	store.upsertSnapshot("abc123", ["src/a.ts", "README.md"]);
+	store.upsertSnapshot("def456", []);
+	const latest = store.readLatestSnapshot();
+	assert.ok(latest);
+	assert.equal(latest.headCommit, "def456");
+	assert.deepEqual(latest.uncommittedPaths, []);
+	const prior = store.read(() => store.db.prepare("SELECT head_commit FROM code_graph_snapshot ORDER BY id ASC").all()) as Array<{ head_commit: string }>;
+	assert.equal(prior[0]?.head_commit, "abc123");
+});
+
+test("worktree mismatch is rejected on open", async (t) => {
+	const opened = await openInMemory();
+	if (!opened) return;
+	t.after(() => opened.cleanup());
+	const { store } = opened;
+	const meta = store.readMeta();
+	assert.ok(meta);
+	// Same path: no throw.
+	store.checkWorktree(meta.worktreeRoot, meta.gitCommonDir);
+	assert.throws(
+		() => store.checkWorktree("/totally/different", meta.gitCommonDir),
+		(err: Error) => {
+			assert.ok(err instanceof PathError);
+			return true;
+		},
+	);
+});
+
+test("write transactions use BEGIN IMMEDIATE and roll back on error", async (t) => {
+	const opened = await openInMemory();
+	if (!opened) return;
+	t.after(() => opened.cleanup());
+	const { store } = opened;
+	store.tx(() => {
+		store.db
+			.prepare(
+				`INSERT INTO files (file_dir, file_name, language, source_hash, source_text, updated_at)
+				 VALUES (?, ?, ?, ?, ?, ?)`,
+			)
+			.run("dir", "a.js", "javascript", "hash", "source", new Date().toISOString());
+	});
+	const ok = store.read(() =>
+		store.db.prepare("SELECT COUNT(*) AS c FROM files WHERE file_dir = 'dir' AND file_name = 'a.js'").get(),
+	) as { c: number };
+	assert.equal(ok.c, 1);
+	assert.throws(() => {
+		store.tx(() => {
+			store.db
+				.prepare(
+					`INSERT INTO files (file_dir, file_name, language, source_hash, source_text, updated_at)
+					 VALUES (?, ?, ?, ?, ?, ?)`,
+				)
+				.run("dir", "a.js", "javascript", "dup", "source", new Date().toISOString());
+			throw new Error("fail");
+		});
+	}, /fail/);
+	const stillOne = store.read(() =>
+		store.db.prepare("SELECT COUNT(*) AS c FROM files WHERE file_dir = 'dir'").get(),
+	) as { c: number };
+	assert.equal(stillOne.c, 1, "duplicate insert must be rolled back");
+});
+
+test("resolveCanonicalWorktree requires a git worktree", () => {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "code-graph-no-git-"));
+	try {
+		assert.throws(() => resolveCanonicalWorktree(dir));
+	} finally {
+		fs.rmSync(dir, { recursive: true, force: true });
+	}
+});

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

@@ -0,0 +1,38 @@
+/** Discovery regression tests for tracked, untracked, and excluded source paths. */
+
+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 { discoverFiles } from "../src/code-graph/discovery.ts";
+
+function git(cwd: string, args: string[]): void {
+	const result = spawnSync("git", args, { cwd, encoding: "utf8" });
+	assert.equal(result.status, 0, `${args.join(" ")} failed: ${result.stderr}`);
+}
+
+test("discovery applies product exclusions to Git and filesystem paths", () => {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "code-graph-discovery-"));
+	try {
+		git(root, ["init", "--initial-branch=main"]);
+		git(root, ["config", "user.email", "test@example.com"]);
+		git(root, ["config", "user.name", "test"]);
+		fs.writeFileSync(path.join(root, "tracked.js"), "function tracked() {}\n");
+		git(root, ["add", "tracked.js"]);
+		git(root, ["commit", "-m", "tracked"]);
+		fs.mkdirSync(path.join(root, "src"), { recursive: true });
+		fs.mkdirSync(path.join(root, "node_modules", "dependency"), { recursive: true });
+		fs.writeFileSync(path.join(root, "src", "untracked.ts"), "export function untracked() {}\n");
+		fs.writeFileSync(path.join(root, "node_modules", "dependency", "ignored.js"), "function ignored() {}\n");
+		fs.mkdirSync(path.join(root, "dist"), { recursive: true });
+		fs.writeFileSync(path.join(root, "dist", "built.py"), "def built(): pass\n");
+
+		const files = discoverFiles({ worktreeRoot: root });
+		const names = files.map((file) => `${file.fileDir}/${file.fileName}`);
+		assert.deepEqual(names, ["./tracked.js", "src/untracked.ts"]);
+	} finally {
+		fs.rmSync(root, { recursive: true, force: true });
+	}
+});