pi-plans 0.2.0 → 0.3.0

package/src/code-graph/resolver.ts

@@ -0,0 +1,69 @@
+/**
+ * Conservative static call resolution. Captures call expressions of the form
+ * `name(...)` and `obj.method(...)` inside the same file; cross-file
+ * resolution is limited to relative imports and explicit module exports.
+ */
+
+import type { SourceLocation } from "./types.ts";
+import type { DiscoveredFile } from "./discovery.ts";
+
+export interface CallSite {
+	fromFunction: string;
+	calleeText: string;
+	kind: "call" | "definition" | "import";
+	resolution: "resolved" | "ambiguous" | "unresolved";
+	target?: { fileDir: string; fileName: string; functionName: string };
+	reason?: string;
+	provenance: SourceLocation;
+}
+
+const CALL_PATTERN = /\b([a-zA-Z_$][\w$]*)(?:\.([a-zA-Z_$][\w$]*))?\s*\(/g;
+
+export function resolveCalls(fromFunction: string, code: string, file: DiscoveredFile, out: CallSite[]): void {
+	for (const match of code.matchAll(CALL_PATTERN)) {
+		const head = match[1];
+		const member = match[2];
+		const start = match.index ?? 0;
+		const calleeText = match[0];
+		out.push({
+			fromFunction,
+			calleeText,
+			kind: "call",
+			resolution: "unresolved",
+			reason: "conservative resolution: same-file or relative import only",
+			provenance: locationOf(code, start, calleeText.length),
+		});
+		void head;
+		void member;
+		void file;
+	}
+	for (const match of code.matchAll(/^\s*(?:import|from)\s+([\w./-]+)/gm)) {
+		const start = match.index ?? 0;
+		out.push({
+			fromFunction,
+			calleeText: match[0],
+			kind: "import",
+			resolution: "unresolved",
+			reason: "import resolution deferred to module graph (not implemented in v1)",
+			provenance: locationOf(code, start, match[0].length),
+		});
+	}
+}
+
+function locationOf(code: string, byteStart: number, length: number): SourceLocation {
+	const before = code.slice(0, byteStart);
+	const startLine = before.split("\n").length;
+	const startColumn = before.length - before.lastIndexOf("\n");
+	const targetText = code.slice(byteStart, byteStart + length);
+	const endLine = startLine + targetText.split("\n").length - 1;
+	const endColumn =
+		targetText.split("\n").pop()?.length ?? startColumn;
+	return {
+		startByte: byteStart,
+		endByte: byteStart + length,
+		startLine,
+		startColumn,
+		endLine,
+		endColumn,
+	};
+}

package/src/code-graph/runtime.ts

@@ -0,0 +1,158 @@
+/**
+ * Lazy runtime guards for the code-graph module. Imports happen on first use
+ * so that a missing parser dependency or unsupported Node version cannot
+ * prevent the rest of pi-plans from registering.
+ *
+ * The module never throws at import time; every consumer calls one of the
+ * `ensure*` helpers and inspects the resulting status object.
+ */
+
+import { execSync } from "node:child_process";
+
+export type RuntimeIssue =
+	| { kind: "node-version"; detail: string }
+	| { kind: "sqlite-import"; detail: string }
+	| { kind: "parser-import"; detail: string; package: string }
+	| { kind: "runtime-unsupported"; detail: string };
+
+export interface RuntimeStatus {
+	nodeVersion: string;
+	nodeMajor: number;
+	hasExperimentalSqliteFlag: boolean;
+	graphEffectiveFloorMet: boolean;
+	parserAvailable: boolean;
+	sqliteAvailable: boolean;
+	bunDetected: boolean;
+	issues: RuntimeIssue[];
+}
+
+const MAJOR = Number(process.versions.node.split(".")[0]);
+const MINOR = Number(process.versions.node.split(".")[1] ?? "0");
+
+export const IS_BUN = typeof (process as { versions?: { bun?: string } }).versions?.bun === "string";
+
+function flagHasExperimentalSqlite(): boolean {
+	try {
+		const out = execSync(process.execPath, ["--experimental-sqlite", "-e", "1"], { encoding: "utf8" });
+		return out === "1";
+	} catch {
+		try {
+			const out = execSync(process.execPath, ["-e", "process.features.sqlite ?? \"off\""], { encoding: "utf8" }).trim();
+			return out !== "off" && out !== "undefined" && out !== "\"off\"";
+		} catch {
+			return false;
+		}
+	}
+}
+
+async function importSqlite(): Promise<unknown> {
+	return await import("node:sqlite");
+}
+
+async function importParser(): Promise<unknown> {
+	const mod = await import("tree-sitter");
+	const js = await import("tree-sitter-javascript");
+	const ts = await import("tree-sitter-typescript");
+	const py = await import("tree-sitter-python");
+	return { default: mod.default ?? mod, js: js.default ?? js, ts: ts.default ?? ts, py: py.default ?? py };
+}
+
+export async function detectRuntimeStatus(): Promise<RuntimeStatus> {
+	const issues: RuntimeIssue[] = [];
+	if (IS_BUN) {
+		issues.push({
+			kind: "runtime-unsupported",
+			detail: "graph feature is Node-only; detected Bun runtime",
+		});
+	}
+	const nodeVersion = process.versions.node;
+	const graphEffectiveFloorMet = IS_BUN
+		? false
+		: (MAJOR === 22 && MINOR >= 13) || MAJOR > 22;
+	const hasFlag = flagHasExperimentalSqlite();
+	const sqliteAvailable = await importSqlite()
+		.then(() => true)
+		.catch((err: Error) => {
+			issues.push({ kind: "sqlite-import", detail: err.message });
+			return false;
+		});
+	if (!sqliteAvailable && !hasFlag && !IS_BUN) {
+		issues.push({
+			kind: "node-version",
+			detail: `node:sqlite requires Node >=22.13 or --experimental-sqlite; current ${nodeVersion}`,
+		});
+	}
+	const parserAvailable = await importParser()
+		.then(() => true)
+		.catch((err: Error) => {
+			issues.push({
+				kind: "parser-import",
+				package: "tree-sitter",
+				detail: err.message,
+			});
+			return false;
+		});
+	return {
+		nodeVersion,
+		nodeMajor: MAJOR,
+		hasExperimentalSqliteFlag: hasFlag,
+		graphEffectiveFloorMet,
+		parserAvailable,
+		sqliteAvailable,
+		bunDetected: IS_BUN,
+		issues,
+	};
+}
+
+export interface GraphRuntime {
+	sqlite: typeof import("node:sqlite");
+	parser: {
+		Parser: typeof import("tree-sitter").default;
+		javascript: unknown;
+		typescript: unknown;
+		tsx: unknown;
+		python: unknown;
+	};
+}
+
+let cached: GraphRuntime | null = null;
+
+export async function loadGraphRuntime(): Promise<{ runtime: GraphRuntime; status: RuntimeStatus }> {
+	if (cached) return { runtime: cached, status: await detectRuntimeStatus() };
+	const sqlite = await importSqlite();
+	const ParserMod = await import("tree-sitter");
+	const jsMod = await import("tree-sitter-javascript");
+	const tsMod = await import("tree-sitter-typescript");
+	const pyMod = await import("tree-sitter-python");
+	const Parser = (ParserMod as { default?: unknown }).default ?? ParserMod;
+	const runtime: GraphRuntime = {
+		sqlite: sqlite as typeof import("node:sqlite"),
+		parser: {
+			Parser: Parser as typeof import("tree-sitter").default,
+			javascript: (jsMod as { default?: unknown }).default ?? jsMod,
+			typescript: (tsMod as { default?: { typescript: unknown; tsx: unknown } }).default?.typescript ?? tsMod,
+			tsx: (tsMod as { default?: { tsx: unknown } }).default?.tsx ?? tsMod,
+			python: (pyMod as { default?: unknown }).default ?? pyMod,
+		},
+	};
+	cached = runtime;
+	return { runtime, status: await detectRuntimeStatus() };
+}
+
+export function describeRuntimeIssues(status: RuntimeStatus): string[] {
+	if (status.issues.length === 0) return [];
+	return status.issues.map((issue) => {
+		switch (issue.kind) {
+			case "node-version":
+				return `Node version: ${issue.detail}`;
+			case "sqlite-import":
+				return `node:sqlite import failed: ${issue.detail}`;
+			case "parser-import":
+				return `parser import failed (${issue.package}): ${issue.detail}`;
+			case "runtime-unsupported":
+				return `runtime: ${issue.detail}`;
+			default:
+				return "unknown runtime issue";
+		}
+	});
+}

package/src/code-graph/schema.ts

@@ -0,0 +1,135 @@
+/**
+ * Schema definition and migrations for the code-graph SQLite database. The
+ * database is intentionally normalized — JSON views are derived from the
+ * edge tables at query time and never stored alongside them.
+ */
+
+export const CURRENT_SCHEMA_VERSION = 2;
+
+export const SCHEMA_STATEMENTS: string[] = [
+	`CREATE TABLE IF NOT EXISTS 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 IF NOT EXISTS 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,
+		pending_kind TEXT,
+		updated_at TEXT NOT NULL,
+		PRIMARY KEY (file_dir, file_name)
+	)`,
+	`CREATE TABLE IF NOT EXISTS file_entries (
+		id INTEGER PRIMARY KEY AUTOINCREMENT,
+		file_dir TEXT NOT NULL,
+		file_name TEXT NOT NULL,
+		ordinal INTEGER NOT NULL,
+		kind TEXT NOT NULL,
+		function_name TEXT,
+		start_byte INTEGER NOT NULL,
+		end_byte INTEGER NOT NULL,
+		text TEXT NOT NULL,
+		UNIQUE (file_dir, file_name, ordinal)
+	)`,
+	`CREATE INDEX IF NOT EXISTS idx_file_entries_file ON file_entries (file_dir, file_name, ordinal)`,
+	`CREATE TABLE IF NOT EXISTS functions (
+		file_dir TEXT NOT NULL,
+		file_name TEXT NOT NULL,
+		function_name TEXT NOT NULL,
+		language TEXT NOT NULL,
+		kind TEXT NOT NULL,
+		full_code TEXT NOT NULL,
+		full_code_hash TEXT NOT NULL,
+		render_code TEXT NOT NULL,
+		render_code_hash TEXT NOT NULL,
+		parent TEXT,
+		container TEXT,
+		move_supported INTEGER NOT NULL,
+		is_primary INTEGER NOT NULL,
+		overload_signatures TEXT,
+		provenance_start_byte INTEGER NOT NULL,
+		provenance_end_byte INTEGER NOT NULL,
+		provenance_start_line INTEGER NOT NULL,
+		provenance_start_col INTEGER NOT NULL,
+		provenance_end_line INTEGER NOT NULL,
+		provenance_end_col INTEGER NOT NULL,
+		summary_description TEXT,
+		summary_inputs TEXT,
+		summary_outputs TEXT,
+		summary_status TEXT,
+		summary_model TEXT,
+		summary_schema_version INTEGER,
+		summary_effective_effort TEXT,
+		summary_error TEXT,
+		summary_updated_at TEXT,
+		version INTEGER NOT NULL DEFAULT 1,
+		PRIMARY KEY (file_dir, file_name, function_name)
+	)`,
+	`CREATE TABLE IF NOT EXISTS call_edges (
+		id INTEGER PRIMARY KEY AUTOINCREMENT,
+		from_file_dir TEXT NOT NULL,
+		from_file_name TEXT NOT NULL,
+		from_function TEXT NOT NULL,
+		to_file_dir TEXT,
+		to_file_name TEXT,
+		to_function TEXT,
+		to_callee_text TEXT NOT NULL,
+		kind TEXT NOT NULL,
+		resolution TEXT NOT NULL,
+		reason TEXT,
+		provenance_start_byte INTEGER NOT NULL,
+		provenance_end_byte INTEGER NOT NULL,
+		provenance_start_line INTEGER NOT NULL,
+		provenance_start_col INTEGER NOT NULL,
+		provenance_end_line INTEGER NOT NULL,
+		provenance_end_col INTEGER NOT NULL
+	)`,
+	`CREATE INDEX IF NOT EXISTS idx_call_edges_from ON call_edges (from_file_dir, from_file_name, from_function)`,
+	`CREATE INDEX IF NOT EXISTS idx_call_edges_to ON call_edges (to_file_dir, to_file_name, to_function)`,
+	`CREATE TABLE IF NOT EXISTS change_log (
+		id INTEGER PRIMARY KEY AUTOINCREMENT,
+		kind TEXT NOT NULL,
+		detail TEXT NOT NULL,
+		recorded_at TEXT NOT NULL
+	)`,
+	`CREATE TABLE IF NOT EXISTS reindex_conflicts (
+		id INTEGER PRIMARY KEY AUTOINCREMENT,
+		file_dir TEXT NOT NULL,
+		file_name TEXT NOT NULL,
+		kind TEXT NOT NULL,
+		detail TEXT NOT NULL,
+		recorded_at TEXT NOT NULL
+	)`,
+	`CREATE TABLE IF NOT EXISTS code_graph_snapshot (
+		id INTEGER PRIMARY KEY AUTOINCREMENT,
+		head_commit TEXT NOT NULL,
+		uncommitted_paths TEXT NOT NULL,
+		recorded_at TEXT NOT NULL
+	)`,
+];
+
+export const FUNCTION_RECORDS_VIEW = `
+CREATE VIEW IF NOT EXISTS function_records AS
+SELECT
+	f.file_dir AS file_dir,
+	f.file_name AS file_name,
+	f.function_name AS function_name,
+	f.language AS language,
+	f.kind AS kind,
+	f.parent AS parent,
+	f.container AS container,
+	f.move_supported AS move_supported,
+	f.is_primary AS is_primary,
+	f.provenance_start_byte AS provenance_start_byte,
+	f.provenance_end_byte AS provenance_end_byte,
+	(SELECT json_group_array(json_object('file_dir', e.from_file_dir, 'file_name', e.from_file_name, 'function_name', e.from_function))
+		FROM call_edges e WHERE e.to_file_dir = f.file_dir AND e.to_file_name = f.file_name AND e.to_function = f.function_name AND e.resolution = 'resolved') AS in_links_json,
+	(SELECT json_group_array(json_object('file_dir', e.to_file_dir, 'file_name', e.to_file_name, 'function_name', e.to_function))
+		FROM call_edges e WHERE e.from_file_dir = f.file_dir AND e.from_file_name = f.file_name AND e.from_function = f.function_name AND e.resolution = 'resolved') AS out_links_json
+FROM functions f
+`;

package/src/code-graph/screening.ts

@@ -0,0 +1,82 @@
+/**
+ * Read-only screening queries that exclude full_code from the response.
+ * Used by the agent-facing tool and `/graph-status`.
+ */
+
+import { Store } from "./store.ts";
+import type { FunctionScreening, Language } from "./types.ts";
+
+export interface ScreeningOptions {
+	store: Store;
+	language?: Language;
+	functionNameLike?: string;
+	limit?: number;
+}
+
+export function screeningQuery(opts: ScreeningOptions): FunctionScreening[] {
+	const conditions: string[] = [];
+	const params: Array<string | number> = [];
+	if (opts.language) {
+		conditions.push("f.language = ?");
+		params.push(opts.language);
+	}
+	if (opts.functionNameLike) {
+		conditions.push("f.function_name LIKE ?");
+		params.push(`%${opts.functionNameLike}%`);
+	}
+	const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+	const limit = Math.max(1, Math.min(opts.limit ?? 100, 500));
+	const rows = opts.store
+		.read(() =>
+			opts.store.db
+				.prepare(
+					`SELECT
+						f.file_dir AS file_dir,
+						f.file_name AS file_name,
+						f.function_name AS function_name,
+						f.language AS language,
+						f.kind AS kind,
+						f.summary_description AS description,
+						f.summary_inputs AS inputs_json,
+						f.summary_outputs AS outputs_json,
+						f.summary_status AS summary_status,
+						f.version AS version,
+						(SELECT json_group_array(json_object('file_dir', e.from_file_dir, 'file_name', e.from_file_name, 'function_name', e.from_function))
+							FROM call_edges e WHERE e.to_file_dir = f.file_dir AND e.to_file_name = f.file_name AND e.to_function = f.function_name AND e.resolution = 'resolved') AS in_json,
+						(SELECT json_group_array(json_object('file_dir', e.to_file_dir, 'file_name', e.to_file_name, 'function_name', e.to_function))
+							FROM call_edges e WHERE e.from_file_dir = f.file_dir AND e.from_file_name = f.file_name AND e.from_function = f.function_name AND e.resolution = 'resolved') AS out_json
+					FROM functions f
+					${where}
+					ORDER BY f.file_dir, f.file_name, f.function_name
+					LIMIT ${limit}`,
+				)
+				.all(...params),
+		) as Array<{
+			file_dir: string;
+			file_name: string;
+			function_name: string;
+			language: Language;
+			kind: string;
+			description: string | null;
+			inputs_json: string | null;
+			outputs_json: string | null;
+			summary_status: string | null;
+			version: number;
+			in_json: string | null;
+			out_json: string | null;
+		}>;
+	return rows.map((row) => ({
+		fileDir: row.file_dir,
+		fileName: row.file_name,
+		functionName: row.function_name,
+		language: row.language,
+		kind: row.kind as FunctionScreening["kind"],
+		description: row.description,
+		inputs: row.inputs_json ? (JSON.parse(row.inputs_json) as string[]) : null,
+		outputs: row.outputs_json ? (JSON.parse(row.outputs_json) as string[]) : null,
+		version: row.version,
+		summaryStatus: row.summary_status as FunctionScreening["summaryStatus"],
+		inLinks: row.in_json ? (JSON.parse(row.in_json) as FunctionScreening["inLinks"]) : [],
+		outLinks: row.out_json ? (JSON.parse(row.out_json) as FunctionScreening["outLinks"]) : [],
+	}));
+}