my-pi 0.0.8 → 0.0.9

package/dist/{api-BA6XuDOE.js → api-Dcq2JalY.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 { 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,739 @@ ${task || "Continue from where the previous session left off."}
 	});
 }
 //#endregion
+//#region src/lsp/client.ts
+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();
+	constructor(options) {
+		super();
+		this.#options = options;
+	}
+	async start() {
+		this.#proc = spawn(this.#options.command, this.#options.args, {
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			env: process.env
+		});
+		this.#proc.on("error", (err) => {
+			this.emit("error", err);
+		});
+		this.#proc.on("close", () => {
+			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();
+		});
+		await 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"
+			}]
+		});
+		this.#notify("initialized", {});
+		this.#initialized = true;
+	}
+	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) ?? [];
+	}
+	get_all_diagnostics() {
+		return new Map(this.#diagnostics_by_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) => {
+			const handler = (event_uri) => {
+				if (event_uri !== uri) return;
+				this.off("diagnostics", handler);
+				clearTimeout(timer);
+				resolve(this.get_diagnostics(uri));
+			};
+			const timer = setTimeout(() => {
+				this.off("diagnostics", handler);
+				resolve(this.get_diagnostics(uri));
+			}, timeout_ms);
+			this.on("diagnostics", handler);
+		});
+	}
+	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();
+		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]));
+	}
+	#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) {
+		if (message.id != null && this.#pending.has(Number(message.id))) {
+			const pending = this.#pending.get(Number(message.id));
+			this.#pending.delete(Number(message.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;
+}
+//#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"]
+	},
+	python: {
+		language: "python",
+		command: "pylsp",
+		args: []
+	},
+	rust: {
+		language: "rust",
+		command: "rust-analyzer",
+		args: []
+	},
+	go: {
+		language: "go",
+		command: "gopls",
+		args: ["serve"]
+	},
+	ruby: {
+		language: "ruby",
+		command: "solargraph",
+		args: ["stdio"]
+	},
+	java: {
+		language: "java",
+		command: "jdtls",
+		args: []
+	},
+	lua: {
+		language: "lua",
+		command: "lua-language-server",
+		args: []
+	},
+	svelte: {
+		language: "svelte",
+		command: "svelteserver",
+		args: ["--stdio"]
+	}
+};
+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 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
+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 root_uri = file_path_to_uri(cwd);
+		const clients_by_language = /* @__PURE__ */ new Map();
+		const failed_languages = /* @__PURE__ */ new Map();
+		const resolve_abs = (file) => isAbsolute(file) ? file : resolve(cwd, file);
+		const clear_language_state = async (language) => {
+			if (language) {
+				const state = clients_by_language.get(language);
+				if (state) {
+					await state.client.stop();
+					clients_by_language.delete(language);
+				}
+				failed_languages.delete(language);
+				return;
+			}
+			await Promise.allSettled(Array.from(clients_by_language.values()).map((state) => state.client.stop()));
+			clients_by_language.clear();
+			failed_languages.clear();
+		};
+		const get_or_start_client = async (file_path) => {
+			const language = detect_language(file_path);
+			if (!language) return void 0;
+			const existing = clients_by_language.get(language);
+			if (existing) return existing;
+			if (failed_languages.has(language)) throw new Error(failed_languages.get(language));
+			const server_config = get_server_config(language, cwd);
+			if (!server_config) return void 0;
+			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) {
+				const message = error instanceof Error ? error.message : String(error);
+				const failure = `Failed to start ${server_config.command} for ${language}: ${message}. Install the language server and ensure it is available.`;
+				failed_languages.set(language, failure);
+				throw new Error(failure);
+			}
+			const state = {
+				client,
+				language,
+				root_uri,
+				command: server_config.command
+			};
+			clients_by_language.set(language, state);
+			failed_languages.delete(language);
+			return state;
+		};
+		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
+			};
+		};
+		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) => {
+				const result = await get_file_state(params.file);
+				if (!result) return {
+					content: [{
+						type: "text",
+						text: `No language server configured for ${resolve_abs(params.file)}`
+					}],
+					details: {}
+				};
+				const diagnostics = await result.state.client.wait_for_diagnostics(result.uri, params.wait_ms ?? 1500);
+				return {
+					content: [{
+						type: "text",
+						text: format_diagnostics(result.abs, diagnostics)
+					}],
+					details: {}
+				};
+			}
+		}));
+		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) => {
+				const result = await get_file_state(params.file);
+				if (!result) return {
+					content: [{
+						type: "text",
+						text: `No language server configured for ${resolve_abs(params.file)}`
+					}],
+					details: {}
+				};
+				return {
+					content: [{
+						type: "text",
+						text: format_hover(await result.state.client.hover(result.uri, {
+							line: params.line,
+							character: params.character
+						}))
+					}],
+					details: {}
+				};
+			}
+		}));
+		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) => {
+				const result = await get_file_state(params.file);
+				if (!result) return {
+					content: [{
+						type: "text",
+						text: `No language server configured for ${resolve_abs(params.file)}`
+					}],
+					details: {}
+				};
+				return {
+					content: [{
+						type: "text",
+						text: format_locations(await result.state.client.definition(result.uri, {
+							line: params.line,
+							character: params.character
+						}), "No definition found.")
+					}],
+					details: {}
+				};
+			}
+		}));
+		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) => {
+				const result = await get_file_state(params.file);
+				if (!result) return {
+					content: [{
+						type: "text",
+						text: `No language server configured for ${resolve_abs(params.file)}`
+					}],
+					details: {}
+				};
+				return {
+					content: [{
+						type: "text",
+						text: format_locations(await result.state.client.references(result.uri, {
+							line: params.line,
+							character: params.character
+						}, params.include_declaration ?? true), "No references found.")
+					}],
+					details: {}
+				};
+			}
+		}));
+		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) => {
+				const result = await get_file_state(params.file);
+				if (!result) return {
+					content: [{
+						type: "text",
+						text: `No language server configured for ${resolve_abs(params.file)}`
+					}],
+					details: {}
+				};
+				const symbols = await result.state.client.document_symbols(result.uri);
+				return {
+					content: [{
+						type: "text",
+						text: format_document_symbols(result.abs, symbols)
+					}],
+					details: {}
+				};
+			}
+		}));
+		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_language, failed_languages, 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_language, failed_languages, 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_language, failed_languages).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_language, failed_languages) {
+	const lines = [];
+	for (const language of list_supported_languages()) {
+		const running = clients_by_language.get(language);
+		if (running) {
+			lines.push(`${language}: running (ready=${running.client.is_ready()}) — ${running.command}`);
+			continue;
+		}
+		const failed = failed_languages.get(language);
+		if (failed) {
+			lines.push(`${language}: failed — ${failed}`);
+			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 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 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 {
+		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"
+	}[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;
@@ -2814,7 +3556,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 +3569,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 +3591,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 +3600,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 +3650,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-Dcq2JalY.js.map