pi-plans 0.2.0 → 0.3.1

package/src/code-graph/discovery.ts

@@ -0,0 +1,118 @@
+/**
+ * Discovery: walk the worktree, filter out unwanted directories, classify files
+ * by language and return a deterministic file order.
+ */
+
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { isIgnoredDir } from "./paths.ts";
+import type { Language } from "./types.ts";
+
+export interface DiscoveredFile {
+	fileDir: string;
+	fileName: string;
+	absolutePath: string;
+	language: Language;
+}
+
+const LANGUAGE_BY_EXT: Record<string, Language> = {
+	".js": "javascript",
+	".mjs": "javascript",
+	".cjs": "javascript",
+	".ts": "typescript",
+	".tsx": "tsx",
+	".py": "python",
+};
+
+function classify(filename: string): Language | null {
+	const ext = path.extname(filename).toLowerCase();
+	return LANGUAGE_BY_EXT[ext] ?? null;
+}
+
+/** Whether a relative POSIX path would be indexed (used by update-graph/drift path filtering). */
+export function isIndexablePath(relativePath: string): boolean {
+	const base = relativePath.split("/").pop() ?? relativePath;
+	return classify(base) !== null && !hasIgnoredDirectory(relativePath);
+}
+
+function hasIgnoredDirectory(relativePath: string): boolean {
+	const segments = relativePath.split(/[\\/]+/).filter(Boolean);
+	return segments.slice(0, -1).some((segment) => isIgnoredDir(segment));
+}
+
+function runGitLsFiles(cwd: string): string[] | null {
+	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", ["ls-files", "-z", "--others", "--exclude-standard"], {
+		cwd,
+		env,
+		encoding: "utf8",
+	});
+	if (result.status !== 0) return null;
+	const raw = result.stdout ?? "";
+	const files = raw.split("\0").filter((entry) => entry.length > 0);
+	if (!files.length) return null;
+	return files;
+}
+
+function walkFs(root: string, onFile: (abs: string) => void): void {
+	const stack = ["."];
+	while (stack.length) {
+		const rel = stack.pop()!;
+		const abs = path.join(root, rel);
+		let stat;
+		try {
+			stat = fs.lstatSync(abs);
+		} catch {
+			continue;
+		}
+		if (stat.isSymbolicLink()) continue;
+		if (stat.isDirectory()) {
+			const name = path.basename(abs);
+			if (rel !== "." && isIgnoredDir(name)) continue;
+			for (const entry of fs.readdirSync(abs)) stack.push(path.join(rel, entry));
+			continue;
+		}
+		if (stat.isFile()) onFile(abs);
+	}
+}
+
+export interface DiscoverOptions {
+	worktreeRoot: string;
+}
+
+export function discoverFiles(options: DiscoverOptions): DiscoveredFile[] {
+	const gitFiles = runGitLsFiles(options.worktreeRoot);
+	const out = new Map<string, DiscoveredFile>();
+	const register = (abs: string) => {
+		if (!abs.startsWith(options.worktreeRoot + path.sep) && abs !== options.worktreeRoot) return;
+		const rel = path.relative(options.worktreeRoot, abs);
+		if (hasIgnoredDirectory(rel)) return;
+		const lang = classify(path.basename(rel));
+		if (!lang) return;
+		const posix = rel.split(path.sep).join("/");
+		const parts = posix.split("/");
+		const fileName = parts[parts.length - 1];
+		const fileDir = parts.length === 1 ? "." : parts.slice(0, -1).join("/");
+		out.set(posix, {
+			fileDir,
+			fileName,
+			absolutePath: abs,
+			language: lang,
+		});
+	};
+	if (gitFiles && gitFiles.length > 0) {
+		for (const rel of gitFiles) register(path.resolve(options.worktreeRoot, rel));
+	}
+	walkFs(options.worktreeRoot, (abs) => {
+		if (!out.has(path.relative(options.worktreeRoot, abs).split(path.sep).join("/"))) {
+			register(abs);
+		}
+	});
+	return [...out.values()].sort((a, b) => {
+		const aKey = `${a.fileDir}/${a.fileName}`;
+		const bKey = `${b.fileDir}/${b.fileName}`;
+		return aKey.localeCompare(bKey);
+	});
+}

package/src/code-graph/git.ts

@@ -0,0 +1,108 @@
+/**
+ * Git porcelain helpers for the code-graph loop. All calls go through
+ * spawnSync with scrubbed environment (mirrors paths.ts) and never introduce
+ * new dependencies.
+ */
+
+import { spawnSync } from "node:child_process";
+
+function runGit(cwd: string, args: string[]): { code: number; stdout: string; stderr: string } {
+	const env: Record<string, string | undefined> = { ...process.env };
+	for (const key of ["GIT_DIR", "GIT_COMMON_DIR", "GIT_WORK_TREE"]) delete env[key];
+	// -c core.quotepath=false keeps non-ASCII paths literal instead of octal-escaped.
+	const result = spawnSync("git", ["-c", "core.quotepath=false", ...args], { cwd, env, encoding: "utf8" });
+	return { code: result.status ?? 1, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
+}
+
+export class GitError extends Error {}
+
+function must(cwd: string, args: string[], what: string): string {
+	const result = runGit(cwd, args);
+	if (result.code !== 0) {
+		throw new GitError(`${what} failed: ${result.stderr.trim() || result.stdout.trim() || `exit ${result.code}`}`);
+	}
+	return result.stdout;
+}
+
+/** Current HEAD commit SHA (empty string when no commits exist). */
+export function gitHead(cwd: string): string {
+	const result = runGit(cwd, ["rev-parse", "HEAD"]);
+	if (result.code !== 0) return "";
+	return result.stdout.trim();
+}
+
+export interface PorcelainEntry {
+	/** Single-letter + optional sub-status code, e.g. "M", " M", "A", "??", "R ". */
+	status: string;
+	/** Path for normal entries; NEW path for rename/copy entries. */
+	path: string;
+	/** Original path for rename (R) / copy (C) entries; null otherwise. */
+	origPath: string | null;
+}
+
+/** Parse `git status --porcelain` output, including rename (R old -> new). */
+export function parsePorcelain(stdout: string): PorcelainEntry[] {
+	const entries: PorcelainEntry[] = [];
+	for (const line of stdout.split("\n")) {
+		if (!line.trim()) continue;
+		const status = line.slice(0, 2);
+		const rest = line.slice(3);
+		if (rest.startsWith('"') && rest.endsWith('"')) {
+			// Quoted path with possible embedded quotes; renames use "old" -> "new".
+			const inner = rest.slice(1, -1);
+			const arrow = inner.indexOf('" -> "');
+			if ((status[0] === "R" || status[0] === "C") && arrow >= 0) {
+				entries.push({ status, path: inner.slice(arrow + 6), origPath: inner.slice(0, arrow) });
+			} else {
+				entries.push({ status, path: inner, origPath: null });
+			}
+			continue;
+		}
+		const arrow = rest.indexOf(" -> ");
+		if ((status[0] === "R" || status[0] === "C") && arrow >= 0) {
+			entries.push({ status, path: rest.slice(arrow + 4), origPath: rest.slice(0, arrow) });
+		} else {
+			entries.push({ status, path: rest, origPath: null });
+		}
+	}
+	return entries;
+}
+
+/** `git status --porcelain` parsed; includes untracked (`??`) and rename entries. */
+export function gitStatusPorcelain(cwd: string): PorcelainEntry[] {
+	return parsePorcelain(must(cwd, ["status", "--porcelain"], "git status"));
+}
+
+/** `git diff --name-only` against HEAD (or --base commit); excludes untracked. */
+export function gitDiffNameOnly(cwd: string, base?: string): string[] {
+	const args = base ? ["diff", "--name-only", base] : ["diff", "--name-only", "HEAD"];
+	const stdout = must(cwd, args, "git diff --name-only");
+	return stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+}
+
+/** Stage everything and commit; returns the new HEAD (or "" when nothing to commit). */
+export function gitAddAllAndCommit(cwd: string, message: string): string {
+	const status = gitStatusPorcelain(cwd);
+	if (status.length === 0) return "";
+	must(cwd, ["add", "-A"], "git add -A");
+	must(cwd, ["commit", "-m", message], "git commit");
+	return gitHead(cwd);
+}
+
+/** Parse "--flag" booleans and "--key value" pairs from a slash-command arg string. */
+export function parseCommandArgs(args: string): { flags: Set<string>; values: Map<string, string> } {
+	const flags = new Set<string>();
+	const values = new Map<string, string>();
+	const tokens = args.split(/\s+/).filter(Boolean);
+	for (let i = 0; i < tokens.length; i++) {
+		const token = tokens[i]!;
+		if (!token.startsWith("--")) continue;
+		if (i + 1 < tokens.length && !tokens[i + 1]!.startsWith("--")) {
+			values.set(token.slice(2), tokens[i + 1]!);
+			i++;
+		} else {
+			flags.add(token.slice(2));
+		}
+	}
+	return { flags, values };
+}

package/src/code-graph/identity.ts

@@ -0,0 +1,59 @@
+/** Deterministic function identity normalization for a parsed file. */
+
+import type { ParsedFile } from "./parser.ts";
+import type { FunctionRecord, RenderUnit } from "./types.ts";
+
+function spanKey(startByte: number, endByte: number): string {
+	return `${startByte}:${endByte}`;
+}
+
+function finalNames(functions: FunctionRecord[]): Map<string, string> {
+	const counts = new Map<string, number>();
+	const names = new Map<string, string>();
+	for (const fn of functions) {
+		const ordinal = (counts.get(fn.functionName) ?? 0) + 1;
+		counts.set(fn.functionName, ordinal);
+		const name = ordinal === 1 ? fn.functionName : `${fn.functionName}#${ordinal}`;
+		names.set(spanKey(fn.provenance.startByte, fn.provenance.endByte), name);
+	}
+	return names;
+}
+
+function renameUnits(units: RenderUnit[], names: Map<string, string>): RenderUnit[] {
+	return units.map((unit) => ({
+		...unit,
+		label: names.get(spanKey(unit.startByte, unit.endByte)) ?? unit.label,
+		children: unit.children ? renameUnits(unit.children, names) : unit.children,
+	}));
+}
+
+/**
+ * Normalize parser output before calls are resolved or rows are written. The
+ * parser order is structural and deterministic; provenance is only used to
+ * associate an existing render unit with its function record.
+ */
+export function normalizeFunctionIdentities(parsed: ParsedFile): ParsedFile {
+	const names = finalNames(parsed.functions);
+	const functions = parsed.functions.map((fn) => ({
+		...fn,
+		functionName: names.get(spanKey(fn.provenance.startByte, fn.provenance.endByte)) ?? fn.functionName,
+	}));
+	return {
+		...parsed,
+		functions,
+		renderUnits: renameUnits(parsed.renderUnits, names),
+	};
+}
+
+export function assertUniqueFunctionKeys(functions: FunctionRecord[], fileDir: string, fileName: string): void {
+	const seen = new Set<string>();
+	for (const fn of functions) {
+		const key = `${fileDir}\0${fileName}\0${fn.functionName}`;
+		if (seen.has(key)) {
+			throw new Error(
+				`duplicate normalized function identity for ${fileDir}/${fileName}/${fn.functionName} at ${fn.provenance.startByte}`,
+			);
+		}
+		seen.add(key);
+	}
+}

package/src/code-graph/indexer.ts

@@ -0,0 +1,281 @@
+/**
+ * Staged indexing pipeline: discovery → parse → resolve calls → write records
+ * inside a single SQLite write transaction. Each stage produces immutable
+ * snapshots so a parser crash cannot leave the DB in an inconsistent state.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { discoverFiles, type DiscoveredFile } from "./discovery.ts";
+import { Store } from "./store.ts";
+import type { ParserBackend } from "./parser.ts";
+import { hashText } from "./parser.ts";
+import type { Language } from "./types.ts";
+import { resolveCalls, type CallSite } from "./resolver.ts";
+import { assertUniqueFunctionKeys, normalizeFunctionIdentities } from "./identity.ts";
+
+export interface IndexerOptions {
+	store: Store;
+	worktreeRoot: string;
+	parsers: Record<Language, ParserBackend>;
+	reindex?: boolean;
+	/** When provided, only index these POSIX "dir/name" paths; paths that no
+	 *  longer exist on disk are purged from the DB (deletions and rename-old). */
+	paths?: string[];
+}
+
+export interface IndexReport {
+	filesScanned: number;
+	functionsIndexed: number;
+	edgesResolved: number;
+	edgesUnresolved: number;
+	conflicts: number;
+	durationMs: number;
+	reindexedPaths: string[];
+	purgedPaths: string[];
+}
+
+export async function runIndex(opts: IndexerOptions): Promise<IndexReport> {
+	const started = Date.now();
+	const files = discoverFiles({ worktreeRoot: opts.worktreeRoot });
+	const pathFilter = opts.paths ? new Set(opts.paths) : null;
+	if (pathFilter) {
+		for (const requested of pathFilter) {
+			if (!files.some((file) => `${file.fileDir}/${file.fileName}` === requested)) {
+				// Requested path no longer exists on disk (deletion or rename-old):
+				// purge its DB rows inside the same transaction below.
+				files.push({
+					absolutePath: path.join(opts.worktreeRoot, requested),
+					fileDir: requested.slice(0, requested.lastIndexOf("/")) || ".",
+					fileName: requested.slice(requested.lastIndexOf("/") + 1),
+					language: "javascript",
+				}) as DiscoveredFile;
+			}
+		}
+	}
+	const staged: Array<{
+		file: DiscoveredFile;
+		parsed: ReturnType<ParserBackend["parse"]>;
+		calls: CallSite[];
+		sourceText: string;
+		sourceHash: string;
+		exists: boolean;
+	}> = [];
+	let preflightConflict = 0;
+	const existingByFile = new Map<string, { sourceHash: string }>();
+	for (const row of opts.store
+		.read(() => opts.store.db.prepare("SELECT file_dir, file_name, source_hash FROM files").all()) as Array<{
+		file_dir: string;
+		file_name: string;
+		source_hash: string;
+	}>) {
+		existingByFile.set(`${row.file_dir}/${row.file_name}`, { sourceHash: row.source_hash });
+	}
+	for (const file of files) {
+		const relativeKey = `${file.fileDir}/${file.fileName}`;
+		if (pathFilter && !pathFilter.has(relativeKey)) continue;
+		let sourceText: string;
+		let exists = true;
+		try {
+			sourceText = fs.readFileSync(file.absolutePath, "utf8");
+		} catch {
+			if (pathFilter) {
+				// Path was requested but is gone from disk: stage a purge.
+				staged.push({ file, parsed: { functions: [], renderUnits: [] } as ReturnType<ParserBackend["parse"]>, calls: [], sourceText: "", sourceHash: "", exists: false });
+			}
+			continue;
+		}
+		const sourceHash = hashText(sourceText);
+		const backend = opts.parsers[file.language];
+		if (!backend) continue;
+		let parsed = backend.parse(sourceText);
+		parsed = normalizeFunctionIdentities(parsed);
+		parsed.functions.forEach((fn) => {
+			fn.fileDir = file.fileDir;
+			fn.fileName = file.fileName;
+		});
+		assertUniqueFunctionKeys(parsed.functions, file.fileDir, file.fileName);
+		const calls: CallSite[] = [];
+		for (const fn of parsed.functions) {
+			const fromText = fn.fullCode;
+			resolveCalls(fn.functionName, fromText, file, calls);
+		}
+		staged.push({ file, parsed, calls, sourceText, sourceHash, exists: true });
+	}
+	const now = new Date().toISOString();
+	const report: IndexReport = {
+		filesScanned: staged.filter((entry) => entry.exists).length,
+		functionsIndexed: 0,
+		edgesResolved: 0,
+		edgesUnresolved: 0,
+		conflicts: 0,
+		durationMs: 0,
+		reindexedPaths: [],
+		purgedPaths: [],
+	};
+	try {
+		opts.store.tx(() => {
+			for (const { file, parsed, calls, sourceText, sourceHash, exists } of staged) {
+				if (!exists) {
+					opts.store
+						.prepare("delete_functions_purge", `DELETE FROM functions WHERE file_dir = ? AND file_name = ?`)
+						.run(file.fileDir, file.fileName);
+					opts.store
+						.prepare("delete_entries_purge", `DELETE FROM file_entries WHERE file_dir = ? AND file_name = ?`)
+						.run(file.fileDir, file.fileName);
+					opts.store
+						.prepare("delete_edges_purge", `DELETE FROM call_edges WHERE from_file_dir = ? AND from_file_name = ?`)
+						.run(file.fileDir, file.fileName);
+					opts.store
+						.prepare("delete_file_purge", `DELETE FROM files WHERE file_dir = ? AND file_name = ?`)
+						.run(file.fileDir, file.fileName);
+					report.purgedPaths.push(`${file.fileDir}/${file.fileName}`);
+					continue;
+			}
+				report.reindexedPaths.push(`${file.fileDir}/${file.fileName}`);
+				const stmt = opts.store.prepare(
+					"insert_file",
+					`INSERT INTO files (file_dir, file_name, language, source_hash, source_text, updated_at)
+					 VALUES (?, ?, ?, ?, ?, ?)
+					 ON CONFLICT(file_dir, file_name) DO UPDATE SET
+						language = excluded.language,
+						source_hash = excluded.source_hash,
+						source_text = excluded.source_text,
+						updated_at = excluded.updated_at`,
+				);
+				stmt.run(file.fileDir, file.fileName, file.language, sourceHash, sourceText, now);
+				const oldHash = existingByFile.get(`${file.fileDir}/${file.fileName}`)?.sourceHash;
+				if (opts.reindex && oldHash && oldHash !== sourceHash) {
+					opts.store
+						.prepare(
+							"insert_conflict",
+							`INSERT INTO reindex_conflicts (file_dir, file_name, kind, detail, recorded_at)
+							 VALUES (?, ?, ?, ?, ?)`,
+						)
+						.run(file.fileDir, file.fileName, "external-change", `was ${oldHash}, now ${sourceHash}`, now);
+					report.conflicts++;
+				}
+				opts.store
+					.prepare("delete_functions", `DELETE FROM functions WHERE file_dir = ? AND file_name = ?`)
+					.run(file.fileDir, file.fileName);
+				opts.store
+					.prepare("delete_entries", `DELETE FROM file_entries WHERE file_dir = ? AND file_name = ?`)
+					.run(file.fileDir, file.fileName);
+				opts.store
+					.prepare("delete_edges", `DELETE FROM call_edges WHERE from_file_dir = ? AND from_file_name = ?`)
+					.run(file.fileDir, file.fileName);
+				const insertFn = opts.store.prepare(
+					"insert_function",
+					`INSERT INTO functions (
+						file_dir, file_name, function_name, language, kind,
+						full_code, full_code_hash, render_code, render_code_hash,
+						parent, container, move_supported, is_primary, overload_signatures,
+						provenance_start_byte, provenance_end_byte,
+						provenance_start_line, provenance_start_col,
+						provenance_end_line, provenance_end_col,
+						summary_description, summary_inputs, summary_outputs,
+						summary_status, summary_model, summary_schema_version,
+						summary_effective_effort, summary_error, summary_updated_at,
+						version
+					) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`,
+				);
+				for (const fn of parsed.functions) {
+					const summary = fn.summary;
+					insertFn.run(
+						fn.fileDir,
+						fn.fileName,
+						fn.functionName,
+						fn.language,
+						fn.kind,
+						fn.fullCode,
+						fn.fullCodeHash,
+						fn.renderCode,
+						fn.renderCodeHash,
+						fn.parent ?? null,
+						fn.container ?? null,
+						fn.moveSupported ? 1 : 0,
+						fn.isPrimary ? 1 : 0,
+						fn.overloadSignatures ? JSON.stringify(fn.overloadSignatures) : null,
+						fn.provenance.startByte,
+						fn.provenance.endByte,
+						fn.provenance.startLine,
+						fn.provenance.startColumn,
+						fn.provenance.endLine,
+						fn.provenance.endColumn,
+						summary?.description ?? null,
+						summary ? JSON.stringify(summary.inputs) : null,
+						summary ? JSON.stringify(summary.outputs) : null,
+						summary?.status ?? null,
+						summary?.model ?? null,
+						summary?.schemaVersion ?? null,
+						summary?.effectiveEffort ?? null,
+						summary?.errorMessage ?? null,
+						summary?.updatedAt ?? null,
+						fn.version,
+					);
+					report.functionsIndexed++;
+				}
+				let ordinal = 0;
+				const insertEntry = opts.store.prepare(
+					"insert_entry",
+					`INSERT INTO file_entries (file_dir, file_name, ordinal, kind, function_name, start_byte, end_byte, text)
+					 VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+				);
+				for (const unit of parsed.renderUnits) {
+					insertEntry.run(
+						file.fileDir,
+						file.fileName,
+						ordinal,
+						unit.kind,
+						unit.label ?? null,
+						unit.startByte,
+						unit.endByte,
+						unit.text ?? "",
+					);
+					ordinal++;
+				}
+				const insertEdge = opts.store.prepare(
+					"insert_edge",
+					`INSERT INTO call_edges (
+						from_file_dir, from_file_name, from_function,
+						to_file_dir, to_file_name, to_function,
+						to_callee_text, kind, resolution, reason,
+						provenance_start_byte, provenance_end_byte,
+						provenance_start_line, provenance_start_col,
+						provenance_end_line, provenance_end_col
+					) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`,
+				);
+				for (const call of calls) {
+					insertEdge.run(
+						file.fileDir,
+						file.fileName,
+						call.fromFunction,
+						call.target?.fileDir ?? null,
+						call.target?.fileName ?? null,
+						call.target?.functionName ?? null,
+						call.calleeText,
+						call.kind,
+						call.resolution,
+						call.reason ?? null,
+						call.provenance.startByte,
+						call.provenance.endByte,
+						call.provenance.startLine,
+						call.provenance.startColumn,
+						call.provenance.endLine,
+						call.provenance.endColumn,
+					);
+					if (call.resolution === "resolved") report.edgesResolved++;
+					else report.edgesUnresolved++;
+				}
+			}
+		});
+	} catch (error) {
+		if (!opts.reindex && staged.length === 0) {
+			preflightConflict++;
+		}
+		throw error;
+	}
+	report.durationMs = Date.now() - started;
+	report.conflicts += preflightConflict;
+	return report;
+}