my-pi 0.0.8 → 0.0.10

package/dist/{api-BA6XuDOE.js → api-7LVj6kUV.js}

@@ -1,11 +1,13 @@
 import { InteractiveMode as InteractiveMode$1, SessionManager, SettingsManager, createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, defineTool, getAgentDir, parseFrontmatter, runPrintMode as runPrintMode$1 } from "@mariozechner/pi-coding-agent";
 import { cpSync, existsSync, globSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, relative, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { Type } from "@sinclair/typebox";
-import { execFileSync, spawn } from "node:child_process";
+import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { Container, SettingsList, Text, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { readFile } from "node:fs/promises";
+import { EventEmitter } from "node:events";
 import { createHash } from "node:crypto";
 //#region src/extensions/chain.ts
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -399,6 +401,13 @@ const BUILTIN_EXTENSIONS = [
 			"preset",
 			"presets"
 		]
+	},
+	{
+		key: "lsp",
+		label: "LSP",
+		description: "Language Server Protocol tools (diagnostics, hover, definition, references)",
+		cli_flag: "--no-lsp",
+		aliases: ["lsp", "language-server"]
 	}
 ];
 function get_builtin_extensions_config_path() {
@@ -814,6 +823,1013 @@ ${task || "Continue from where the previous session left off."}
 	});
 }
 //#endregion
+//#region src/lsp/client.ts
+var LspClientStartError = class extends Error {
+	command;
+	args;
+	code;
+	constructor(message, options) {
+		super(message, options.cause ? { cause: options.cause } : void 0);
+		this.name = "LspClientStartError";
+		this.command = options.command;
+		this.args = options.args;
+		this.code = options.code;
+	}
+};
+var LspClient = class extends EventEmitter {
+	#proc = null;
+	#options;
+	#next_id = 1;
+	#pending = /* @__PURE__ */ new Map();
+	#buffer = Buffer.alloc(0);
+	#initialized = false;
+	#open_docs = /* @__PURE__ */ new Map();
+	#diagnostics_by_uri = /* @__PURE__ */ new Map();
+	#diagnostic_waiters = /* @__PURE__ */ new Set();
+	constructor(options) {
+		super();
+		this.#options = options;
+	}
+	async start() {
+		this.#proc = spawn(this.#options.command, this.#options.args, {
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			env: process.env
+		});
+		let start_reject = null;
+		const start_failure = new Promise((_, reject) => {
+			start_reject = reject;
+		});
+		const reject_start = (error) => {
+			if (!start_reject) return false;
+			const reject = start_reject;
+			start_reject = null;
+			reject(error);
+			return true;
+		};
+		const start_error = (message, cause, code) => new LspClientStartError(message, {
+			command: this.#options.command,
+			args: this.#options.args,
+			cause,
+			code
+		});
+		this.#proc.on("error", (err) => {
+			const wrapped = start_error(`Failed to spawn ${this.#options.command}`, err, error_code(err));
+			if (!reject_start(wrapped)) this.#emit_error(wrapped);
+		});
+		this.#proc.on("close", () => {
+			if (!this.#initialized) reject_start(start_error(`LSP server ${this.#options.command} closed before initialization`));
+			for (const pending of this.#pending.values()) {
+				clearTimeout(pending.timer);
+				pending.reject(/* @__PURE__ */ new Error("LSP server closed"));
+			}
+			this.#pending.clear();
+			this.#initialized = false;
+			this.#proc = null;
+		});
+		this.#proc.stderr?.on("data", () => {});
+		this.#proc.stdout.on("data", (chunk) => {
+			this.#buffer = Buffer.concat([this.#buffer, chunk]);
+			this.#drain_buffer();
+		});
+		try {
+			await Promise.race([this.#request("initialize", {
+				processId: process.pid,
+				rootUri: this.#options.root_uri,
+				capabilities: {
+					textDocument: {
+						publishDiagnostics: { relatedInformation: true },
+						hover: { contentFormat: ["markdown", "plaintext"] },
+						definition: { linkSupport: false },
+						references: {},
+						documentSymbol: { hierarchicalDocumentSymbolSupport: true }
+					},
+					workspace: {
+						workspaceFolders: true,
+						symbol: {}
+					}
+				},
+				workspaceFolders: [{
+					uri: this.#options.root_uri,
+					name: "workspace"
+				}]
+			}), start_failure]);
+			this.#notify("initialized", {});
+			this.#initialized = true;
+			start_reject = null;
+		} catch (error) {
+			await this.stop();
+			throw error;
+		}
+	}
+	is_ready() {
+		return this.#initialized;
+	}
+	async ensure_document_open(uri, text) {
+		const existing = this.#open_docs.get(uri);
+		if (existing) {
+			if (existing.text === text) return;
+			const next_version = existing.version + 1;
+			this.#open_docs.set(uri, {
+				version: next_version,
+				text
+			});
+			this.#notify("textDocument/didChange", {
+				textDocument: {
+					uri,
+					version: next_version
+				},
+				contentChanges: [{ text }]
+			});
+			return;
+		}
+		const language_id = this.#options.language_id_for_uri(uri) ?? "plaintext";
+		this.#open_docs.set(uri, {
+			version: 1,
+			text
+		});
+		this.#notify("textDocument/didOpen", { textDocument: {
+			uri,
+			languageId: language_id,
+			version: 1,
+			text
+		} });
+	}
+	async hover(uri, position) {
+		return await this.#request("textDocument/hover", {
+			textDocument: { uri },
+			position
+		}) ?? null;
+	}
+	async definition(uri, position) {
+		return normalize_location_result(await this.#request("textDocument/definition", {
+			textDocument: { uri },
+			position
+		}));
+	}
+	async references(uri, position, include_declaration) {
+		return await this.#request("textDocument/references", {
+			textDocument: { uri },
+			position,
+			context: { includeDeclaration: include_declaration }
+		}) ?? [];
+	}
+	async document_symbols(uri) {
+		return normalize_document_symbol_result(await this.#request("textDocument/documentSymbol", { textDocument: { uri } }));
+	}
+	get_diagnostics(uri) {
+		return this.#diagnostics_by_uri.get(uri) ?? [];
+	}
+	async wait_for_diagnostics(uri, timeout_ms = 1500) {
+		if (this.#diagnostics_by_uri.has(uri)) return this.get_diagnostics(uri);
+		return new Promise((resolve) => {
+			let active = true;
+			const cleanup = () => {
+				if (!active) return;
+				active = false;
+				this.off("diagnostics", handler);
+				clearTimeout(timer);
+				this.#diagnostic_waiters.delete(cleanup);
+				resolve(this.get_diagnostics(uri));
+			};
+			const handler = (event_uri) => {
+				if (event_uri !== uri) return;
+				cleanup();
+			};
+			const timer = setTimeout(cleanup, timeout_ms);
+			this.on("diagnostics", handler);
+			this.#diagnostic_waiters.add(cleanup);
+		});
+	}
+	async stop() {
+		if (this.#initialized) try {
+			await this.#request("shutdown", null, 1e3);
+			this.#notify("exit", null);
+		} catch {}
+		for (const pending of this.#pending.values()) {
+			clearTimeout(pending.timer);
+			pending.reject(/* @__PURE__ */ new Error("LSP client stopped"));
+		}
+		this.#pending.clear();
+		for (const cleanup of Array.from(this.#diagnostic_waiters)) cleanup();
+		if (this.#proc) {
+			this.#proc.kill();
+			this.#proc = null;
+		}
+		this.#initialized = false;
+	}
+	#request(method, params, timeout_override) {
+		return new Promise((resolve, reject) => {
+			const id = this.#next_id++;
+			const timeout_ms = timeout_override ?? this.#options.request_timeout_ms ?? 3e4;
+			const timer = setTimeout(() => {
+				if (this.#pending.has(id)) {
+					this.#pending.delete(id);
+					reject(/* @__PURE__ */ new Error(`LSP request ${method} timed out`));
+				}
+			}, timeout_ms);
+			this.#pending.set(id, {
+				resolve,
+				reject,
+				timer
+			});
+			try {
+				this.#send({
+					jsonrpc: "2.0",
+					id,
+					method,
+					params
+				});
+			} catch (error) {
+				clearTimeout(timer);
+				this.#pending.delete(id);
+				reject(error);
+			}
+		});
+	}
+	#notify(method, params) {
+		this.#send({
+			jsonrpc: "2.0",
+			method,
+			params
+		});
+	}
+	#send(message) {
+		if (!this.#proc?.stdin?.writable) throw new Error("LSP server not connected");
+		const body = Buffer.from(JSON.stringify(message), "utf8");
+		const header = Buffer.from(`Content-Length: ${body.length}\r\n\r\n`, "ascii");
+		this.#proc.stdin.write(Buffer.concat([header, body]));
+	}
+	#emit_error(error) {
+		if (this.listenerCount("error") > 0) this.emit("error", error);
+	}
+	#drain_buffer() {
+		while (true) {
+			const header_end = this.#buffer.indexOf("\r\n\r\n");
+			if (header_end === -1) return;
+			const match = this.#buffer.subarray(0, header_end).toString("ascii").match(/Content-Length:\s*(\d+)/i);
+			if (!match) {
+				this.#buffer = this.#buffer.subarray(header_end + 4);
+				continue;
+			}
+			const length = Number(match[1]);
+			const body_start = header_end + 4;
+			if (this.#buffer.length < body_start + length) return;
+			const body = this.#buffer.subarray(body_start, body_start + length);
+			this.#buffer = this.#buffer.subarray(body_start + length);
+			try {
+				this.#handle_message(JSON.parse(body.toString("utf8")));
+			} catch (error) {
+				this.#emit_error(error);
+			}
+		}
+	}
+	#handle_message(message) {
+		const numeric_id = typeof message.id === "number" ? message.id : typeof message.id === "string" && /^-?\d+$/.test(message.id) ? Number(message.id) : null;
+		if (numeric_id != null && this.#pending.has(numeric_id)) {
+			const pending = this.#pending.get(numeric_id);
+			this.#pending.delete(numeric_id);
+			clearTimeout(pending.timer);
+			if (message.error) pending.reject(/* @__PURE__ */ new Error(`LSP error ${message.error.code}: ${message.error.message}`));
+			else pending.resolve(message.result);
+			return;
+		}
+		if (message.method === "textDocument/publishDiagnostics" && message.params) {
+			const params = message.params;
+			this.#diagnostics_by_uri.set(params.uri, params.diagnostics);
+			this.emit("diagnostics", params.uri);
+			return;
+		}
+		if (message.method && message.id != null) this.#send({
+			jsonrpc: "2.0",
+			id: message.id,
+			result: null
+		});
+	}
+};
+function normalize_location_result(result) {
+	if (!result) return [];
+	return (Array.isArray(result) ? result : [result]).map((entry) => {
+		if ("uri" in entry) return entry;
+		return {
+			uri: entry.targetUri,
+			range: entry.targetSelectionRange ?? entry.targetRange
+		};
+	});
+}
+function normalize_document_symbol_result(result) {
+	if (!result) return [];
+	if (result.length === 0 || "range" in result[0] && "selectionRange" in result[0]) return result;
+	return result.map((entry) => ({
+		name: entry.name,
+		kind: entry.kind,
+		range: entry.location.range,
+		selectionRange: entry.location.range,
+		containerName: entry.containerName,
+		uri: entry.location.uri
+	}));
+}
+function file_path_to_uri(file_path) {
+	return pathToFileURL(file_path).href;
+}
+function error_code(error) {
+	return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
+}
+//#endregion
+//#region src/lsp/servers.ts
+const EXTENSION_LANGUAGES = {
+	".ts": "typescript",
+	".tsx": "typescript",
+	".mts": "typescript",
+	".cts": "typescript",
+	".js": "typescript",
+	".jsx": "typescript",
+	".mjs": "typescript",
+	".cjs": "typescript",
+	".py": "python",
+	".rs": "rust",
+	".go": "go",
+	".rb": "ruby",
+	".java": "java",
+	".lua": "lua",
+	".svelte": "svelte"
+};
+const LANGUAGE_SERVERS = {
+	typescript: {
+		language: "typescript",
+		command: "typescript-language-server",
+		args: ["--stdio"],
+		install_hint: "Install TypeScript LSP with: pnpm add -D typescript typescript-language-server"
+	},
+	python: {
+		language: "python",
+		command: "pylsp",
+		args: [],
+		install_hint: "Install Python LSP with: pip install python-lsp-server"
+	},
+	rust: {
+		language: "rust",
+		command: "rust-analyzer",
+		args: [],
+		install_hint: "Install Rust Analyzer and ensure the rust-analyzer binary is on PATH."
+	},
+	go: {
+		language: "go",
+		command: "gopls",
+		args: ["serve"],
+		install_hint: "Install Go LSP with: go install golang.org/x/tools/gopls@latest"
+	},
+	ruby: {
+		language: "ruby",
+		command: "solargraph",
+		args: ["stdio"],
+		install_hint: "Install Ruby LSP with: gem install solargraph"
+	},
+	java: {
+		language: "java",
+		command: "jdtls",
+		args: [],
+		install_hint: "Install Eclipse JDT Language Server and ensure the jdtls binary is on PATH."
+	},
+	lua: {
+		language: "lua",
+		command: "lua-language-server",
+		args: [],
+		install_hint: "Install Lua LSP and ensure the lua-language-server binary is on PATH."
+	},
+	svelte: {
+		language: "svelte",
+		command: "svelteserver",
+		args: ["--stdio"],
+		install_hint: "Install Svelte LSP with: pnpm add -D svelte-language-server (or volta install svelte-language-server)"
+	}
+};
+const WORKSPACE_MARKERS = [
+	"svelte.config.js",
+	"svelte.config.ts",
+	"tsconfig.json",
+	"jsconfig.json",
+	"package.json",
+	"pyproject.toml",
+	"Cargo.toml",
+	"go.mod",
+	"Gemfile",
+	"pom.xml",
+	"build.gradle",
+	"build.gradle.kts"
+];
+const REPOSITORY_MARKERS = [
+	"pnpm-workspace.yaml",
+	"package-lock.json",
+	"yarn.lock",
+	"bun.lockb",
+	"bun.lock",
+	".git"
+];
+function detect_language(file_path) {
+	return EXTENSION_LANGUAGES[extname(file_path).toLowerCase()];
+}
+function list_supported_languages() {
+	return Object.keys(LANGUAGE_SERVERS).sort();
+}
+function resolve_server_command(command, cwd = process.cwd()) {
+	if (!command) return command;
+	if (isAbsolute(command) || command.includes("/") || command.includes("\\")) return command;
+	for (const dir of ancestor_directories(cwd)) {
+		const local_bin = resolve_local_binary(dir, command);
+		if (local_bin) return local_bin;
+	}
+	return command;
+}
+function get_server_config(language, cwd = process.cwd()) {
+	const base = LANGUAGE_SERVERS[language];
+	if (!base) return void 0;
+	return {
+		...base,
+		command: resolve_server_command(base.command, cwd)
+	};
+}
+function language_id_for_file(file_path) {
+	return detect_language(file_path);
+}
+function find_workspace_root(file_path, fallback = process.cwd()) {
+	const start = resolve(dirname(file_path));
+	const project_root = find_nearest_marker_directory(start, WORKSPACE_MARKERS);
+	if (project_root) return project_root;
+	const repo_root = find_nearest_marker_directory(start, REPOSITORY_MARKERS);
+	if (repo_root) return repo_root;
+	return resolve(fallback);
+}
+function find_nearest_marker_directory(start, markers) {
+	for (const dir of ancestor_directories(start)) if (markers.some((marker) => existsSync(join(dir, marker)))) return dir;
+}
+function ancestor_directories(start) {
+	const dirs = [];
+	let current = resolve(start);
+	while (true) {
+		dirs.push(current);
+		const parent = dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return dirs;
+}
+function resolve_local_binary(directory, command) {
+	return [join(directory, "node_modules", ".bin", command), join(directory, "node_modules", ".bin", `${command}.cmd`)].find((candidate) => existsSync(candidate));
+}
+//#endregion
+//#region src/extensions/lsp.ts
+var LspToolError = class extends Error {
+	details;
+	constructor(details) {
+		super(details.message);
+		this.name = "LspToolError";
+		this.details = details;
+	}
+};
+var LspStartupCancelledError = class extends Error {
+	constructor(language, workspace_root) {
+		super(`Startup cancelled for ${language} LSP in ${workspace_root}`);
+		this.name = "LspStartupCancelledError";
+	}
+};
+const SYMBOL_KIND_LABELS = {
+	2: "module",
+	3: "namespace",
+	5: "class",
+	6: "method",
+	7: "property",
+	8: "field",
+	9: "constructor",
+	11: "interface",
+	12: "function",
+	13: "variable",
+	14: "constant",
+	23: "struct",
+	24: "event"
+};
+const SYMBOL_KIND_NAMES = Object.values(SYMBOL_KIND_LABELS);
+const SYMBOL_KIND_SCHEMA = Type.Union(SYMBOL_KIND_NAMES.map((name) => Type.Literal(name)));
+function create_lsp_extension(options = {}) {
+	const create_client = options.create_client ?? ((client_options) => new LspClient(client_options));
+	const read_file = options.read_file ?? ((path) => readFile(path, "utf-8"));
+	return async function lsp(pi) {
+		const cwd = options.cwd?.() ?? process.cwd();
+		const clients_by_server = /* @__PURE__ */ new Map();
+		const failed_servers = /* @__PURE__ */ new Map();
+		const starting_servers = /* @__PURE__ */ new Map();
+		const resolve_abs = (file) => isAbsolute(file) ? file : resolve(cwd, file);
+		const server_key = (language, workspace_root) => `${language}\u0000${workspace_root}`;
+		const make_tool_result = (text, details = {}) => ({
+			content: [{
+				type: "text",
+				text
+			}],
+			details
+		});
+		const make_tool_error = (details) => make_tool_result(format_tool_error(details), {
+			ok: false,
+			error: details
+		});
+		const clear_language_state = async (language) => {
+			const states = language ? Array.from(clients_by_server.entries()).filter(([, state]) => state.language === language) : Array.from(clients_by_server.entries());
+			const starting = language ? Array.from(starting_servers.entries()).filter(([key]) => key.startsWith(`${language}\u0000`)) : Array.from(starting_servers.entries());
+			for (const [key, startup] of starting) {
+				startup.cancelled = true;
+				starting_servers.delete(key);
+			}
+			await Promise.allSettled(states.map(([, state]) => state.client.stop()));
+			for (const [key] of states) clients_by_server.delete(key);
+			if (!language) {
+				failed_servers.clear();
+				return;
+			}
+			for (const [key, failure] of failed_servers.entries()) if (failure.language === language) failed_servers.delete(key);
+		};
+		const get_or_start_client = async (file_path) => {
+			const language = detect_language(file_path);
+			if (!language) return void 0;
+			const workspace_root = find_workspace_root(file_path, cwd);
+			const key = server_key(language, workspace_root);
+			const existing = clients_by_server.get(key);
+			if (existing) return existing;
+			const failed = failed_servers.get(key);
+			if (failed) throw new LspToolError(failed);
+			const in_flight = starting_servers.get(key);
+			if (in_flight) return in_flight.promise;
+			const server_config = get_server_config(language, workspace_root);
+			if (!server_config) return void 0;
+			const root_uri = file_path_to_uri(workspace_root);
+			const startup = {
+				cancelled: false,
+				promise: Promise.resolve(void 0)
+			};
+			const start_promise = (async () => {
+				const client = create_client({
+					command: server_config.command,
+					args: server_config.args,
+					root_uri,
+					language_id_for_uri: (uri) => language_id_for_file(uri)
+				});
+				try {
+					await client.start();
+				} catch (error) {
+					if (startup.cancelled) throw new LspStartupCancelledError(language, workspace_root);
+					const failure = to_lsp_tool_error(file_path, language, workspace_root, server_config.command, server_config.install_hint, error);
+					failed_servers.set(key, failure);
+					throw new LspToolError(failure);
+				}
+				if (startup.cancelled) {
+					await Promise.allSettled([client.stop()]);
+					throw new LspStartupCancelledError(language, workspace_root);
+				}
+				const state = {
+					client,
+					language,
+					workspace_root,
+					root_uri,
+					command: server_config.command,
+					install_hint: server_config.install_hint
+				};
+				clients_by_server.set(key, state);
+				failed_servers.delete(key);
+				return state;
+			})();
+			startup.promise = start_promise;
+			starting_servers.set(key, startup);
+			try {
+				return await start_promise;
+			} finally {
+				if (starting_servers.get(key) === startup) starting_servers.delete(key);
+			}
+		};
+		const open_file = async (state, abs_path) => {
+			const text = await read_file(abs_path);
+			const uri = file_path_to_uri(abs_path);
+			await state.client.ensure_document_open(uri, text);
+			return uri;
+		};
+		const get_file_state = async (file) => {
+			const abs = resolve_abs(file);
+			const state = await get_or_start_client(abs);
+			if (!state) return void 0;
+			return {
+				abs,
+				uri: await open_file(state, abs),
+				state
+			};
+		};
+		const resolve_file_state = async (file) => {
+			const abs = resolve_abs(file);
+			try {
+				const result = await get_file_state(abs);
+				if (!result) return {
+					ok: false,
+					error: {
+						kind: "unsupported_language",
+						file: abs,
+						message: `No language server configured for ${abs}`
+					}
+				};
+				return {
+					ok: true,
+					result
+				};
+			} catch (error) {
+				if (error instanceof LspToolError) return {
+					ok: false,
+					error: error.details
+				};
+				return {
+					ok: false,
+					error: {
+						kind: "tool_execution_failed",
+						file: abs,
+						message: error instanceof Error ? error.message : String(error)
+					}
+				};
+			}
+		};
+		const with_file_state = async (file, run) => {
+			const resolved = await resolve_file_state(file);
+			if (!resolved.ok) return make_tool_error(resolved.error);
+			const { result } = resolved;
+			try {
+				return make_tool_result(await run(result), {
+					ok: true,
+					language: result.state.language,
+					command: result.state.command,
+					workspace_root: result.state.workspace_root
+				});
+			} catch (error) {
+				return make_tool_error(to_lsp_tool_error(result.abs, result.state.language, result.state.workspace_root, result.state.command, result.state.install_hint, error));
+			}
+		};
+		pi.registerTool(defineTool({
+			name: "lsp_diagnostics",
+			label: "LSP: diagnostics",
+			description: "Get language server diagnostics (errors, warnings, hints) for a file. Uses the project language server and returns empty output if the file is clean.",
+			parameters: Type.Object({
+				file: Type.String({ description: "Path to the file to check (relative to cwd or absolute)." }),
+				wait_ms: Type.Optional(Type.Number({ description: "Max ms to wait for diagnostics after opening the file. Default 1500." }))
+			}),
+			execute: async (_id, params) => with_file_state(params.file, async (result) => {
+				const diagnostics = await result.state.client.wait_for_diagnostics(result.uri, params.wait_ms ?? 1500);
+				return format_diagnostics(result.abs, diagnostics);
+			})
+		}));
+		pi.registerTool(defineTool({
+			name: "lsp_diagnostics_many",
+			label: "LSP: diagnostics many",
+			description: "Get language server diagnostics for multiple files in one call. Useful for package-level sweeps and summarization.",
+			parameters: Type.Object({
+				files: Type.Array(Type.String(), {
+					minItems: 1,
+					maxItems: 100,
+					description: "Files to check (relative to cwd or absolute)."
+				}),
+				wait_ms: Type.Optional(Type.Number({ description: "Max ms to wait for diagnostics after opening each file. Default 1500." }))
+			}),
+			execute: async (_id, params) => {
+				const results = await Promise.all(params.files.map((file) => resolve_file_state(file)));
+				const wait_ms = params.wait_ms ?? 1500;
+				const lines_with_stats = await Promise.all(results.map(async (resolved) => {
+					if (!resolved.ok) return {
+						line: format_tool_error(resolved.error),
+						diagnostics: 0,
+						error: true
+					};
+					const diagnostics = await resolved.result.state.client.wait_for_diagnostics(resolved.result.uri, wait_ms);
+					return {
+						line: format_diagnostics(resolved.result.abs, diagnostics),
+						diagnostics: diagnostics.length,
+						error: false
+					};
+				}));
+				let diagnostic_count = 0;
+				let clean_count = 0;
+				let error_count = 0;
+				const lines = [];
+				for (const entry of lines_with_stats) {
+					lines.push(entry.line);
+					if (entry.error) error_count += 1;
+					else {
+						diagnostic_count += entry.diagnostics;
+						if (entry.diagnostics === 0) clean_count += 1;
+					}
+				}
+				return make_tool_result([`Checked ${params.files.length} file(s): ${diagnostic_count} diagnostic(s), ${clean_count} clean, ${error_count} error(s)`, ...lines].join("\n\n"), {
+					ok: error_count === 0,
+					checked: params.files.length,
+					diagnostic_count,
+					clean_count,
+					error_count
+				});
+			}
+		}));
+		pi.registerTool(defineTool({
+			name: "lsp_find_symbol",
+			label: "LSP: find symbol",
+			description: "Find symbols in a file by name or detail text using document symbols. Supports exact matching, kind filters, and top-level-only mode.",
+			parameters: Type.Object({
+				file: Type.String(),
+				query: Type.String({ description: "Substring to match against symbol names/details." }),
+				max_results: Type.Optional(Type.Number({ description: "Max number of matches to return. Default 20." })),
+				top_level_only: Type.Optional(Type.Boolean({ description: "Only match top-level symbols. Default false." })),
+				exact_match: Type.Optional(Type.Boolean({ description: "Match whole symbol names/details exactly instead of substring matching. Default false." })),
+				kinds: Type.Optional(Type.Array(SYMBOL_KIND_SCHEMA, {
+					minItems: 1,
+					maxItems: SYMBOL_KIND_NAMES.length,
+					description: "Restrict matches to these symbol kinds."
+				}))
+			}),
+			execute: async (_id, params) => with_file_state(params.file, async (result) => {
+				const matches = find_symbol_matches(await result.state.client.document_symbols(result.uri), params.query, {
+					max_results: params.max_results ?? 20,
+					top_level_only: params.top_level_only ?? false,
+					exact_match: params.exact_match ?? false,
+					kinds: new Set(params.kinds ?? [])
+				});
+				return format_symbol_matches(result.abs, params.query, matches);
+			})
+		}));
+		pi.registerTool(defineTool({
+			name: "lsp_hover",
+			label: "LSP: hover",
+			description: "Get hover info (types, docs) at a position in a file. Positions are zero-based.",
+			parameters: Type.Object({
+				file: Type.String(),
+				line: Type.Number({ description: "Zero-based line number." }),
+				character: Type.Number({ description: "Zero-based character offset." })
+			}),
+			execute: async (_id, params) => with_file_state(params.file, async (result) => {
+				return format_hover(await result.state.client.hover(result.uri, {
+					line: params.line,
+					character: params.character
+				}));
+			})
+		}));
+		pi.registerTool(defineTool({
+			name: "lsp_definition",
+			label: "LSP: go to definition",
+			description: "Find definition locations for the symbol at a position. Positions are zero-based.",
+			parameters: Type.Object({
+				file: Type.String(),
+				line: Type.Number(),
+				character: Type.Number()
+			}),
+			execute: async (_id, params) => with_file_state(params.file, async (result) => {
+				return format_locations(await result.state.client.definition(result.uri, {
+					line: params.line,
+					character: params.character
+				}), "No definition found.");
+			})
+		}));
+		pi.registerTool(defineTool({
+			name: "lsp_references",
+			label: "LSP: find references",
+			description: "Find references to the symbol at a position. Positions are zero-based.",
+			parameters: Type.Object({
+				file: Type.String(),
+				line: Type.Number(),
+				character: Type.Number(),
+				include_declaration: Type.Optional(Type.Boolean())
+			}),
+			execute: async (_id, params) => with_file_state(params.file, async (result) => {
+				return format_locations(await result.state.client.references(result.uri, {
+					line: params.line,
+					character: params.character
+				}, params.include_declaration ?? true), "No references found.");
+			})
+		}));
+		pi.registerTool(defineTool({
+			name: "lsp_document_symbols",
+			label: "LSP: document symbols",
+			description: "List symbols in a file (functions, classes, variables) using the language server.",
+			parameters: Type.Object({ file: Type.String() }),
+			execute: async (_id, params) => with_file_state(params.file, async (result) => {
+				const symbols = await result.state.client.document_symbols(result.uri);
+				return format_document_symbols(result.abs, symbols);
+			})
+		}));
+		pi.registerCommand("lsp", {
+			description: "Show or manage language server state",
+			getArgumentCompletions: (prefix) => {
+				const parts = prefix.trim().split(/\s+/);
+				const subcommands = [
+					"status",
+					"list",
+					"restart"
+				];
+				if (!prefix.trim()) return subcommands.map((value) => ({
+					value,
+					label: value
+				}));
+				if (parts.length <= 1) return subcommands.filter((value) => value.startsWith(parts[0])).map((value) => ({
+					value,
+					label: value
+				}));
+				if (parts[0] === "restart") {
+					const candidate = parts[1] ?? "";
+					return ["all", ...list_supported_languages()].filter((value) => value.startsWith(candidate)).map((value) => ({
+						value: `restart ${value}`,
+						label: value
+					}));
+				}
+				return null;
+			},
+			handler: async (args, ctx) => {
+				await handle_lsp_command(args, ctx, cwd, clients_by_server, failed_servers, clear_language_state);
+			}
+		});
+		pi.on("session_shutdown", async () => {
+			await clear_language_state();
+		});
+	};
+}
+var lsp_default = create_lsp_extension();
+async function handle_lsp_command(args, ctx, cwd, clients_by_server, failed_servers, clear_language_state) {
+	const [subcommand = "status", target] = args.trim() ? args.trim().split(/\s+/, 2) : [];
+	switch (subcommand) {
+		case "status":
+		case "list":
+			ctx.ui.notify(format_status_lines(cwd, clients_by_server, failed_servers).join("\n"));
+			return;
+		case "restart":
+			if (!target || target === "all") {
+				await clear_language_state();
+				ctx.ui.notify("Restarted all language server state.");
+				return;
+			}
+			if (!list_supported_languages().includes(target)) {
+				ctx.ui.notify(`Unknown language: ${target}. Use one of: ${list_supported_languages().join(", ")}`, "warning");
+				return;
+			}
+			await clear_language_state(target);
+			ctx.ui.notify(`Restarted ${target} language server state.`);
+			return;
+		default: ctx.ui.notify(`Unknown subcommand: ${subcommand}. Use: status, list, restart`, "warning");
+	}
+}
+function format_status_lines(cwd, clients_by_server, failed_servers) {
+	const lines = [];
+	const active_languages = /* @__PURE__ */ new Set();
+	const running_states = Array.from(clients_by_server.values()).sort((a, b) => a.language.localeCompare(b.language) || a.workspace_root.localeCompare(b.workspace_root));
+	for (const running of running_states) {
+		active_languages.add(running.language);
+		lines.push(`${running.language}: running (ready=${running.client.is_ready()}) — ${running.command} [workspace ${running.workspace_root}]`);
+	}
+	const failures = Array.from(failed_servers.values()).sort((a, b) => (a.language ?? "").localeCompare(b.language ?? "") || (a.workspace_root ?? "").localeCompare(b.workspace_root ?? ""));
+	for (const failure of failures) {
+		if (failure.language) active_languages.add(failure.language);
+		const workspace = failure.workspace_root ? ` [workspace ${failure.workspace_root}]` : "";
+		const language = failure.language ?? "unknown";
+		lines.push(`${language}: failed — ${failure.message}${workspace}`);
+	}
+	for (const language of list_supported_languages()) {
+		if (active_languages.has(language)) continue;
+		const config = get_server_config(language, cwd);
+		if (config) lines.push(`${language}: idle — ${config.command}`);
+	}
+	return lines.length > 0 ? lines : ["No language servers configured for this project."];
+}
+function to_lsp_tool_error(file, language, workspace_root, command, install_hint, error) {
+	if (error instanceof LspToolError) return error.details;
+	if (error instanceof LspClientStartError) {
+		const missing_binary = error.code === "ENOENT";
+		return {
+			kind: "server_start_failed",
+			file,
+			language,
+			workspace_root,
+			command,
+			install_hint,
+			code: error.code,
+			message: missing_binary ? `command "${command}" not found` : error.message
+		};
+	}
+	return {
+		kind: "tool_execution_failed",
+		file,
+		language,
+		workspace_root,
+		command,
+		install_hint,
+		message: error instanceof Error ? error.message : String(error),
+		code: typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0
+	};
+}
+function format_tool_error(details) {
+	if (details.kind === "unsupported_language") return details.message;
+	const lines = [details.language ? `${details.language} LSP unavailable for ${details.file}` : `LSP request failed for ${details.file}`, `Reason: ${details.message}`];
+	if (details.command) lines.push(`Command: ${details.command}`);
+	if (details.workspace_root) lines.push(`Workspace: ${details.workspace_root}`);
+	if (details.install_hint) lines.push(`Hint: ${details.install_hint}`);
+	return lines.join("\n");
+}
+function severity_label(severity) {
+	switch (severity) {
+		case 1: return "error";
+		case 2: return "warning";
+		case 3: return "info";
+		case 4: return "hint";
+		default: return "info";
+	}
+}
+function format_diagnostics(file, diagnostics) {
+	if (diagnostics.length === 0) return `${file}: no diagnostics`;
+	const lines = [`${file}: ${diagnostics.length} diagnostic(s)`];
+	for (const d of diagnostics) {
+		const position = `${d.range.start.line + 1}:${d.range.start.character + 1}`;
+		const source = d.source ? ` [${d.source}]` : "";
+		const code = d.code != null ? ` (${d.code})` : "";
+		lines.push(`  ${position} ${severity_label(d.severity)}${source}${code}: ${d.message}`);
+	}
+	return lines.join("\n");
+}
+function format_hover(hover) {
+	if (!hover) return "No hover info.";
+	const contents = hover.contents;
+	const extract = (item) => typeof item === "string" ? item : item.value ?? "";
+	if (Array.isArray(contents)) return contents.map(extract).join("\n\n").trim() || "No hover info.";
+	return extract(contents).trim() || "No hover info.";
+}
+function format_locations(locations, empty_message) {
+	if (locations.length === 0) return empty_message;
+	return locations.map((loc) => {
+		return `${file_url_to_path_or_value(loc.uri)}:${loc.range.start.line + 1}:${loc.range.start.character + 1}`;
+	}).join("\n");
+}
+function format_document_symbols(file, symbols) {
+	if (symbols.length === 0) return `${file}: no symbols`;
+	const lines = [`${file}: ${symbols.length} top-level symbol(s)`];
+	append_symbol_lines(lines, symbols, 1);
+	return lines.join("\n");
+}
+function find_symbol_matches(symbols, query, options) {
+	const normalized = query.trim().toLowerCase();
+	if (!normalized) return [];
+	const matches = [];
+	const matches_query = (symbol) => {
+		const values = [symbol.name, symbol.detail ?? ""].map((value) => value.trim().toLowerCase());
+		return options.exact_match ? values.some((value) => value === normalized) : values.some((value) => value.includes(normalized));
+	};
+	const matches_kind = (symbol) => {
+		if (options.kinds.size === 0) return true;
+		return options.kinds.has(symbol_kind_label(symbol.kind));
+	};
+	const visit = (entries, depth) => {
+		for (const symbol of entries) {
+			if (matches_kind(symbol) && matches_query(symbol)) {
+				matches.push({
+					symbol,
+					depth
+				});
+				if (matches.length >= options.max_results) return;
+			}
+			if (!options.top_level_only && symbol.children?.length) {
+				visit(symbol.children, depth + 1);
+				if (matches.length >= options.max_results) return;
+			}
+		}
+	};
+	visit(symbols, 1);
+	return matches;
+}
+function format_symbol_matches(file, query, matches) {
+	if (matches.length === 0) return `${file}: no symbols matching "${query}"`;
+	const lines = [`${file}: ${matches.length} symbol match(es) for "${query}"`];
+	for (const { symbol, depth } of matches) {
+		const indent = "  ".repeat(depth);
+		const detail = symbol.detail ? ` — ${symbol.detail}` : "";
+		const range = `${symbol.range.start.line + 1}:${symbol.range.start.character + 1}`;
+		lines.push(`${indent}${symbol_kind_label(symbol.kind)} ${symbol.name}${detail} @ ${range}`);
+	}
+	return lines.join("\n");
+}
+function append_symbol_lines(lines, symbols, depth) {
+	for (const symbol of symbols) {
+		const indent = "  ".repeat(depth);
+		const detail = symbol.detail ? ` — ${symbol.detail}` : "";
+		const range = `${symbol.range.start.line + 1}:${symbol.range.start.character + 1}`;
+		lines.push(`${indent}${symbol_kind_label(symbol.kind)} ${symbol.name}${detail} @ ${range}`);
+		if (symbol.children?.length) append_symbol_lines(lines, symbol.children, depth + 1);
+	}
+}
+function symbol_kind_label(kind) {
+	return SYMBOL_KIND_LABELS[kind] ?? "symbol";
+}
+function file_url_to_path_or_value(uri) {
+	try {
+		return uri.startsWith("file:") ? fileURLToPath(uri) : uri;
+	} catch {
+		return uri;
+	}
+}
+//#endregion
 //#region src/mcp/client.ts
 var McpClient = class {
 	#proc = null;
@@ -1075,56 +2091,93 @@ function load_mcp_config(cwd) {
 }
 //#endregion
 //#region src/extensions/mcp.ts
+function remove_server_tools_from_active(pi, tool_names) {
+	const tool_set = new Set(tool_names);
+	pi.setActiveTools(pi.getActiveTools().filter((tool) => !tool_set.has(tool)));
+}
+function format_server_status(state) {
+	switch (state.status) {
+		case "connected": return state.enabled ? "enabled" : "disabled";
+		case "connecting": return state.enabled ? "connecting" : "connecting, disabled";
+		case "failed": return state.enabled ? "failed" : "failed, disabled";
+		default: return state.enabled ? "not connected yet" : "disabled";
+	}
+}
 async function mcp(pi) {
-	const cwd = process.cwd();
-	const servers = /* @__PURE__ */ new Map();
-	const configs = load_mcp_config(cwd);
-	const results = await Promise.allSettled(configs.map(async (config) => {
-		const client = new McpClient(config);
-		await client.connect();
-		return {
-			config,
-			client,
-			mcp_tools: await client.listTools()
-		};
-	}));
-	for (const result of results) {
-		if (result.status === "rejected") {
-			console.error(`MCP server failed: ${result.reason}`);
-			continue;
+	const configs = load_mcp_config(process.cwd());
+	const servers = new Map(configs.map((config) => [config.name, {
+		config,
+		tool_names: [],
+		enabled: true,
+		status: "disconnected"
+	}]));
+	const registered_tool_names = /* @__PURE__ */ new Set();
+	const connect_server = async (state) => {
+		if (state.status === "connected") return;
+		if (state.connect_promise) {
+			await state.connect_promise;
+			return;
 		}
-		const { config, client, mcp_tools } = result.value;
-		const tool_names = [];
-		for (const mcp_tool of mcp_tools) {
-			const tool_name = `mcp__${config.name}__${mcp_tool.name}`;
-			tool_names.push(tool_name);
-			pi.registerTool(defineTool({
-				name: tool_name,
-				label: `${config.name}: ${mcp_tool.name}`,
-				description: mcp_tool.description || mcp_tool.name,
-				parameters: mcp_tool.inputSchema || {
-					type: "object",
-					properties: {}
-				},
-				execute: async (_id, params) => {
-					const result = await client.callTool(mcp_tool.name, params);
-					return {
-						content: [{
-							type: "text",
-							text: result?.content?.map((c) => c.text || "").join("\n") || JSON.stringify(result)
-						}],
-						details: {}
-					};
+		state.connect_promise = (async () => {
+			state.status = "connecting";
+			state.error = void 0;
+			const client = new McpClient(state.config);
+			try {
+				await client.connect();
+				state.client = client;
+				const mcp_tools = await client.listTools();
+				const tool_names = [];
+				for (const mcp_tool of mcp_tools) {
+					const tool_name = `mcp__${state.config.name}__${mcp_tool.name}`;
+					tool_names.push(tool_name);
+					if (registered_tool_names.has(tool_name)) continue;
+					registered_tool_names.add(tool_name);
+					pi.registerTool(defineTool({
+						name: tool_name,
+						label: `${state.config.name}: ${mcp_tool.name}`,
+						description: mcp_tool.description || mcp_tool.name,
+						parameters: mcp_tool.inputSchema || {
+							type: "object",
+							properties: {}
+						},
+						execute: async (_id, params) => {
+							const result = await state.client.callTool(mcp_tool.name, params);
+							return {
+								content: [{
+									type: "text",
+									text: result?.content?.map((c) => c.text || "").join("\n") || JSON.stringify(result)
+								}],
+								details: {}
+							};
+						}
+					}));
 				}
-			}));
-		}
-		servers.set(config.name, {
-			config,
-			client,
-			tool_names,
-			enabled: true
-		});
-	}
+				state.tool_names = tool_names;
+				state.status = "connected";
+				if (!state.enabled) remove_server_tools_from_active(pi, state.tool_names);
+			} catch (error) {
+				state.status = "failed";
+				state.error = error instanceof Error ? error.message : String(error);
+				state.client = void 0;
+				await client.disconnect().catch(() => {});
+				console.error(`MCP server failed (${state.config.name}): ${state.error}`);
+				throw error;
+			} finally {
+				state.connect_promise = void 0;
+			}
+		})();
+		await state.connect_promise;
+	};
+	const connect_all_servers = async (options = {}) => {
+		await Promise.allSettled(Array.from(servers.values()).filter((state) => state.enabled).filter((state) => options.include_failed || state.status !== "failed").map((state) => connect_server(state)));
+	};
+	pi.on("session_start", async () => {
+		connect_all_servers();
+	});
+	pi.on("before_agent_start", async (event) => {
+		await connect_all_servers();
+		return event;
+	});
 	pi.registerCommand("mcp", {
 		description: "Manage MCP servers (list, enable, disable)",
 		getArgumentCompletions: (prefix) => {
@@ -1156,10 +2209,7 @@ async function mcp(pi) {
 						return;
 					}
 					const lines = [];
-					for (const [sname, state] of servers.entries()) {
-						const status = state.enabled ? "enabled" : "disabled";
-						lines.push(`${sname} (${status}) — ${state.tool_names.length} tools`);
-					}
+					for (const [sname, state] of servers.entries()) lines.push(`${sname} (${format_server_status(state)}) — ${state.tool_names.length} tools${state.error ? ` — ${state.error}` : ""}`);
 					ctx.ui.notify(lines.join("\n"));
 					break;
 				}
@@ -1169,14 +2219,23 @@ async function mcp(pi) {
 						ctx.ui.notify(`Unknown server: ${name}`, "warning");
 						return;
 					}
-					if (server.enabled) {
+					if (server.enabled && server.status !== "failed") {
 						ctx.ui.notify(`${name} already enabled`);
 						return;
 					}
 					server.enabled = true;
-					const active = pi.getActiveTools();
-					pi.setActiveTools([...active, ...server.tool_names]);
-					ctx.ui.notify(`Enabled ${name}`);
+					if (server.status === "connected") {
+						const active = pi.getActiveTools();
+						pi.setActiveTools([...active, ...server.tool_names]);
+						ctx.ui.notify(`Enabled ${name}`);
+						return;
+					}
+					if (server.status === "failed") {
+						server.status = "disconnected";
+						server.error = void 0;
+					}
+					connect_server(server);
+					ctx.ui.notify(`Enabling ${name} and connecting in background`);
 					break;
 				}
 				case "disable": {
@@ -1190,8 +2249,7 @@ async function mcp(pi) {
 						return;
 					}
 					server.enabled = false;
-					const tool_set = new Set(server.tool_names);
-					pi.setActiveTools(pi.getActiveTools().filter((t) => !tool_set.has(t)));
+					remove_server_tools_from_active(pi, server.tool_names);
 					ctx.ui.notify(`Disabled ${name}`);
 					break;
 				}
@@ -1200,7 +2258,12 @@ async function mcp(pi) {
 		}
 	});
 	pi.on("session_shutdown", async () => {
-		for (const server of servers.values()) await server.client.disconnect();
+		await Promise.allSettled(Array.from(servers.values()).map(async (server) => {
+			await server.connect_promise?.catch(() => {});
+			await server.client?.disconnect();
+			server.client = void 0;
+			if (server.status !== "failed") server.status = "disconnected";
+		}));
 	});
 }
 //#endregion
@@ -2021,22 +3084,20 @@ async function prompt_presets(pi) {
 //#endregion
 //#region src/extensions/recall.ts
 const DEFAULT_DB_PATH = join(process.env.HOME, ".pi", "pirecall.db");
-async function recall(pi) {
-	if (existsSync(DEFAULT_DB_PATH)) try {
-		execFileSync("npx", [
+function sync_recall_db_in_background() {
+	if (!existsSync(DEFAULT_DB_PATH)) return;
+	try {
+		spawn("npx", [
 			"pirecall",
 			"sync",
 			"--json"
-		], {
-			encoding: "utf-8",
-			timeout: 3e4,
-			stdio: [
-				"pipe",
-				"pipe",
-				"pipe"
-			]
-		});
+		], { stdio: "ignore" }).unref();
 	} catch {}
+}
+async function recall(pi) {
+	pi.on("session_start", async () => {
+		sync_recall_db_in_background();
+	});
 	pi.on("before_agent_start", async (event) => {
 		return { systemPrompt: event.systemPrompt + `
 
@@ -2814,7 +3875,8 @@ const BUILTIN_EXTENSION_FACTORIES = {
 	"filter-output": filter_output,
 	handoff,
 	recall,
-	"prompt-presets": prompt_presets
+	"prompt-presets": prompt_presets,
+	lsp: lsp_default
 };
 const PACKAGE_THEME_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "..", "themes");
 function get_force_disabled_builtins(options) {
@@ -2826,6 +3888,7 @@ function get_force_disabled_builtins(options) {
 	if (!options.handoff) force_disabled.add("handoff");
 	if (!options.recall) force_disabled.add("recall");
 	if (!options.prompt_presets) force_disabled.add("prompt-presets");
+	if (!options.lsp) force_disabled.add("lsp");
 	return force_disabled;
 }
 function create_builtin_extension_factory(key, extension, force_disabled) {
@@ -2847,7 +3910,7 @@ function create_extensions_override(managed_inline_paths) {
 	};
 }
 async function create_my_pi(options = {}) {
-	const { cwd = process.cwd(), extensions = [], extensionFactories: user_factories = [], mcp = true, skills = true, chain = true, filter_output = true, handoff = true, recall = true, prompt_presets = true, model, system_prompt, append_system_prompt } = options;
+	const { cwd = process.cwd(), extensions = [], extensionFactories: user_factories = [], mcp = true, skills = true, chain = true, filter_output = true, handoff = true, recall = true, prompt_presets = true, lsp = true, model, system_prompt, append_system_prompt } = options;
 	const resolved_extensions = extensions.map((p) => resolve(cwd, p));
 	const force_disabled = get_force_disabled_builtins({
 		mcp,
@@ -2856,7 +3919,8 @@ async function create_my_pi(options = {}) {
 		filter_output,
 		handoff,
 		recall,
-		prompt_presets
+		prompt_presets,
+		lsp
 	});
 	const managed_extension_factories = [create_extensions_extension({ force_disabled }), ...BUILTIN_EXTENSIONS.map((extension) => create_builtin_extension_factory(extension.key, BUILTIN_EXTENSION_FACTORIES[extension.key], force_disabled))];
 	const managed_inline_paths = managed_extension_factories.map((_, index) => `<inline:${index + 1}>`);
@@ -2905,4 +3969,4 @@ async function create_my_pi(options = {}) {
 //#endregion
 export { create_my_pi as n, runPrintMode$1 as r, InteractiveMode$1 as t };
 
-//# sourceMappingURL=api-BA6XuDOE.js.map
+//# sourceMappingURL=api-7LVj6kUV.js.map