@ashx-j/lunr-dev 0.2.13-dev.7.1 → 0.2.16-dev.9.1

package/dist/node-runtime/src-Y7JSCK64.js

@@ -0,0 +1,2407 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  MAX_FILE_SIZE,
+  MAX_INDEX_FILES,
+  SKIP_DIRS,
+  extractSymbols,
+  findDefinition,
+  getEnclosingDeclaration,
+  getNodeAtPosition,
+  getSignatureText,
+  getSyntaxErrors
+} from "./chunk-BHO7O6E5.js";
+import {
+  require_api2 as require_api
+} from "./chunk-SN6G4OU6.js";
+import {
+  getLanguageIdFromPath
+} from "./chunk-3X3KZKMI.js";
+import {
+  awaitWithAbort
+} from "./chunk-RRIZE6QQ.js";
+import {
+  DEFAULT_MAX_BYTES,
+  DEFAULT_MAX_LINES,
+  truncateHead
+} from "./chunk-53YJI7JU.js";
+import {
+  typebox_exports
+} from "./chunk-PL6JKXWI.js";
+import {
+  isEditToolResult,
+  isReadToolResult,
+  isWriteToolResult
+} from "./chunk-OR4L3IB2.js";
+import {
+  __toESM
+} from "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/index.js
+var import_vscode_languageserver_protocol3 = __toESM(require_api(), 1);
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/runtime.js
+var defaultLoaders = {
+  loadLspManager: () => import("./lsp-manager-3ASUSO4T.js"),
+  loadFileSync: () => import("./file-sync-HCOP2QVF.js"),
+  loadTreeSitter: () => import("./parser-manager-TQHWYDH7.js"),
+  loadWorkspaceIndex: () => import("./workspace-index-6DBXSTJ6.js")
+}, LspRuntimeHost = class {
+  generation = 0;
+  services = null;
+  initPromise = null;
+  bindOptions = null;
+  loaders;
+  constructor(loaders) {
+    this.loaders = { ...defaultLoaders, ...loaders };
+  }
+  getGeneration() {
+    return this.generation;
+  }
+  hasServices() {
+    return this.services !== null;
+  }
+  getServicesIfReady() {
+    return this.services;
+  }
+  getBindOptions() {
+    return this.bindOptions;
+  }
+  bindSession(options) {
+    this.generation++;
+    let previous = this.services;
+    this.services = null, this.initPromise = null, this.bindOptions = options, previous && this.shutdownServices(previous);
+  }
+  setPendingProvider(provider) {
+    this.bindOptions && (this.bindOptions = { ...this.bindOptions, pendingProvider: provider }), this.services && provider && this.services.manager.setWorkspaceProvider(provider);
+  }
+  async ensureServices(fallbackOptions) {
+    if (this.services)
+      return this.services;
+    if (this.initPromise)
+      return this.initPromise;
+    if (!this.bindOptions) {
+      if (!fallbackOptions)
+        throw new Error("LSP runtime is not bound to a session");
+      this.bindOptions = fallbackOptions;
+    }
+    let gen = this.generation, pending = this.loadServices(gen);
+    this.initPromise = pending;
+    try {
+      return await pending;
+    } catch (error) {
+      throw this.generation === gen && this.initPromise === pending && (this.initPromise = null), error;
+    }
+  }
+  async shutdown() {
+    this.generation++;
+    let previous = this.services;
+    this.services = null, this.initPromise = null, this.bindOptions = null, previous && await this.shutdownServices(previous);
+  }
+  async loadServices(gen) {
+    let [managerMod, fileSyncMod, treeSitterMod, workspaceIndexMod] = await Promise.all([
+      this.loaders.loadLspManager(),
+      this.loaders.loadFileSync(),
+      this.loaders.loadTreeSitter(),
+      this.loaders.loadWorkspaceIndex()
+    ]), options = this.bindOptions;
+    if (gen !== this.generation || !options)
+      throw new Error("LSP runtime initialization aborted: session replaced");
+    let manager = new managerMod.LspManager(options.cwd, void 0, options.callbacks, void 0, options.pendingProvider ?? void 0), treeSitter = new treeSitterMod.TreeSitterManager();
+    try {
+      let fileSync = new fileSyncMod.FileSync(manager);
+      fileSync.setSyntheticDotChecker(options.syntheticDotChecker);
+      let workspaceIndex = new workspaceIndexMod.WorkspaceIndex(options.cwd, treeSitter);
+      if (fileSync.setTreeSitter(treeSitter, workspaceIndex), options.configureManager?.(manager), gen !== this.generation)
+        throw new Error("LSP runtime initialization aborted: session replaced");
+      return this.services = { manager, fileSync, treeSitter, workspaceIndex }, this.services;
+    } catch (error) {
+      throw await manager.shutdownAll().catch(() => {
+      }), treeSitter.shutdown(), error;
+    }
+  }
+  async shutdownServices(services) {
+    await services.manager.shutdownAll().catch(() => {
+    }), services.treeSitter.shutdown();
+  }
+};
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/tools/diagnostics.js
+var import_vscode_languageserver_protocol = __toESM(require_api(), 1);
+import { Text } from "@ashx-j/lunr-tui";
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/resolve-provider.js
+function resolveProvider(filePath, manager, treeSitter) {
+  let languageId = manager.getLanguageId(filePath);
+  if (languageId) {
+    if (manager.getRunningClient(languageId))
+      return { type: "lsp" };
+    if (manager.isServerStarting(languageId))
+      return treeSitter?.hasGrammar(languageId) ? { type: "tree-sitter", languageId } : { type: "none", reason: `LSP server for ${languageId} is still starting up. Try again in a moment.` };
+  }
+  if (treeSitter) {
+    let tsLang = treeSitter.getLanguageId(filePath);
+    if (tsLang && treeSitter.hasGrammar(tsLang))
+      return { type: "tree-sitter", languageId: tsLang };
+  }
+  return {
+    type: "none",
+    reason: `No code intelligence available for ${(filePath.match(/\.[^.]+$/)?.[0] ?? "") || "this file type"}. No LSP server is running and no tree-sitter grammar is available.`
+  };
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/tools/diagnostics.js
+import { readFile } from "node:fs/promises";
+import { relative } from "node:path";
+import { fileURLToPath } from "node:url";
+function severityToString(severity) {
+  switch (severity) {
+    case import_vscode_languageserver_protocol.DiagnosticSeverity.Error:
+      return "error";
+    case import_vscode_languageserver_protocol.DiagnosticSeverity.Warning:
+      return "warning";
+    case import_vscode_languageserver_protocol.DiagnosticSeverity.Information:
+      return "info";
+    case import_vscode_languageserver_protocol.DiagnosticSeverity.Hint:
+      return "hint";
+    default:
+      return "unknown";
+  }
+}
+function formatDiagnostic(diag, filePath) {
+  let line = diag.range.start.line + 1, col = diag.range.start.character + 1, sev = severityToString(diag.severity), source = diag.source ? ` [${diag.source}]` : "", code = diag.code !== void 0 ? ` (${diag.code})` : "";
+  return `${filePath}:${line}:${col} ${sev}: ${diag.message}${code}${source}`;
+}
+var DiagnosticsParams = typebox_exports.Object({
+  path: typebox_exports.String({ description: 'File path to get diagnostics for. Pass "*" to get all workspace diagnostics from all running LSP servers.' })
+});
+function createDiagnosticsTool(manager, treeSitter) {
+  return {
+    name: "lsp_diagnostics",
+    label: "LSP Diagnostics",
+    description: 'Get compilation errors and warnings from the LSP server. Pass a file path to check a single file, or pass "*" to get all cached diagnostics across the workspace.',
+    promptSnippet: 'Get compiler errors, warnings, and hints for a source file via LSP. Pass path="*" to get all workspace diagnostics.',
+    promptGuidelines: [
+      "After making code changes with edit or write, use lsp_diagnostics to check for compilation errors before moving on.",
+      'To review all workspace diagnostics at once, call lsp_diagnostics with path="*" \u2014 this returns all cached diagnostics from running LSP servers without needing to check files individually.'
+    ],
+    parameters: DiagnosticsParams,
+    async execute(_toolCallId, params) {
+      let filePath = params.path.replace(/^@/, "");
+      if (filePath === "*" || filePath === "")
+        return executeWorkspaceDiagnostics(manager);
+      let client = await manager.getClientForFile(filePath).catch(() => null);
+      if (client) {
+        let uri = manager.getFileUri(filePath), diagnostics = client.getDiagnostics(uri);
+        if (diagnostics.length === 0)
+          return { content: [{ type: "text", text: "No diagnostics (clean)." }], details: { count: 0 } };
+        let sorted = [...diagnostics].sort((a, b) => (a.severity ?? 99) - (b.severity ?? 99)), relPath = relative(manager.resolvePath("."), manager.resolvePath(filePath)), output = sorted.map((d) => formatDiagnostic(d, relPath)).join(`
+`), errors = sorted.filter((d) => d.severity === import_vscode_languageserver_protocol.DiagnosticSeverity.Error).length, warnings = sorted.filter((d) => d.severity === import_vscode_languageserver_protocol.DiagnosticSeverity.Warning).length, other = sorted.length - errors - warnings, summary = [
+          errors > 0 ? `${errors} error(s)` : null,
+          warnings > 0 ? `${warnings} warning(s)` : null,
+          other > 0 ? `${other} other` : null
+        ].filter(Boolean).join(", "), truncation = truncateHead(output, { maxLines: 2e3, maxBytes: 51200 }), resultText = `${summary}
+
+${truncation.content}`;
+        return truncation.truncated && (resultText += `
+
+[Output truncated: showing ${truncation.outputLines} of ${truncation.totalLines} diagnostics]`), {
+          content: [{ type: "text", text: resultText }],
+          details: { count: sorted.length, errors, warnings }
+        };
+      }
+      if (treeSitter && resolveProvider(filePath, manager, treeSitter).type === "tree-sitter")
+        try {
+          let absPath = manager.resolvePath(filePath), content = await readFile(absPath, "utf-8"), tree = await treeSitter.parse(absPath, content);
+          if (tree) {
+            let syntaxErrors = getSyntaxErrors(tree);
+            if (syntaxErrors.length === 0)
+              return { content: [{ type: "text", text: "No syntax errors detected. [tree-sitter \u2014 syntax only, no type checking]" }], details: { count: 0 } };
+            let relPath = relative(manager.resolvePath("."), absPath), output = syntaxErrors.map((e) => `${relPath}:${e.line + 1}:${e.character + 1} error: ${e.message}`).join(`
+`), truncation = truncateHead(output, { maxLines: 2e3, maxBytes: 51200 }), resultText = `${syntaxErrors.length} syntax error(s) [tree-sitter \u2014 syntax only, no type checking]
+
+${truncation.content}`;
+            return truncation.truncated && (resultText += `
+
+[Output truncated: showing ${truncation.outputLines} of ${truncation.totalLines} diagnostics]`), {
+              content: [{ type: "text", text: resultText }],
+              details: { count: syntaxErrors.length, errors: syntaxErrors.length }
+            };
+          }
+        } catch {
+        }
+      return {
+        content: [{ type: "text", text: manager.getUnavailableReason(filePath) }],
+        details: { count: 0 }
+      };
+    },
+    renderCall(args, theme) {
+      let text = theme.fg("toolTitle", theme.bold("lsp_diagnostics "));
+      return args.path && args.path !== "*" ? text += theme.fg("accent", args.path) : text += theme.fg("dim", "(workspace)"), new Text(text, 0, 0);
+    },
+    renderResult(result, { expanded, isPartial }, theme) {
+      if (isPartial)
+        return new Text(theme.fg("warning", "Checking..."), 0, 0);
+      let details = result.details;
+      if (!details || details.count === 0)
+        return new Text(theme.fg("success", "\u2713 No diagnostics"), 0, 0);
+      let text = "";
+      if (details.errors && details.errors > 0 && (text += theme.fg("error", `${details.errors} error(s)`)), details.warnings && details.warnings > 0 && (text && (text += " "), text += theme.fg("warning", `${details.warnings} warning(s)`)), details.files && details.files > 0 && (text += theme.fg("dim", ` in ${details.files} file(s)`)), expanded) {
+        let content = result.content[0];
+        if (content?.type === "text") {
+          let lines = content.text.split(`
+`).slice(0, 30);
+          for (let line of lines)
+            text += `
+${theme.fg("dim", line)}`;
+        }
+      }
+      return new Text(text, 0, 0);
+    }
+  };
+}
+function executeWorkspaceDiagnostics(manager) {
+  let running = manager.getStatus().filter((s) => s.running);
+  if (running.length === 0)
+    return {
+      content: [{ type: "text", text: "No LSP servers are running. Use lsp_diagnostics with a file path to start a server and check that file." }],
+      details: { count: 0 }
+    };
+  let rootDir = manager.resolvePath("."), allDiagnostics = [];
+  for (let status of running) {
+    let client = manager.getRunningClient(status.languageId);
+    if (!client)
+      continue;
+    let diagMap = client.getAllDiagnostics();
+    for (let [uri, diagnostics] of diagMap) {
+      if (diagnostics.length === 0)
+        continue;
+      let absPath;
+      try {
+        absPath = fileURLToPath(uri);
+      } catch {
+        absPath = uri;
+      }
+      let relPath = relative(rootDir, absPath);
+      for (let diag of diagnostics)
+        allDiagnostics.push({ relPath, diag });
+    }
+  }
+  if (allDiagnostics.length === 0) {
+    let langs = running.map((s) => s.languageId).join(", ");
+    return {
+      content: [{ type: "text", text: `No diagnostics across ${running.length} running server(s) (${langs}).` }],
+      details: { count: 0 }
+    };
+  }
+  allDiagnostics.sort((a, b) => {
+    let sevDiff = (a.diag.severity ?? 99) - (b.diag.severity ?? 99);
+    return sevDiff !== 0 ? sevDiff : a.relPath.localeCompare(b.relPath);
+  });
+  let errors = allDiagnostics.filter((d) => d.diag.severity === import_vscode_languageserver_protocol.DiagnosticSeverity.Error).length, warnings = allDiagnostics.filter((d) => d.diag.severity === import_vscode_languageserver_protocol.DiagnosticSeverity.Warning).length, other = allDiagnostics.length - errors - warnings, fileCount = new Set(allDiagnostics.map((d) => d.relPath)).size, summary = [
+    `${allDiagnostics.length} diagnostic(s) in ${fileCount} file(s)`,
+    errors > 0 ? `${errors} error(s)` : null,
+    warnings > 0 ? `${warnings} warning(s)` : null,
+    other > 0 ? `${other} other` : null
+  ].filter(Boolean).join(", "), output = allDiagnostics.map((d) => formatDiagnostic(d.diag, d.relPath)).join(`
+`), truncation = truncateHead(output, { maxLines: 2e3, maxBytes: 51200 }), resultText = `${summary}
+
+${truncation.content}`;
+  return truncation.truncated && (resultText += `
+
+[Output truncated: showing ${truncation.outputLines} of ${truncation.totalLines} diagnostics]`), {
+    content: [{ type: "text", text: resultText }],
+    details: { count: allDiagnostics.length, errors, warnings, files: fileCount }
+  };
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/tools/hover.js
+import { Text as Text2 } from "@ashx-j/lunr-tui";
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/shared/resolve-position.js
+import { readFile as readFile2 } from "node:fs/promises";
+async function resolveSymbolPosition(filePath, query, manager, treeSitter) {
+  let client = await manager.getClientForFile(filePath).catch(() => null);
+  if (client) {
+    let uri = manager.getFileUri(filePath);
+    try {
+      let symbols = await client.sendRequest("textDocument/documentSymbol", { textDocument: { uri } });
+      if (symbols && symbols.length > 0) {
+        let match = findInDocumentSymbols(symbols, query);
+        if (match)
+          return match;
+      }
+    } catch {
+    }
+  }
+  if (treeSitter)
+    try {
+      let absPath = manager.resolvePath(filePath), content = await readFile2(absPath, "utf-8"), languageId = getLanguageIdFromPath(filePath);
+      if (languageId) {
+        let tree = await treeSitter.parse(absPath, content);
+        if (tree) {
+          let symbols = extractSymbols(tree, languageId), match = findInSymbolInfos(symbols, query);
+          if (match)
+            return match;
+        }
+      }
+    } catch {
+    }
+  return null;
+}
+async function getSymbolNames(filePath, manager, treeSitter) {
+  let client = await manager.getClientForFile(filePath).catch(() => null);
+  if (client) {
+    let uri = manager.getFileUri(filePath);
+    try {
+      let symbols = await client.sendRequest("textDocument/documentSymbol", { textDocument: { uri } });
+      if (symbols && symbols.length > 0)
+        return "selectionRange" in symbols[0] ? symbols.map((s) => s.name) : symbols.map((s) => s.name);
+    } catch {
+    }
+  }
+  if (treeSitter)
+    try {
+      let absPath = manager.resolvePath(filePath), content = await readFile2(absPath, "utf-8"), languageId = getLanguageIdFromPath(filePath);
+      if (languageId) {
+        let tree = await treeSitter.parse(absPath, content);
+        if (tree)
+          return extractSymbols(tree, languageId).map((s) => s.name);
+      }
+    } catch {
+    }
+  return [];
+}
+function findInDocumentSymbols(symbols, query) {
+  return symbols.length === 0 ? null : "selectionRange" in symbols[0] ? findInHierarchicalSymbols(symbols, query) : findInFlatSymbols(symbols, query);
+}
+function findInHierarchicalSymbols(symbols, query) {
+  let candidates = flattenDocumentSymbols(symbols);
+  return matchCandidates(candidates, query, "lsp");
+}
+function flattenDocumentSymbols(symbols, parent) {
+  let result = [];
+  for (let sym of symbols)
+    result.push({
+      name: sym.name,
+      line: sym.selectionRange.start.line + 1,
+      character: sym.selectionRange.start.character + 1,
+      parent
+    }), sym.children && sym.children.length > 0 && result.push(...flattenDocumentSymbols(sym.children, sym.name));
+  return result;
+}
+function findInFlatSymbols(symbols, query) {
+  let candidates = symbols.map((sym) => ({
+    name: sym.name,
+    line: sym.location.range.start.line + 1,
+    character: sym.location.range.start.character + 1,
+    parent: sym.containerName ?? void 0
+  }));
+  return matchCandidates(candidates, query, "lsp");
+}
+function findInSymbolInfos(symbols, query) {
+  let candidates = flattenSymbolInfos(symbols);
+  return matchCandidates(candidates, query, "tree-sitter");
+}
+function flattenSymbolInfos(symbols, parent) {
+  let result = [];
+  for (let sym of symbols)
+    result.push({
+      name: sym.name,
+      line: sym.line,
+      character: 1,
+      // tree-sitter symbols don't have column precision for the name
+      parent
+    }), sym.children && sym.children.length > 0 && result.push(...flattenSymbolInfos(sym.children, sym.name));
+  return result;
+}
+function matchCandidates(candidates, query, source) {
+  let dotIndex = query.lastIndexOf("."), parentFilter, symbolQuery;
+  if (dotIndex > 0 ? (parentFilter = query.slice(0, dotIndex), symbolQuery = query.slice(dotIndex + 1)) : symbolQuery = query, parentFilter) {
+    let qualified = candidates.filter((c) => c.parent?.toLowerCase() === parentFilter.toLowerCase()), match = matchByPriority(qualified, symbolQuery, source);
+    if (match)
+      return match;
+  }
+  return matchByPriority(candidates, symbolQuery, source);
+}
+function matchByPriority(candidates, query, source) {
+  let queryLower = query.toLowerCase(), exact = candidates.find((c) => c.name === query);
+  if (exact)
+    return { line: exact.line, character: exact.character, symbolName: exact.name, source };
+  let caseInsensitive = candidates.find((c) => c.name.toLowerCase() === queryLower);
+  if (caseInsensitive)
+    return { line: caseInsensitive.line, character: caseInsensitive.character, symbolName: caseInsensitive.name, source };
+  let substring = candidates.find((c) => c.name.toLowerCase().includes(queryLower));
+  return substring ? { line: substring.line, character: substring.character, symbolName: substring.name, source } : null;
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/tools/hover.js
+import { readFile as readFile3 } from "node:fs/promises";
+function formatHoverContent(hover) {
+  let contents = hover.contents;
+  return typeof contents == "string" ? contents : "kind" in contents && "value" in contents ? contents.value : "language" in contents && "value" in contents ? `\`\`\`${contents.language}
+${contents.value}
+\`\`\`` : Array.isArray(contents) ? contents.map((c) => typeof c == "string" ? c : "language" in c && "value" in c ? `\`\`\`${c.language}
+${c.value}
+\`\`\`` : String(c)).join(`
+
+`) : String(contents);
+}
+var HoverParams = typebox_exports.Object({
+  path: typebox_exports.String({ description: "File path" }),
+  line: typebox_exports.Optional(typebox_exports.Number({ description: "Line number (1-indexed). Required unless query is provided." })),
+  character: typebox_exports.Optional(typebox_exports.Number({ description: "Column number (1-indexed). Required unless query is provided." })),
+  query: typebox_exports.Optional(typebox_exports.String({ description: "Symbol name to find in the file. Alternative to line/character \u2014 resolves the symbol's position automatically." }))
+});
+function createHoverTool(manager, treeSitter) {
+  return {
+    name: "lsp_hover",
+    label: "LSP Hover",
+    description: "Get type information and documentation for a symbol at a specific position in a file. Line and character are 1-indexed.",
+    promptSnippet: "Get type info and docs for a symbol at a file position via LSP",
+    parameters: HoverParams,
+    async execute(_toolCallId, params) {
+      let filePath = params.path.replace(/^@/, ""), line = params.line, character = params.character, resolvedFrom;
+      if ((line === void 0 || character === void 0) && params.query) {
+        let resolved = await resolveSymbolPosition(filePath, params.query, manager, treeSitter);
+        if (resolved)
+          line = resolved.line, character = resolved.character, resolvedFrom = `Resolved "${params.query}" \u2192 ${resolved.symbolName} at ${line}:${character} [${resolved.source}]`;
+        else {
+          let names = await getSymbolNames(filePath, manager, treeSitter), hint = names.length > 0 ? `
+Available symbols: ${names.slice(0, 20).join(", ")}` : "";
+          return { content: [{ type: "text", text: `Could not find symbol "${params.query}" in ${filePath}${hint}` }], details: { hasResult: !1 } };
+        }
+      }
+      if (line === void 0 || character === void 0)
+        return { content: [{ type: "text", text: "Either line/character or query is required." }], details: { hasResult: !1 } };
+      let client = await manager.getClientForFile(filePath).catch(() => null);
+      if (client) {
+        let uri = manager.getFileUri(filePath), position = { line: line - 1, character: character - 1 };
+        try {
+          let hover = await client.sendRequest("textDocument/hover", {
+            textDocument: { uri },
+            position
+          });
+          if (!hover)
+            return { content: [{ type: "text", text: resolvedFrom ? `${resolvedFrom}
+
+No hover information available at this position.` : "No hover information available at this position." }], details: { hasResult: !1 } };
+          let hoverText = formatHoverContent(hover);
+          return { content: [{ type: "text", text: resolvedFrom ? `${resolvedFrom}
+
+${hoverText}` : hoverText }], details: { hasResult: !0 } };
+        } catch (err) {
+          return { content: [{ type: "text", text: `LSP hover request failed: ${err.message}` }], details: { hasResult: !1 } };
+        }
+      }
+      if (treeSitter && resolveProvider(filePath, manager, treeSitter).type === "tree-sitter")
+        try {
+          let absPath = manager.resolvePath(filePath), content = await readFile3(absPath, "utf-8"), tree = await treeSitter.parse(absPath, content);
+          if (tree) {
+            let decl = getEnclosingDeclaration(tree, line - 1, character - 1);
+            if (decl) {
+              let sig = getSignatureText(decl), text2 = `${decl.type.replace(/_/g, " ")} [tree-sitter]
+
+\`\`\`
+${sig}
+\`\`\``;
+              return resolvedFrom && (text2 = `${resolvedFrom}
+
+${text2}`), { content: [{ type: "text", text: text2 }], details: { hasResult: !0 } };
+            }
+            return { content: [{ type: "text", text: resolvedFrom ? `${resolvedFrom}
+
+No hover information available at this position. [tree-sitter]` : "No hover information available at this position. [tree-sitter]" }], details: { hasResult: !1 } };
+          }
+        } catch {
+        }
+      return { content: [{ type: "text", text: manager.getUnavailableReason(filePath) }], details: { hasResult: !1 } };
+    },
+    renderCall(args, theme) {
+      let text = theme.fg("toolTitle", theme.bold("lsp_hover "));
+      return args.query && !args.line ? (text += theme.fg("accent", `${args.path}`), text += theme.fg("muted", ` query="${args.query}"`)) : text += theme.fg("accent", `${args.path}:${args.line}:${args.character}`), new Text2(text, 0, 0);
+    },
+    renderResult(result, { isPartial }, theme) {
+      if (isPartial)
+        return new Text2(theme.fg("warning", "Looking up..."), 0, 0);
+      if (!result.details?.hasResult)
+        return new Text2(theme.fg("dim", "No info"), 0, 0);
+      let content = result.content[0];
+      if (content?.type === "text") {
+        let lines = content.text.split(`
+`).slice(0, 5);
+        return new Text2(lines.map((l) => theme.fg("dim", l)).join(`
+`), 0, 0);
+      }
+      return new Text2(theme.fg("dim", "No info"), 0, 0);
+    }
+  };
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/tools/definition.js
+import { Text as Text3 } from "@ashx-j/lunr-tui";
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/shared/format.js
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { relative as relative2 } from "node:path";
+function formatLocation(loc, rootDir) {
+  try {
+    let absPath = fileURLToPath2(loc.uri);
+    return `${relative2(rootDir, absPath)}:${loc.range.start.line + 1}:${loc.range.start.character + 1}`;
+  } catch {
+    return `${loc.uri}:${loc.range.start.line + 1}:${loc.range.start.character + 1}`;
+  }
+}
+function formatLocationLink(link, rootDir) {
+  try {
+    let absPath = fileURLToPath2(link.targetUri);
+    return `${relative2(rootDir, absPath)}:${link.targetSelectionRange.start.line + 1}:${link.targetSelectionRange.start.character + 1}`;
+  } catch {
+    return `${link.targetUri}:${link.targetSelectionRange.start.line + 1}:${link.targetSelectionRange.start.character + 1}`;
+  }
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/tools/definition.js
+import { readFile as readFile4 } from "node:fs/promises";
+import { relative as relative3 } from "node:path";
+var DefinitionParams = typebox_exports.Object({
+  path: typebox_exports.String({ description: "File path" }),
+  line: typebox_exports.Optional(typebox_exports.Number({ description: "Line number (1-indexed). Required unless query is provided." })),
+  character: typebox_exports.Optional(typebox_exports.Number({ description: "Column number (1-indexed). Required unless query is provided." })),
+  query: typebox_exports.Optional(typebox_exports.String({ description: "Symbol name to find in the file. Alternative to line/character \u2014 resolves the symbol's position automatically." }))
+});
+function createDefinitionTool(manager, treeSitter, workspaceIndex) {
+  return {
+    name: "lsp_definition",
+    label: "LSP Definition",
+    description: "Go to the definition of a symbol at a specific position. Returns the file path and location of the definition. Line and character are 1-indexed.",
+    promptSnippet: "Jump to the definition of a symbol at a file position via LSP",
+    parameters: DefinitionParams,
+    async execute(_toolCallId, params) {
+      let filePath = params.path.replace(/^@/, ""), line = params.line, character = params.character, resolvedFrom;
+      if ((line === void 0 || character === void 0) && params.query) {
+        let resolved = await resolveSymbolPosition(filePath, params.query, manager, treeSitter);
+        if (resolved)
+          line = resolved.line, character = resolved.character, resolvedFrom = `Resolved "${params.query}" \u2192 ${resolved.symbolName} at ${line}:${character} [${resolved.source}]`;
+        else {
+          let names = await getSymbolNames(filePath, manager, treeSitter), hint = names.length > 0 ? `
+Available symbols: ${names.slice(0, 20).join(", ")}` : "";
+          return { content: [{ type: "text", text: `Could not find symbol "${params.query}" in ${filePath}${hint}` }], details: { count: 0 } };
+        }
+      }
+      if (line === void 0 || character === void 0)
+        return { content: [{ type: "text", text: "Either line/character or query is required." }], details: { count: 0 } };
+      let client = await manager.getClientForFile(filePath).catch(() => null);
+      if (client) {
+        let uri = manager.getFileUri(filePath), position = { line: line - 1, character: character - 1 };
+        try {
+          let result = await client.sendRequest("textDocument/definition", {
+            textDocument: { uri },
+            position
+          });
+          if (!result)
+            return { content: [{ type: "text", text: resolvedFrom ? `${resolvedFrom}
+
+No definition found.` : "No definition found." }], details: { count: 0 } };
+          let rootDir = manager.resolvePath("."), locations;
+          if (Array.isArray(result)) {
+            if (result.length === 0)
+              return { content: [{ type: "text", text: resolvedFrom ? `${resolvedFrom}
+
+No definition found.` : "No definition found." }], details: { count: 0 } };
+            "targetUri" in result[0] ? locations = result.map((l) => formatLocationLink(l, rootDir)) : locations = result.map((l) => formatLocation(l, rootDir));
+          } else
+            locations = [formatLocation(result, rootDir)];
+          let text = locations.length === 1 ? `Definition: ${locations[0]}` : `Definitions:
+${locations.map((l) => `  ${l}`).join(`
+`)}`;
+          return resolvedFrom && (text = `${resolvedFrom}
+
+${text}`), { content: [{ type: "text", text }], details: { count: locations.length } };
+        } catch (err) {
+          return { content: [{ type: "text", text: `LSP definition request failed: ${err.message}` }], details: { count: 0 } };
+        }
+      }
+      if (treeSitter) {
+        let provider = resolveProvider(filePath, manager, treeSitter);
+        if (provider.type === "tree-sitter")
+          try {
+            let absPath = manager.resolvePath(filePath), content = await readFile4(absPath, "utf-8"), tree = await treeSitter.parse(absPath, content);
+            if (tree) {
+              let node = getNodeAtPosition(tree, line - 1, character - 1);
+              if (node) {
+                let symbolName = node.text, rootDir = manager.resolvePath("."), relPath = relative3(rootDir, absPath), localDefs = findDefinition(tree, symbolName, provider.languageId);
+                if (localDefs.length > 0) {
+                  let locs = localDefs.map((d) => `${relPath}:${d.line}:1`), text2 = locs.length === 1 ? `Definition [tree-sitter]: ${locs[0]}` : `Definitions [tree-sitter]:
+${locs.map((l) => `  ${l}`).join(`
+`)}`;
+                  return resolvedFrom && (text2 = `${resolvedFrom}
+
+${text2}`), { content: [{ type: "text", text: text2 }], details: { count: locs.length } };
+                }
+                if (workspaceIndex) {
+                  await workspaceIndex.build();
+                  let exact = workspaceIndex.search(symbolName).filter((e) => e.name === symbolName);
+                  if (exact.length > 0) {
+                    let rootDir2 = manager.resolvePath("."), locs = exact.slice(0, 10).map((e) => `${relative3(rootDir2, e.file)}:${e.line}:1`), text2 = locs.length === 1 ? `Definition [tree-sitter]: ${locs[0]}` : `Definitions [tree-sitter]:
+${locs.map((l) => `  ${l}`).join(`
+`)}`;
+                    return resolvedFrom && (text2 = `${resolvedFrom}
+
+${text2}`), { content: [{ type: "text", text: text2 }], details: { count: locs.length } };
+                  }
+                }
+                let msg = `No definition found for "${symbolName}" [tree-sitter]`;
+                return { content: [{ type: "text", text: resolvedFrom ? `${resolvedFrom}
+
+${msg}` : msg }], details: { count: 0 } };
+              }
+            }
+          } catch {
+          }
+      }
+      return { content: [{ type: "text", text: manager.getUnavailableReason(filePath) }], details: { count: 0 } };
+    },
+    renderCall(args, theme) {
+      let text = theme.fg("toolTitle", theme.bold("lsp_definition "));
+      return args.query && !args.line ? (text += theme.fg("accent", `${args.path}`), text += theme.fg("muted", ` query="${args.query}"`)) : text += theme.fg("accent", `${args.path}:${args.line}:${args.character}`), new Text3(text, 0, 0);
+    },
+    renderResult(result, { isPartial }, theme) {
+      if (isPartial)
+        return new Text3(theme.fg("warning", "Resolving..."), 0, 0);
+      let content = result.content[0];
+      return content?.type === "text" ? new Text3(theme.fg("dim", content.text), 0, 0) : new Text3(theme.fg("dim", "No result"), 0, 0);
+    }
+  };
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/tools/references.js
+import { Text as Text4 } from "@ashx-j/lunr-tui";
+var ReferencesParams = typebox_exports.Object({
+  path: typebox_exports.String({ description: "File path" }),
+  line: typebox_exports.Optional(typebox_exports.Number({ description: "Line number (1-indexed). Required unless query is provided." })),
+  character: typebox_exports.Optional(typebox_exports.Number({ description: "Column number (1-indexed). Required unless query is provided." })),
+  query: typebox_exports.Optional(typebox_exports.String({ description: "Symbol name to find in the file. Alternative to line/character \u2014 resolves the symbol's position automatically." })),
+  includeDeclaration: typebox_exports.Optional(typebox_exports.Boolean({ description: "Include the declaration in results (default: true)" }))
+});
+function createReferencesTool(manager, treeSitter) {
+  return {
+    name: "lsp_references",
+    label: "LSP References",
+    description: "Find all references to a symbol at a specific position. Returns a list of file locations. Line and character are 1-indexed.",
+    promptSnippet: "Find all references to a symbol at a file position via LSP",
+    parameters: ReferencesParams,
+    async execute(_toolCallId, params) {
+      let filePath = params.path.replace(/^@/, ""), line = params.line, character = params.character, resolvedFrom;
+      if ((line === void 0 || character === void 0) && params.query) {
+        let resolved = await resolveSymbolPosition(filePath, params.query, manager, treeSitter);
+        if (resolved)
+          line = resolved.line, character = resolved.character, resolvedFrom = `Resolved "${params.query}" \u2192 ${resolved.symbolName} at ${line}:${character} [${resolved.source}]`;
+        else {
+          let names = await getSymbolNames(filePath, manager, treeSitter), hint = names.length > 0 ? `
+Available symbols: ${names.slice(0, 20).join(", ")}` : "";
+          return { content: [{ type: "text", text: `Could not find symbol "${params.query}" in ${filePath}${hint}` }], details: { count: 0 } };
+        }
+      }
+      if (line === void 0 || character === void 0)
+        return { content: [{ type: "text", text: "Either line/character or query is required." }], details: { count: 0 } };
+      let client = await manager.getClientForFile(filePath).catch(() => null);
+      if (!client)
+        return { content: [{ type: "text", text: manager.getUnavailableReason(filePath) }], details: { count: 0 } };
+      let uri = manager.getFileUri(filePath), position = { line: line - 1, character: character - 1 };
+      try {
+        let locations = await client.sendRequest("textDocument/references", {
+          textDocument: { uri },
+          position,
+          context: { includeDeclaration: params.includeDeclaration ?? !0 }
+        });
+        if (!locations || locations.length === 0)
+          return { content: [{ type: "text", text: resolvedFrom ? `${resolvedFrom}
+
+No references found.` : "No references found." }], details: { count: 0 } };
+        let rootDir = manager.resolvePath("."), output = locations.map((l) => formatLocation(l, rootDir)).join(`
+`), truncation = truncateHead(output, { maxLines: 2e3, maxBytes: 51200 }), resultText = `${locations.length} reference(s) found:
+
+${truncation.content}`;
+        return truncation.truncated && (resultText += `
+
+[Output truncated: showing ${truncation.outputLines} of ${truncation.totalLines} references]`), resolvedFrom && (resultText = `${resolvedFrom}
+
+${resultText}`), { content: [{ type: "text", text: resultText }], details: { count: locations.length } };
+      } catch (err) {
+        return { content: [{ type: "text", text: `LSP references request failed: ${err.message}` }], details: { count: 0 } };
+      }
+    },
+    renderCall(args, theme) {
+      let text = theme.fg("toolTitle", theme.bold("lsp_references "));
+      return args.query && !args.line ? (text += theme.fg("accent", `${args.path}`), text += theme.fg("muted", ` query="${args.query}"`)) : text += theme.fg("accent", `${args.path}:${args.line}:${args.character}`), new Text4(text, 0, 0);
+    },
+    renderResult(result, { isPartial }, theme) {
+      if (isPartial)
+        return new Text4(theme.fg("warning", "Searching..."), 0, 0);
+      let details = result.details;
+      return !details || details.count === 0 ? new Text4(theme.fg("dim", "No references found"), 0, 0) : new Text4(theme.fg("success", `${details.count} reference(s)`), 0, 0);
+    }
+  };
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/tools/symbols.js
+var import_vscode_languageserver_protocol2 = __toESM(require_api(), 1);
+import { Text as Text5 } from "@ashx-j/lunr-tui";
+import { readFile as readFile5 } from "node:fs/promises";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { relative as relative4 } from "node:path";
+var SYMBOL_KIND_NAMES = {
+  [import_vscode_languageserver_protocol2.SymbolKind.File]: "file",
+  [import_vscode_languageserver_protocol2.SymbolKind.Module]: "module",
+  [import_vscode_languageserver_protocol2.SymbolKind.Namespace]: "namespace",
+  [import_vscode_languageserver_protocol2.SymbolKind.Package]: "package",
+  [import_vscode_languageserver_protocol2.SymbolKind.Class]: "class",
+  [import_vscode_languageserver_protocol2.SymbolKind.Method]: "method",
+  [import_vscode_languageserver_protocol2.SymbolKind.Property]: "property",
+  [import_vscode_languageserver_protocol2.SymbolKind.Field]: "field",
+  [import_vscode_languageserver_protocol2.SymbolKind.Constructor]: "constructor",
+  [import_vscode_languageserver_protocol2.SymbolKind.Enum]: "enum",
+  [import_vscode_languageserver_protocol2.SymbolKind.Interface]: "interface",
+  [import_vscode_languageserver_protocol2.SymbolKind.Function]: "function",
+  [import_vscode_languageserver_protocol2.SymbolKind.Variable]: "variable",
+  [import_vscode_languageserver_protocol2.SymbolKind.Constant]: "constant",
+  [import_vscode_languageserver_protocol2.SymbolKind.String]: "string",
+  [import_vscode_languageserver_protocol2.SymbolKind.Number]: "number",
+  [import_vscode_languageserver_protocol2.SymbolKind.Boolean]: "boolean",
+  [import_vscode_languageserver_protocol2.SymbolKind.Array]: "array",
+  [import_vscode_languageserver_protocol2.SymbolKind.Object]: "object",
+  [import_vscode_languageserver_protocol2.SymbolKind.Key]: "key",
+  [import_vscode_languageserver_protocol2.SymbolKind.Null]: "null",
+  [import_vscode_languageserver_protocol2.SymbolKind.EnumMember]: "enum-member",
+  [import_vscode_languageserver_protocol2.SymbolKind.Struct]: "struct",
+  [import_vscode_languageserver_protocol2.SymbolKind.Event]: "event",
+  [import_vscode_languageserver_protocol2.SymbolKind.Operator]: "operator",
+  [import_vscode_languageserver_protocol2.SymbolKind.TypeParameter]: "type-param"
+};
+function kindName(kind) {
+  return SYMBOL_KIND_NAMES[kind] ?? `kind(${kind})`;
+}
+function formatDocumentSymbol(sym, indent = 0) {
+  let prefix = "  ".repeat(indent), line = sym.range.start.line + 1, result = [`${prefix}${kindName(sym.kind)} ${sym.name} (line ${line})`];
+  if (sym.children)
+    for (let child of sym.children)
+      result.push(...formatDocumentSymbol(child, indent + 1));
+  return result;
+}
+function formatSymbolInfo(sym, rootDir) {
+  let location = "";
+  if ("location" in sym && sym.location)
+    try {
+      let absPath = fileURLToPath3(sym.location.uri), relPath = relative4(rootDir, absPath), loc = sym.location, line = loc.range ? loc.range.start.line + 1 : "?";
+      location = ` ${relPath}:${line}`;
+    } catch {
+      location = ` ${sym.location.uri}`;
+    }
+  return `${kindName(sym.kind)} ${sym.name}${location}`;
+}
+var SymbolsParams = typebox_exports.Object({
+  path: typebox_exports.Optional(typebox_exports.String({ description: "File path for document symbols" })),
+  query: typebox_exports.Optional(typebox_exports.String({ description: "Search query for workspace symbols (searches across all files)" }))
+});
+function formatTreeSitterSymbol(sym, indent = 0) {
+  let prefix = "  ".repeat(indent), kindStr = SYMBOL_KIND_NAMES[sym.kind] ?? `kind(${sym.kind})`, result = [`${prefix}${kindStr} ${sym.name} (line ${sym.line})`];
+  if (sym.children)
+    for (let child of sym.children)
+      result.push(...formatTreeSitterSymbol(child, indent + 1));
+  return result;
+}
+function createSymbolsTool(manager, treeSitter, workspaceIndex) {
+  return {
+    name: "lsp_symbols",
+    label: "LSP Symbols",
+    description: "List symbols in a file (document symbols) or search for symbols across the workspace. Provide 'path' for file symbols or 'query' for workspace search.",
+    promptSnippet: "List symbols in a file or search workspace symbols via LSP",
+    parameters: SymbolsParams,
+    async execute(_toolCallId, params) {
+      let filePath = params.path?.replace(/^@/, ""), query = params.query;
+      if (!filePath && query === void 0)
+        return {
+          content: [{ type: "text", text: "Please provide either 'path' for file symbols or 'query' for workspace symbol search." }],
+          details: { count: 0 }
+        };
+      if (filePath) {
+        let client = await manager.getClientForFile(filePath).catch(() => null);
+        if (client) {
+          let uri = manager.getFileUri(filePath);
+          try {
+            let result = await client.sendRequest("textDocument/documentSymbol", { textDocument: { uri } });
+            if (!result || result.length === 0)
+              return { content: [{ type: "text", text: "No symbols found in this file." }], details: { count: 0 } };
+            let lines;
+            if ("range" in result[0])
+              lines = result.flatMap((s) => formatDocumentSymbol(s));
+            else {
+              let rootDir = manager.resolvePath(".");
+              lines = result.map((s) => formatSymbolInfo(s, rootDir));
+            }
+            let output = lines.join(`
+`), truncation = truncateHead(output, { maxLines: 2e3, maxBytes: 51200 }), text = `${lines.length} symbol(s):
+
+${truncation.content}`;
+            return truncation.truncated && (text += `
+
+[Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines]`), { content: [{ type: "text", text }], details: { count: lines.length } };
+          } catch (err) {
+            return { content: [{ type: "text", text: `LSP document symbols request failed: ${err.message}` }], details: { count: 0 } };
+          }
+        }
+        if (treeSitter) {
+          let provider = resolveProvider(filePath, manager, treeSitter);
+          if (provider.type === "tree-sitter")
+            try {
+              let absPath = manager.resolvePath(filePath), content = await readFile5(absPath, "utf-8"), tree = await treeSitter.parse(absPath, content);
+              if (tree) {
+                let symbols = extractSymbols(tree, provider.languageId);
+                if (symbols.length === 0)
+                  return { content: [{ type: "text", text: "No symbols found in this file." }], details: { count: 0 } };
+                let lines = symbols.flatMap((s) => formatTreeSitterSymbol(s)), output = lines.join(`
+`), truncation = truncateHead(output, { maxLines: 2e3, maxBytes: 51200 }), text = `${lines.length} symbol(s) [tree-sitter]:
+
+${truncation.content}`;
+                return truncation.truncated && (text += `
+
+[Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines]`), { content: [{ type: "text", text }], details: { count: lines.length } };
+              }
+            } catch {
+            }
+        }
+        return { content: [{ type: "text", text: manager.getUnavailableReason(filePath) }], details: { count: 0 } };
+      }
+      let runningLang = manager.getStatus().find((s) => s.running)?.languageId;
+      if (runningLang) {
+        let client = await manager.getClientForLanguage(runningLang).catch(() => null);
+        if (client)
+          try {
+            let result = await client.sendRequest("workspace/symbol", { query: query ?? "" });
+            if (!result || result.length === 0)
+              return { content: [{ type: "text", text: `No workspace symbols found for query: "${query}"` }], details: { count: 0 } };
+            let rootDir = manager.resolvePath("."), output = result.map((s) => formatSymbolInfo(s, rootDir)).join(`
+`), truncation = truncateHead(output, { maxLines: 2e3, maxBytes: 51200 }), text = `${result.length} symbol(s) found:
+
+${truncation.content}`;
+            return truncation.truncated && (text += `
+
+[Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines]`), { content: [{ type: "text", text }], details: { count: result.length } };
+          } catch (err) {
+            return { content: [{ type: "text", text: `LSP workspace symbols request failed: ${err.message}` }], details: { count: 0 } };
+          }
+      }
+      if (workspaceIndex && query)
+        try {
+          await workspaceIndex.build();
+          let results = workspaceIndex.search(query);
+          if (results.length === 0)
+            return { content: [{ type: "text", text: `No workspace symbols found for query: "${query}" [tree-sitter]` }], details: { count: 0 } };
+          let rootDir = manager.resolvePath("."), output = results.map((e) => {
+            let relPath = relative4(rootDir, e.file);
+            return `${kindName(e.kind)} ${e.name} ${relPath}:${e.line}`;
+          }).join(`
+`), truncation = truncateHead(output, { maxLines: 2e3, maxBytes: 51200 }), text = `${results.length} symbol(s) found [tree-sitter]:
+
+${truncation.content}`;
+          return truncation.truncated && (text += `
+
+[Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines]`), { content: [{ type: "text", text }], details: { count: results.length } };
+        } catch {
+        }
+      return {
+        content: [{ type: "text", text: "No LSP servers are currently running and no workspace index is available. Use lsp_diagnostics or lsp_hover on a file first to start a server." }],
+        details: { count: 0 }
+      };
+    },
+    renderCall(args, theme) {
+      let text = theme.fg("toolTitle", theme.bold("lsp_symbols "));
+      return args.path && (text += theme.fg("accent", args.path)), args.query && (text += theme.fg("accent", `query="${args.query}"`)), new Text5(text, 0, 0);
+    },
+    renderResult(result, { isPartial }, theme) {
+      if (isPartial)
+        return new Text5(theme.fg("warning", "Loading symbols..."), 0, 0);
+      let details = result.details;
+      return !details || details.count === 0 ? new Text5(theme.fg("dim", "No symbols"), 0, 0) : new Text5(theme.fg("success", `${details.count} symbol(s)`), 0, 0);
+    }
+  };
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/tools/rename.js
+import { Text as Text6 } from "@ashx-j/lunr-tui";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
+import { relative as relative5 } from "node:path";
+function formatWorkspaceEdit(edit, rootDir) {
+  let lines = [], totalEdits = 0, fileCount = 0;
+  if (edit.documentChanges) {
+    for (let change of edit.documentChanges)
+      if ("textDocument" in change && "edits" in change) {
+        fileCount++;
+        let relPath;
+        try {
+          relPath = relative5(rootDir, fileURLToPath4(change.textDocument.uri));
+        } catch {
+          relPath = change.textDocument.uri;
+        }
+        lines.push(`${relPath}:`);
+        for (let textEdit of change.edits) {
+          let line = textEdit.range.start.line + 1, col = textEdit.range.start.character + 1;
+          lines.push(`  ${line}:${col} \u2192 "${textEdit.newText}"`), totalEdits++;
+        }
+      }
+  }
+  let changes = edit.changes ?? {};
+  for (let [uri, edits] of Object.entries(changes)) {
+    fileCount++;
+    let relPath;
+    try {
+      relPath = relative5(rootDir, fileURLToPath4(uri));
+    } catch {
+      relPath = uri;
+    }
+    lines.push(`${relPath}:`);
+    for (let textEdit of edits) {
+      let line = textEdit.range.start.line + 1, col = textEdit.range.start.character + 1;
+      lines.push(`  ${line}:${col} \u2192 "${textEdit.newText}"`), totalEdits++;
+    }
+  }
+  return { summary: lines.join(`
+`), fileCount, editCount: totalEdits };
+}
+var RenameParams = typebox_exports.Object({
+  path: typebox_exports.String({ description: "File path" }),
+  line: typebox_exports.Optional(typebox_exports.Number({ description: "Line number (1-indexed). Required unless query is provided." })),
+  character: typebox_exports.Optional(typebox_exports.Number({ description: "Column number (1-indexed). Required unless query is provided." })),
+  query: typebox_exports.Optional(typebox_exports.String({ description: "Symbol name to find in the file. Alternative to line/character \u2014 resolves the symbol's position automatically." })),
+  newName: typebox_exports.String({ description: "New name for the symbol" })
+});
+function createRenameTool(manager, treeSitter) {
+  return {
+    name: "lsp_rename",
+    label: "LSP Rename",
+    description: "Preview a rename refactoring for a symbol at a position. Returns the list of changes that would be made across all files. Does NOT apply the changes \u2014 use edit/write tools to apply them. Line and character are 1-indexed.",
+    promptSnippet: "Preview rename refactoring for a symbol (returns planned edits, does not apply them)",
+    parameters: RenameParams,
+    async execute(_toolCallId, params) {
+      let filePath = params.path.replace(/^@/, ""), line = params.line, character = params.character, resolvedFrom;
+      if ((line === void 0 || character === void 0) && params.query) {
+        let resolved = await resolveSymbolPosition(filePath, params.query, manager, treeSitter);
+        if (resolved)
+          line = resolved.line, character = resolved.character, resolvedFrom = `Resolved "${params.query}" \u2192 ${resolved.symbolName} at ${line}:${character} [${resolved.source}]`;
+        else {
+          let names = await getSymbolNames(filePath, manager, treeSitter), hint = names.length > 0 ? `
+Available symbols: ${names.slice(0, 20).join(", ")}` : "";
+          return { content: [{ type: "text", text: `Could not find symbol "${params.query}" in ${filePath}${hint}` }], details: { fileCount: 0, editCount: 0 } };
+        }
+      }
+      if (line === void 0 || character === void 0)
+        return { content: [{ type: "text", text: "Either line/character or query is required." }], details: { fileCount: 0, editCount: 0 } };
+      let client = await manager.getClientForFile(filePath).catch(() => null);
+      if (!client)
+        return { content: [{ type: "text", text: manager.getUnavailableReason(filePath) }], details: { fileCount: 0, editCount: 0 } };
+      let uri = manager.getFileUri(filePath), position = { line: line - 1, character: character - 1 };
+      try {
+        let result = await client.sendRequest("textDocument/rename", {
+          textDocument: { uri },
+          position,
+          newName: params.newName
+        });
+        if (!result)
+          return { content: [{ type: "text", text: resolvedFrom ? `${resolvedFrom}
+
+Rename not possible at this position.` : "Rename not possible at this position." }], details: { fileCount: 0, editCount: 0 } };
+        let rootDir = manager.resolvePath("."), { summary, fileCount, editCount } = formatWorkspaceEdit(result, rootDir);
+        if (editCount === 0)
+          return { content: [{ type: "text", text: resolvedFrom ? `${resolvedFrom}
+
+No edits needed for this rename.` : "No edits needed for this rename." }], details: { fileCount: 0, editCount: 0 } };
+        let truncation = truncateHead(summary, { maxLines: 2e3, maxBytes: 51200 }), text = "";
+        return resolvedFrom && (text += `${resolvedFrom}
+
+`), text += `Rename "${params.newName}": ${editCount} edit(s) across ${fileCount} file(s)
+
+`, text += `NOTE: These changes are NOT applied. Use edit/write tools to make the changes.
+
+`, text += truncation.content, truncation.truncated && (text += `
+
+[Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines]`), { content: [{ type: "text", text }], details: { fileCount, editCount } };
+      } catch (err) {
+        return { content: [{ type: "text", text: `LSP rename request failed: ${err.message}` }], details: { fileCount: 0, editCount: 0 } };
+      }
+    },
+    renderCall(args, theme) {
+      let text = theme.fg("toolTitle", theme.bold("lsp_rename "));
+      return args.query && !args.line ? (text += theme.fg("accent", `${args.path}`), text += theme.fg("muted", ` query="${args.query}" \u2192 ${args.newName}`)) : (text += theme.fg("accent", `${args.path}:${args.line}:${args.character}`), text += theme.fg("muted", ` \u2192 ${args.newName}`)), new Text6(text, 0, 0);
+    },
+    renderResult(result, { isPartial }, theme) {
+      if (isPartial)
+        return new Text6(theme.fg("warning", "Computing..."), 0, 0);
+      let details = result.details;
+      return !details || details.editCount === 0 ? new Text6(theme.fg("dim", "No edits"), 0, 0) : new Text6(theme.fg("success", `${details.editCount} edit(s) in ${details.fileCount} file(s) (preview only)`), 0, 0);
+    }
+  };
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/tools/code-overview.js
+import { Text as Text7 } from "@ashx-j/lunr-tui";
+import { resolve, relative as relative6 } from "node:path";
+import { readdir, readFile as readFile6 } from "node:fs/promises";
+import { existsSync } from "node:fs";
+var MANIFESTS = [
+  "package.json",
+  "Cargo.toml",
+  "go.mod",
+  "go.sum",
+  "pom.xml",
+  "build.gradle",
+  "build.gradle.kts",
+  "requirements.txt",
+  "pyproject.toml",
+  "setup.py",
+  "setup.cfg",
+  "Gemfile",
+  "Makefile",
+  "CMakeLists.txt"
+], ENTRY_PATTERNS = [
+  "index.ts",
+  "index.js",
+  "main.ts",
+  "main.js",
+  "app.ts",
+  "app.js",
+  "main.py",
+  "app.py",
+  "__init__.py",
+  "main.rs",
+  "lib.rs",
+  "main.go",
+  "Main.java",
+  "Application.java"
+], MAX_TREE_DEPTH = 3, MAX_TREE_ENTRIES = 200, OverviewParams = typebox_exports.Object({
+  path: typebox_exports.Optional(typebox_exports.String({ description: "Root directory to analyze (defaults to project root)" })),
+  depth: typebox_exports.Optional(typebox_exports.Number({ description: "Maximum directory depth (default: 3)" }))
+});
+function createCodeOverviewTool(rootDirOrGetter, treeSitter, workspaceIndex) {
+  let getRootDir = typeof rootDirOrGetter == "function" ? rootDirOrGetter : () => rootDirOrGetter;
+  return {
+    name: "code_overview",
+    label: "Code Overview",
+    description: "Summarize project structure: directory tree, top-level symbols per key file, dependency manifests. Uses tree-sitter for symbol extraction \u2014 no LSP required.",
+    promptSnippet: "Get a structural overview of the project (directories, key files, symbols)",
+    parameters: OverviewParams,
+    async execute(_toolCallId, params) {
+      let rootDir = getRootDir(), targetDir = resolve(rootDir, params.path ?? "."), maxDepth = params.depth ?? MAX_TREE_DEPTH, sections = [], totalFiles = 0, totalSymbols = 0, treeLines = [];
+      await buildTree(targetDir, "", 0, maxDepth, treeLines), totalFiles = treeLines.filter((l) => !l.endsWith("/")).length, sections.push("## Directory Structure\n\n```\n" + treeLines.join(`
+`) + "\n```");
+      let manifests = [];
+      for (let m of MANIFESTS) {
+        let path = resolve(targetDir, m);
+        existsSync(path) && manifests.push(m);
+      }
+      manifests.length > 0 && sections.push(`## Dependency Manifests
+
+` + manifests.map((m) => `- ${m}`).join(`
+`));
+      let keyFiles = await findKeyFiles(targetDir);
+      if (keyFiles.length > 0) {
+        let symbolSections = [];
+        for (let file of keyFiles.slice(0, 10))
+          try {
+            let content = await readFile6(file, "utf-8"), languageId = treeSitter.getLanguageId(file);
+            if (!languageId)
+              continue;
+            let tree = await treeSitter.parse(file, content);
+            if (!tree)
+              continue;
+            let symbols = extractSymbols(tree, languageId);
+            if (symbols.length === 0)
+              continue;
+            let relPath = relative6(targetDir, file), symbolLines = symbols.slice(0, 20).map((s) => `  ${{
+              5: "class",
+              6: "method",
+              10: "enum",
+              11: "interface",
+              12: "function",
+              13: "variable",
+              14: "constant",
+              22: "struct"
+            }[s.kind] ?? "symbol"} ${s.name} (line ${s.line})`);
+            symbols.length > 20 && symbolLines.push(`  ... and ${symbols.length - 20} more`), totalSymbols += symbols.length, symbolSections.push(`### ${relPath}
+${symbolLines.join(`
+`)}`);
+          } catch {
+          }
+        symbolSections.length > 0 && sections.push(`## Key Files
+
+` + symbolSections.join(`
+
+`));
+      }
+      if (workspaceIndex.isBuilt) {
+        let stats = workspaceIndex.getStats();
+        sections.push(`## Index Stats
+
+- ${stats.files} indexed files
+- ${stats.symbols} symbols`);
+      }
+      let output = sections.join(`
+
+`), truncation = truncateHead(output, { maxLines: 2e3, maxBytes: 51200 }), text = truncation.content;
+      return truncation.truncated && (text += `
+
+[Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines]`), {
+        content: [{ type: "text", text }],
+        details: { files: totalFiles, symbols: totalSymbols }
+      };
+    },
+    renderCall(args, theme) {
+      let text = theme.fg("toolTitle", theme.bold("code_overview "));
+      return args.path ? text += theme.fg("accent", args.path) : text += theme.fg("dim", "(project root)"), new Text7(text, 0, 0);
+    },
+    renderResult(result, { isPartial }, theme) {
+      if (isPartial)
+        return new Text7(theme.fg("warning", "Analyzing..."), 0, 0);
+      let d = result.details;
+      return d ? new Text7(theme.fg("success", `${d.files} files, ${d.symbols} symbols`), 0, 0) : new Text7(theme.fg("dim", "No overview"), 0, 0);
+    }
+  };
+}
+async function buildTree(dir, prefix, depth, maxDepth, lines) {
+  if (!(depth > maxDepth || lines.length > MAX_TREE_ENTRIES))
+    try {
+      let sorted = (await readdir(dir, { withFileTypes: !0 })).filter((e) => !e.name.startsWith(".") || e.name === ".github").sort((a, b) => a.isDirectory() && !b.isDirectory() ? -1 : !a.isDirectory() && b.isDirectory() ? 1 : a.name.localeCompare(b.name));
+      for (let i = 0; i < sorted.length; i++) {
+        if (lines.length > MAX_TREE_ENTRIES) {
+          lines.push(`${prefix}... (truncated)`);
+          return;
+        }
+        let entry = sorted[i], isLast = i === sorted.length - 1, connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ", childPrefix = isLast ? "    " : "\u2502   ";
+        if (entry.isDirectory()) {
+          if (SKIP_DIRS.has(entry.name)) {
+            lines.push(`${prefix}${connector}${entry.name}/ (skipped)`);
+            continue;
+          }
+          lines.push(`${prefix}${connector}${entry.name}/`), await buildTree(resolve(dir, entry.name), prefix + childPrefix, depth + 1, maxDepth, lines);
+        } else
+          lines.push(`${prefix}${connector}${entry.name}`);
+      }
+    } catch {
+    }
+}
+async function findKeyFiles(dir) {
+  let found = [], searchDirs = [dir, resolve(dir, "src"), resolve(dir, "lib"), resolve(dir, "app")];
+  for (let searchDir of searchDirs)
+    for (let pattern of ENTRY_PATTERNS) {
+      let fullPath = resolve(searchDir, pattern);
+      existsSync(fullPath) && found.push(fullPath);
+    }
+  return [...new Set(found)];
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/tools/completions.js
+import { Text as Text8 } from "@ashx-j/lunr-tui";
+import { readFile as readFile7 } from "node:fs/promises";
+var KIND_LABELS = {
+  1: "text",
+  2: "method",
+  3: "function",
+  4: "constructor",
+  5: "field",
+  6: "variable",
+  7: "class",
+  8: "interface",
+  9: "module",
+  10: "property",
+  11: "unit",
+  12: "value",
+  13: "enum",
+  14: "keyword",
+  15: "snippet",
+  16: "color",
+  17: "file",
+  18: "reference",
+  19: "folder",
+  20: "enum member",
+  21: "constant",
+  22: "struct",
+  23: "event",
+  24: "operator",
+  25: "type param"
+};
+function kindLabel(kind) {
+  return kind ? KIND_LABELS[kind] ?? "unknown" : "unknown";
+}
+function docSummary(doc) {
+  if (!doc)
+    return;
+  let text = typeof doc == "string" ? doc : doc.value;
+  if (!text)
+    return;
+  let summary = text.replace(/```[\s\S]*?```/g, "").split(`
+`).map((l) => l.trim()).filter((l) => l.length > 0).slice(0, 2).join(" ");
+  return summary.length > 120 ? summary.slice(0, 117) + "..." : summary;
+}
+function formatItem(item) {
+  let kind = kindLabel(item.kind), label = item.label, detail = item.detail ? ` ${item.detail}` : "", labelDetail = item.labelDetails?.detail ? item.labelDetails.detail : "", labelDesc = item.labelDetails?.description ? ` \u2014 ${item.labelDetails.description}` : "", line = `${kind.padEnd(12)} ${label}${labelDetail}${detail}${labelDesc}`, doc = docSummary(item.documentation);
+  return doc && (line += `
+${"".padEnd(13)}${doc}`), line;
+}
+var CompletionParams = typebox_exports.Object({
+  path: typebox_exports.String({ description: "File path" }),
+  line: typebox_exports.Optional(typebox_exports.Number({ description: "Line number (1-indexed). Required unless query is provided." })),
+  character: typebox_exports.Optional(typebox_exports.Number({ description: "Column number (1-indexed). Required unless query is provided." })),
+  query: typebox_exports.Optional(typebox_exports.String({ description: "Symbol name to find in the file. Alternative to line/character \u2014 resolves the symbol's position automatically." })),
+  limit: typebox_exports.Optional(typebox_exports.Number({ description: "Max results to return (default: 20)" })),
+  trigger: typebox_exports.Optional(typebox_exports.Union([typebox_exports.Literal("auto"), typebox_exports.Literal("none")], {
+    description: 'Synthetic trigger mode (default: "auto"). When "auto", if the position is at the end of an identifier (no trailing dot), a dot is temporarily inserted to trigger member completions. Use "none" to skip this.'
+  }))
+});
+function shouldSyntheticTrigger(content, line, character) {
+  let lines = content.split(`
+`);
+  if (line < 0 || line >= lines.length)
+    return null;
+  let lineText = lines[line];
+  if (character < 0 || character > lineText.length || lineText[character] === ".")
+    return null;
+  let charBefore = character > 0 ? lineText[character - 1] : "";
+  return charBefore && /[\w\d_\)\]]/.test(charBefore) ? { insertLine: line, insertChar: character } : null;
+}
+function insertDot(content, line, character) {
+  let lines = content.split(`
+`), lineText = lines[line];
+  return lines[line] = lineText.slice(0, character) + "." + lineText.slice(character), lines.join(`
+`);
+}
+var syntheticDotLocks = /* @__PURE__ */ new Set();
+function createCompletionsTool(manager, versionTracker, treeSitter) {
+  return {
+    name: "lsp_completions",
+    label: "LSP Completions",
+    description: 'Get completion suggestions at a specific position in a file. Returns methods, properties, and other symbols available at that point. Useful for discovering APIs and verifying method names. Line and character are 1-indexed. When trigger is "auto" (default), a dot is temporarily inserted if the position is at the end of an identifier, enabling member completion without editing the file.',
+    promptSnippet: "Get code completion suggestions at a file position via LSP. Use to discover available methods, properties, and APIs on objects. Supports automatic dot insertion for exploring members on identifiers.",
+    parameters: CompletionParams,
+    async execute(_toolCallId, params) {
+      let filePath = params.path.replace(/^@/, ""), limit = params.limit ?? 20, trigger = params.trigger ?? "auto", line = params.line, character = params.character, resolvedFrom;
+      if ((line === void 0 || character === void 0) && params.query) {
+        let resolved = await resolveSymbolPosition(filePath, params.query, manager, treeSitter);
+        if (resolved)
+          line = resolved.line + 1, character = resolved.character + 1, resolvedFrom = `Resolved "${params.query}" \u2192 ${resolved.symbolName} at ${line}:${character} [${resolved.source}]`;
+        else
+          return { content: [{ type: "text", text: `Could not find symbol "${params.query}" in ${filePath}` }], details: { count: 0, total: 0 } };
+      }
+      if (line === void 0 || character === void 0)
+        return { content: [{ type: "text", text: "Either line/character or query is required." }], details: { count: 0, total: 0 } };
+      let client = await manager.getClientForFile(filePath).catch(() => null);
+      if (!client)
+        return {
+          content: [
+            { type: "text", text: manager.getUnavailableReason(filePath) }
+          ],
+          details: { count: 0, total: 0 }
+        };
+      let caps = client.serverCapabilities;
+      if (caps && !caps.completionProvider)
+        return {
+          content: [
+            {
+              type: "text",
+              text: "LSP server for this file does not support completions."
+            }
+          ],
+          details: { count: 0, total: 0 }
+        };
+      let uri = manager.getFileUri(filePath), position = {
+        line: line - 1,
+        character: character - 1
+      };
+      try {
+        let syntheticDot = !1, originalContent = null, revertVersion = 99991, completionPosition = position;
+        if (trigger === "auto" && !syntheticDotLocks.has(uri))
+          try {
+            syntheticDotLocks.add(uri);
+            let absPath = manager.resolvePath(filePath), fileContent = await readFile7(absPath, "utf-8"), triggerPos = shouldSyntheticTrigger(fileContent, position.line, position.character);
+            if (triggerPos) {
+              originalContent = fileContent;
+              let modifiedContent = insertDot(fileContent, triggerPos.insertLine, triggerPos.insertChar), currentVersion = versionTracker?.getTrackedVersion(uri), insertVersion = currentVersion != null ? currentVersion + 1 : 99990;
+              revertVersion = currentVersion != null ? currentVersion + 2 : 99991, client.didChange(uri, insertVersion, modifiedContent), versionTracker && currentVersion != null && versionTracker.setTrackedVersion(uri, insertVersion), completionPosition = {
+                line: triggerPos.insertLine,
+                character: triggerPos.insertChar + 1
+              }, syntheticDot = !0, await new Promise((r) => setTimeout(r, 100));
+            }
+          } catch {
+          } finally {
+            syntheticDotLocks.delete(uri);
+          }
+        let response;
+        try {
+          response = await client.sendRequest("textDocument/completion", { textDocument: { uri }, position: completionPosition });
+        } finally {
+          if (syntheticDot && originalContent !== null)
+            try {
+              client.didChange(uri, revertVersion, originalContent), versionTracker && versionTracker.setTrackedVersion(uri, revertVersion);
+            } catch {
+            }
+        }
+        if (!response)
+          return {
+            content: [
+              { type: "text", text: "No completions available at this position." }
+            ],
+            details: { count: 0, total: 0 }
+          };
+        let allItems = Array.isArray(response) ? response : response.items;
+        if (allItems.length === 0)
+          return {
+            content: [
+              { type: "text", text: "No completions available at this position." }
+            ],
+            details: { count: 0, total: 0 }
+          };
+        let total = allItems.length, topItems = [...allItems].sort((a, b) => {
+          let sa = a.sortText ?? a.label, sb = b.sortText ?? b.label;
+          return sa.localeCompare(sb);
+        }).slice(0, limit), resolveSupported = caps?.completionProvider?.resolveProvider, resolvedItems;
+        resolveSupported ? resolvedItems = (await Promise.allSettled(topItems.map((item) => Promise.race([
+          client.sendRequest("completionItem/resolve", item),
+          // Timeout per item: 2 seconds
+          new Promise((_, reject) => setTimeout(() => reject(new Error("resolve timeout")), 2e3))
+        ])))).map((result, i) => result.status === "fulfilled" ? result.value : topItems[i]) : resolvedItems = topItems;
+        let triggerNote = syntheticDot ? " (synthetic dot trigger)" : "", header = `${resolvedItems.length} of ${total} completions at ${filePath}:${line}:${character}${triggerNote}
+`;
+        resolvedFrom && (header = `${resolvedFrom}
+
+${header}`);
+        let lines = resolvedItems.map(formatItem);
+        return {
+          content: [{ type: "text", text: header + lines.join(`
+`) }],
+          details: { count: resolvedItems.length, total }
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `LSP completion request failed: ${err.message}`
+            }
+          ],
+          details: { count: 0, total: 0 }
+        };
+      }
+    },
+    renderCall(args, theme) {
+      let text = theme.fg("toolTitle", theme.bold("lsp_completions "));
+      args.query && !args.line ? (text += theme.fg("accent", `${args.path}`), text += theme.fg("muted", ` query="${args.query}"`)) : text += theme.fg("accent", `${args.path}:${args.line}:${args.character}`);
+      let extras = [];
+      return args.limit && extras.push(`limit: ${args.limit}`), args.trigger === "none" && extras.push("trigger: none"), extras.length > 0 && (text += theme.fg("dim", ` (${extras.join(", ")})`)), new Text8(text, 0, 0);
+    },
+    renderResult(result, { isPartial }, theme) {
+      if (isPartial)
+        return new Text8(theme.fg("warning", "Loading completions..."), 0, 0);
+      if (!result.details || result.details.count === 0) {
+        let content = result.content[0];
+        return content?.type === "text" ? new Text8(theme.fg("dim", content.text), 0, 0) : new Text8(theme.fg("dim", "No completions"), 0, 0);
+      }
+      let { count, total } = result.details, summary = `${count} of ${total} completions`;
+      return new Text8(theme.fg("dim", summary), 0, 0);
+    }
+  };
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/tools/code-search.js
+import { relative as relative7 } from "node:path";
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/tree-sitter/pattern-compiler.js
+var VARIADIC_RE = /^\$\$\$([A-Z_][A-Z0-9_]*)?$/, METAVAR_RE = /^\$([A-Z_][A-Z0-9_]*)$/;
+function isVariadic(text) {
+  let m = VARIADIC_RE.exec(text);
+  return m ? m[1] ?? "" : null;
+}
+function isMetavar(text) {
+  let m = METAVAR_RE.exec(text);
+  return m ? m[1] : null;
+}
+var META_PREFIX = "__META_", VMETA_PREFIX = "__VMETA_", META_SUFFIX = "__";
+function preprocessMetavars(source) {
+  let placeholders = /* @__PURE__ */ new Map(), preprocessed = source.replace(/\$\$\$([A-Z_][A-Z0-9_]*)?/g, (_match, name) => {
+    let n = name ?? "", placeholder = `${VMETA_PREFIX}${n || "ANON"}${META_SUFFIX}`;
+    return placeholders.set(placeholder, { kind: "variadic", name: n }), placeholder;
+  });
+  return preprocessed = preprocessed.replace(/\$([A-Z_][A-Z0-9_]*)/g, (_match, name) => {
+    let placeholder = `${META_PREFIX}${name}${META_SUFFIX}`;
+    return placeholders.set(placeholder, { kind: "metavar", name }), placeholder;
+  }), { preprocessed, placeholders };
+}
+function decodePlaceholder(text, placeholders) {
+  return placeholders.get(text) ?? null;
+}
+async function compilePattern(source, languageId, treeSitter) {
+  await treeSitter.init();
+  let { preprocessed, placeholders } = preprocessMetavars(source), wrappers = getWrappersForLanguage(languageId);
+  for (let { wrap, unwrap } of wrappers) {
+    let wrapped = wrap(preprocessed), tree = await treeSitter.parseWithLanguage(`__pattern__${Date.now()}`, wrapped, languageId);
+    if (!tree)
+      continue;
+    let root = tree.rootNode;
+    if (hasErrors(root))
+      continue;
+    let unwrapped = unwrap(root);
+    if (!unwrapped)
+      continue;
+    let metavars = [];
+    return { root: buildPatternNode(unwrapped, metavars, void 0, placeholders), metavars: [...new Set(metavars)], languageId };
+  }
+  throw new Error(`Failed to parse pattern as ${languageId}. The pattern may have syntax errors or may not be a valid code fragment in this language.`);
+}
+function getWrappersForLanguage(languageId) {
+  let common = [
+    { wrap: (s) => s, unwrap: unwrapProgram },
+    { wrap: (s) => `${s};`, unwrap: unwrapProgram },
+    { wrap: (s) => `(${s})`, unwrap: unwrapExpression }
+  ];
+  return languageId === "python" ? [
+    { wrap: (s) => s, unwrap: unwrapModule },
+    { wrap: (s) => `(${s})`, unwrap: unwrapExpression },
+    { wrap: (s) => `def _():
+  ${s}`, unwrap: unwrapPythonFunctionBody }
+  ] : [
+    ...common,
+    { wrap: (s) => `function _() { ${s} }`, unwrap: unwrapFunctionBody }
+  ];
+}
+function buildPatternNode(node, metavars, fieldName, placeholders) {
+  let text = node.text;
+  if (node.namedChildCount === 0) {
+    let decoded = decodePlaceholder(text, placeholders);
+    if (decoded)
+      return decoded.name && metavars.push(decoded.name), decoded.kind === "variadic" ? { kind: "variadic", name: decoded.name, fieldName } : { kind: "metavar", name: decoded.name, fieldName };
+  }
+  if (node.namedChildCount === 0) {
+    let variadicName = isVariadic(text);
+    if (variadicName !== null)
+      return variadicName && metavars.push(variadicName), { kind: "variadic", name: variadicName, fieldName };
+    let metavarName = isMetavar(text);
+    if (metavarName !== null)
+      return metavars.push(metavarName), { kind: "metavar", name: metavarName, fieldName };
+  }
+  if (node.namedChildCount === 1) {
+    let onlyChild = node.namedChildren[0];
+    if (onlyChild.namedChildCount === 0) {
+      let decoded = decodePlaceholder(onlyChild.text, placeholders);
+      if (decoded)
+        return decoded.name && metavars.push(decoded.name), decoded.kind === "variadic" ? { kind: "variadic", name: decoded.name, fieldName } : { kind: "metavar", name: decoded.name, fieldName };
+      let childMeta = isMetavar(onlyChild.text);
+      if (childMeta !== null)
+        return metavars.push(childMeta), { kind: "metavar", name: childMeta, fieldName };
+      let childVariadic = isVariadic(onlyChild.text);
+      if (childVariadic !== null)
+        return childVariadic && metavars.push(childVariadic), { kind: "variadic", name: childVariadic, fieldName };
+    }
+  }
+  if (node.namedChildCount === 0)
+    return { kind: "literal", nodeType: node.type, text, children: [], fieldName };
+  let children = [];
+  for (let child of node.namedChildren) {
+    let childFieldName = getFieldName(node, child);
+    children.push(buildPatternNode(child, metavars, childFieldName, placeholders));
+  }
+  return { kind: "literal", nodeType: node.type, children, fieldName };
+}
+function getFieldName(parent, child) {
+  for (let i = 0; i < parent.childCount; i++) {
+    let c = parent.child(i);
+    if (c && c.id === child.id)
+      return parent.fieldNameForChild(i) ?? void 0;
+  }
+}
+function unwrapProgram(root) {
+  if (root.type !== "program" || root.namedChildCount === 0)
+    return null;
+  let child = root.namedChildren[0];
+  return child.type === "expression_statement" && child.namedChildCount === 1 ? child.namedChildren[0] : child;
+}
+function unwrapModule(root) {
+  if (root.type !== "module" || root.namedChildCount === 0)
+    return null;
+  let child = root.namedChildren[0];
+  return child.type === "expression_statement" && child.namedChildCount === 1 ? child.namedChildren[0] : child;
+}
+function unwrapExpression(root) {
+  if (root.type !== "program" || root.namedChildCount === 0)
+    return null;
+  let node = root.namedChildren[0];
+  return node.type === "expression_statement" && (node = node.namedChildren[0]), node.type === "parenthesized_expression" && node.namedChildCount === 1 ? node.namedChildren[0] : node;
+}
+function unwrapFunctionBody(root) {
+  if (root.type !== "program" || root.namedChildCount === 0)
+    return null;
+  let fn = root.namedChildren[0];
+  if (!fn.type.includes("function"))
+    return null;
+  let body = fn.childForFieldName("body");
+  if (!body || body.namedChildCount === 0)
+    return null;
+  let stmt = body.namedChildren[0];
+  return stmt.type === "expression_statement" && stmt.namedChildCount === 1 ? stmt.namedChildren[0] : stmt;
+}
+function unwrapPythonFunctionBody(root) {
+  if (root.type !== "module" || root.namedChildCount === 0)
+    return null;
+  let fn = root.namedChildren[0];
+  if (fn.type !== "function_definition")
+    return null;
+  let body = fn.childForFieldName("body");
+  if (!body || body.namedChildCount === 0)
+    return null;
+  let stmt = body.namedChildren[0];
+  return stmt.type === "expression_statement" && stmt.namedChildCount === 1 ? stmt.namedChildren[0] : stmt;
+}
+function hasErrors(node) {
+  if (node.type === "ERROR" || node.isMissing)
+    return !0;
+  for (let i = 0; i < node.childCount; i++) {
+    let child = node.child(i);
+    if (child && hasErrors(child))
+      return !0;
+  }
+  return !1;
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/tree-sitter/search-engine.js
+import { resolve as resolve2 } from "node:path";
+import { readdir as readdir2, readFile as readFile8, stat } from "node:fs/promises";
+async function searchFiles(pattern, rootDir, treeSitter, options = {}) {
+  let searchRoot = options.path ? resolve2(rootDir, options.path) : rootDir, maxResults = options.maxResults ?? 50, stats = await stat(searchRoot), files;
+  stats.isFile() ? files = [searchRoot] : files = await collectFilesByLanguage(searchRoot, pattern.languageId, treeSitter);
+  let matches = [];
+  for (let file of files) {
+    if (matches.length >= maxResults)
+      break;
+    try {
+      let content = await readFile8(file, "utf-8"), tree = await treeSitter.parseWithLanguage(file, content, pattern.languageId);
+      if (!tree)
+        continue;
+      let fileMatches = findMatches(tree.rootNode, pattern.root);
+      for (let m of fileMatches) {
+        if (matches.length >= maxResults)
+          break;
+        matches.push({
+          file,
+          line: m.node.startPosition.row + 1,
+          column: m.node.startPosition.column + 1,
+          matchedText: m.node.text,
+          startIndex: m.node.startIndex,
+          endIndex: m.node.endIndex,
+          captures: m.captures
+        });
+      }
+    } catch {
+    }
+  }
+  return matches;
+}
+async function collectFilesByLanguage(dir, languageId, treeSitter, collected = [], maxFiles = MAX_INDEX_FILES) {
+  if (collected.length >= maxFiles)
+    return collected;
+  try {
+    let entries = await readdir2(dir, { withFileTypes: !0 });
+    for (let entry of entries) {
+      if (collected.length >= maxFiles)
+        break;
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name) || entry.name.startsWith("."))
+          continue;
+        await collectFilesByLanguage(resolve2(dir, entry.name), languageId, treeSitter, collected, maxFiles);
+      } else if (entry.isFile() && treeSitter.getLanguageId(entry.name) === languageId) {
+        let filePath = resolve2(dir, entry.name);
+        try {
+          (await stat(filePath)).size <= MAX_FILE_SIZE && collected.push(filePath);
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return collected;
+}
+function findMatches(root, pattern) {
+  let matches = [], visited = /* @__PURE__ */ new Set();
+  function walk(node) {
+    if (visited.has(node.id))
+      return;
+    let captures = {};
+    if (matchNode(node, pattern, captures)) {
+      matches.push({ node, captures }), markDescendants(node, visited);
+      return;
+    }
+    for (let child of node.namedChildren)
+      walk(child);
+  }
+  return walk(root), matches;
+}
+function markDescendants(node, visited) {
+  visited.add(node.id);
+  for (let child of node.namedChildren)
+    markDescendants(child, visited);
+}
+function matchNode(target, pattern, captures) {
+  switch (pattern.kind) {
+    case "metavar": {
+      let name = pattern.name;
+      return name in captures ? captures[name] === target.text : (captures[name] = target.text, !0);
+    }
+    case "variadic": {
+      let name = pattern.name;
+      return name && name in captures ? captures[name] === target.text : (name && (captures[name] = target.text), !0);
+    }
+    case "literal":
+      return target.type !== pattern.nodeType ? !1 : pattern.text !== void 0 ? target.text === pattern.text : matchChildrenFieldAware(target, pattern.children, captures);
+  }
+}
+function matchChildrenFieldAware(targetNode, patternChildren, captures) {
+  let fieldPatterns = [], positionalPatterns = [];
+  for (let pc of patternChildren)
+    pc.fieldName ? fieldPatterns.push(pc) : positionalPatterns.push(pc);
+  for (let fp of fieldPatterns) {
+    let targetChild = targetNode.childForFieldName(fp.fieldName);
+    if (!targetChild || !matchNode(targetChild, fp, captures))
+      return !1;
+  }
+  if (positionalPatterns.length > 0) {
+    let matchedFieldNames = new Set(fieldPatterns.map((fp) => fp.fieldName)), remainingTargets = [];
+    for (let child of targetNode.namedChildren) {
+      let childField = getChildFieldName(targetNode, child);
+      (!childField || !matchedFieldNames.has(childField)) && remainingTargets.push(child);
+    }
+    return matchChildrenPositional(remainingTargets, 0, positionalPatterns, 0, captures);
+  }
+  return !0;
+}
+function getChildFieldName(parent, child) {
+  for (let i = 0; i < parent.childCount; i++) {
+    let c = parent.child(i);
+    if (c && c.id === child.id)
+      return parent.fieldNameForChild(i);
+  }
+  return null;
+}
+function matchChildrenPositional(targets, ti, patterns, pi, captures) {
+  if (pi >= patterns.length)
+    return !0;
+  let pat = patterns[pi];
+  if (pat.kind === "variadic") {
+    if (pi === patterns.length - 1) {
+      let remainingText = targets.slice(ti).map((t) => t.text).join(", ");
+      if (pat.name) {
+        if (pat.name in captures && captures[pat.name] !== remainingText)
+          return !1;
+        captures[pat.name] = remainingText;
+      }
+      return !0;
+    }
+    for (let take = 0; take <= targets.length - ti; take++) {
+      let captureSnapshot2 = { ...captures }, consumedText = targets.slice(ti, ti + take).map((t) => t.text).join(", ");
+      if (pat.name) {
+        if (pat.name in captureSnapshot2 && captureSnapshot2[pat.name] !== consumedText)
+          continue;
+        captureSnapshot2[pat.name] = consumedText;
+      }
+      if (matchChildrenPositional(targets, ti + take, patterns, pi + 1, captureSnapshot2))
+        return Object.assign(captures, captureSnapshot2), !0;
+    }
+    return !1;
+  }
+  if (ti >= targets.length)
+    return !1;
+  let captureSnapshot = { ...captures };
+  return matchNode(targets[ti], pat, captureSnapshot) && matchChildrenPositional(targets, ti + 1, patterns, pi + 1, captureSnapshot) ? (Object.assign(captures, captureSnapshot), !0) : !1;
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/tools/code-search.js
+var SearchParams = typebox_exports.Object({
+  pattern: typebox_exports.String({ description: "Structural pattern with metavariables ($NAME for single node, $$$NAME for variadic)" }),
+  language: typebox_exports.String({ description: "Target language (typescript, python, rust, java, etc.)" }),
+  path: typebox_exports.Optional(typebox_exports.String({ description: "File or directory to search (default: workspace root)" })),
+  max_results: typebox_exports.Optional(typebox_exports.Number({ description: "Maximum results to return (default: 50)" }))
+});
+function createCodeSearchTool(rootDirOrGetter, treeSitter) {
+  let getRootDir = typeof rootDirOrGetter == "function" ? rootDirOrGetter : () => rootDirOrGetter;
+  return {
+    name: "ast_search",
+    label: "Code Search",
+    description: "Find code matching a structural pattern using AST matching. Use $NAME to match any single node, $$$NAME to match zero-or-more nodes. More precise than grep \u2014 matches code structure, not text.",
+    parameters: SearchParams,
+    async execute(_toolCallId, params) {
+      let rootDir = getRootDir(), { pattern: patternStr, language, path, max_results } = params, compiled;
+      try {
+        compiled = await compilePattern(patternStr, language, treeSitter);
+      } catch (e) {
+        return {
+          content: [{ type: "text", text: `Error: ${e.message}` }],
+          details: { matchCount: 0, filesSearched: 0 }
+        };
+      }
+      let matches = await searchFiles(compiled, rootDir, treeSitter, {
+        path,
+        maxResults: max_results ?? 50
+      });
+      if (matches.length === 0)
+        return {
+          content: [{ type: "text", text: "No matches found." }],
+          details: { matchCount: 0, filesSearched: 0 }
+        };
+      let lines = [];
+      lines.push(`Found ${matches.length} match${matches.length !== 1 ? "es" : ""}:
+`);
+      for (let m of matches) {
+        let relPath = relative7(rootDir, m.file), matchText = m.matchedText.length > 200 ? m.matchedText.slice(0, 200) + "..." : m.matchedText;
+        lines.push(`${relPath}:${m.line}:${m.column}`), lines.push(`  ${matchText.replace(/\n/g, `
+  `)}`);
+        let captureEntries = Object.entries(m.captures);
+        if (captureEntries.length > 0)
+          for (let [name, value] of captureEntries) {
+            let displayValue = value.length > 100 ? value.slice(0, 100) + "..." : value;
+            lines.push(`  $${name} = ${displayValue}`);
+          }
+        lines.push("");
+      }
+      let text = lines.join(`
+`), uniqueFiles = new Set(matches.map((m) => m.file)), truncation = truncateHead(text, { maxLines: 2e3, maxBytes: 51200 }), output = truncation.content;
+      return truncation.truncated && (output += `
+
+[Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines]`), {
+        content: [{ type: "text", text: output }],
+        details: { matchCount: matches.length, filesSearched: uniqueFiles.size }
+      };
+    }
+  };
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/tools/code-rewrite.js
+import { relative as relative8 } from "node:path";
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/tree-sitter/rewrite-engine.js
+import { readFile as readFile9, writeFile } from "node:fs/promises";
+var METAVAR_REF_RE = /\$\$\$([A-Z_][A-Z0-9_]*)|\$([A-Z_][A-Z0-9_]*)/g;
+function substituteCaptures(template, captures) {
+  return template.replace(METAVAR_REF_RE, (match, variadicName, singleName) => {
+    let name = variadicName ?? singleName;
+    return name in captures ? captures[name] : match;
+  });
+}
+function preserveTrailingSemicolon(original, replacement) {
+  let trailingMatch = original.match(/(\s*;)\s*$/);
+  return trailingMatch && !replacement.trimEnd().endsWith(";") ? replacement + trailingMatch[1] : replacement;
+}
+function computeRewrites(matches, replacementTemplate) {
+  return matches.map((m) => {
+    let raw = substituteCaptures(replacementTemplate, m.captures), after = preserveTrailingSemicolon(m.matchedText, raw);
+    return {
+      file: m.file,
+      line: m.line,
+      column: m.column,
+      before: m.matchedText,
+      after
+    };
+  });
+}
+async function applyRewrites(matches, replacementTemplate) {
+  let byFile = /* @__PURE__ */ new Map();
+  for (let m of matches) {
+    let existing = byFile.get(m.file);
+    existing ? existing.push(m) : byFile.set(m.file, [m]);
+  }
+  let changes = [], filesModified = 0;
+  for (let [file, fileMatches] of byFile) {
+    let sorted = [...fileMatches].sort((a, b) => b.startIndex - a.startIndex), content = await readFile9(file, "utf-8"), modified = !1;
+    for (let m of sorted) {
+      let raw = substituteCaptures(replacementTemplate, m.captures), replacement = preserveTrailingSemicolon(m.matchedText, raw);
+      replacement !== m.matchedText && (content = content.slice(0, m.startIndex) + replacement + content.slice(m.endIndex), modified = !0), changes.push({
+        file,
+        line: m.line,
+        column: m.column,
+        before: m.matchedText,
+        after: replacement
+      });
+    }
+    modified && (await writeFile(file, content, "utf-8"), filesModified++);
+  }
+  return changes.reverse(), { changes, filesModified };
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/tools/code-rewrite.js
+var RewriteParams = typebox_exports.Object({
+  pattern: typebox_exports.String({ description: "Structural pattern to match (with $NAME / $$$NAME metavariables)" }),
+  replacement: typebox_exports.String({ description: "Replacement template using the same metavariables" }),
+  language: typebox_exports.String({ description: "Target language (typescript, python, rust, java, etc.)" }),
+  path: typebox_exports.Optional(typebox_exports.String({ description: "File or directory scope (default: workspace root)" })),
+  dry_run: typebox_exports.Optional(typebox_exports.Boolean({ description: "Preview changes without applying (default: true)" }))
+});
+function createCodeRewriteTool(rootDirOrGetter, treeSitter, fileChangeCallback) {
+  let getRootDir = typeof rootDirOrGetter == "function" ? rootDirOrGetter : () => rootDirOrGetter;
+  return {
+    name: "code_rewrite",
+    label: "Code Rewrite",
+    description: "Transform code matching a structural pattern into a replacement. Use $NAME to capture and reuse single nodes, $$$NAME for sequences. Defaults to dry-run mode (preview only). Set dry_run=false to apply changes. For symbol renames, prefer lsp_rename instead (semantically correct).",
+    parameters: RewriteParams,
+    async execute(_toolCallId, params) {
+      let rootDir = getRootDir(), { pattern: patternStr, replacement, language, path, dry_run } = params, isDryRun = dry_run !== !1, compiled;
+      try {
+        compiled = await compilePattern(patternStr, language, treeSitter);
+      } catch (e) {
+        return {
+          content: [{ type: "text", text: `Error: ${e.message}` }],
+          details: { matchCount: 0, filesModified: 0, dryRun: isDryRun }
+        };
+      }
+      let knownVars = new Set(compiled.metavars), refRe = /\$\$\$([A-Z_][A-Z0-9_]*)|\$([A-Z_][A-Z0-9_]*)/g, refMatch;
+      for (; (refMatch = refRe.exec(replacement)) !== null; ) {
+        let name = refMatch[1] ?? refMatch[2];
+        if (!knownVars.has(name))
+          return {
+            content: [{ type: "text", text: `Error: Replacement references $${name} but pattern doesn't capture it. Pattern captures: ${compiled.metavars.join(", ") || "(none)"}` }],
+            details: { matchCount: 0, filesModified: 0, dryRun: isDryRun }
+          };
+      }
+      let matches = await searchFiles(compiled, rootDir, treeSitter, {
+        path,
+        maxResults: 500
+      });
+      if (matches.length === 0)
+        return {
+          content: [{ type: "text", text: "No matches found. No changes to make." }],
+          details: { matchCount: 0, filesModified: 0, dryRun: isDryRun }
+        };
+      if (isDryRun) {
+        let changes = computeRewrites(matches, replacement), lines2 = [];
+        lines2.push(`Dry run: ${changes.length} change${changes.length !== 1 ? "s" : ""} would be made:
+`);
+        for (let c of changes) {
+          let relPath = relative8(rootDir, c.file);
+          lines2.push(`${relPath}:${c.line}:${c.column}`);
+          let beforeLines = c.before.split(`
+`), afterLines = c.after.split(`
+`);
+          for (let l of beforeLines)
+            lines2.push(`  - ${l}`);
+          for (let l of afterLines)
+            lines2.push(`  + ${l}`);
+          lines2.push("");
+        }
+        lines2.push("Run with dry_run=false to apply these changes.");
+        let text2 = lines2.join(`
+`), truncation2 = truncateHead(text2, { maxLines: 2e3, maxBytes: 51200 }), output2 = truncation2.content;
+        truncation2.truncated && (output2 += `
+
+[Truncated: showing ${truncation2.outputLines} of ${truncation2.totalLines} lines]`);
+        let uniqueFiles = new Set(changes.map((c) => c.file));
+        return {
+          content: [{ type: "text", text: output2 }],
+          details: { matchCount: matches.length, filesModified: uniqueFiles.size, dryRun: !0 }
+        };
+      }
+      let result = await applyRewrites(matches, replacement);
+      if (fileChangeCallback && result.filesModified > 0) {
+        let modifiedFiles = new Set(result.changes.map((c) => c.file));
+        for (let file of modifiedFiles)
+          fileChangeCallback.onFileModified(file);
+      }
+      let lines = [];
+      lines.push(`Applied ${result.changes.length} change${result.changes.length !== 1 ? "s" : ""} across ${result.filesModified} file${result.filesModified !== 1 ? "s" : ""}:
+`);
+      for (let c of result.changes) {
+        let relPath = relative8(rootDir, c.file), beforeShort = c.before.length > 80 ? c.before.slice(0, 80) + "..." : c.before, afterShort = c.after.length > 80 ? c.after.slice(0, 80) + "..." : c.after;
+        lines.push(`${relPath}:${c.line} \u2014 ${beforeShort} \u2192 ${afterShort}`);
+      }
+      let text = lines.join(`
+`), truncation = truncateHead(text, { maxLines: 2e3, maxBytes: 51200 }), output = truncation.content;
+      return truncation.truncated && (output += `
+
+[Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines]`), {
+        content: [{ type: "text", text: output }],
+        details: { matchCount: matches.length, filesModified: result.filesModified, dryRun: !1 }
+      };
+    }
+  };
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/tools/code-actions.js
+import { Text as Text9 } from "@ashx-j/lunr-tui";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
+import { relative as relative9 } from "node:path";
+var CodeActionsParams = typebox_exports.Object({
+  path: typebox_exports.String({ description: "File path" }),
+  line: typebox_exports.Optional(typebox_exports.Number({ description: "Line number (1-indexed). Required unless query is provided." })),
+  character: typebox_exports.Optional(typebox_exports.Number({ description: "Column number (1-indexed). Required unless query is provided." })),
+  query: typebox_exports.Optional(typebox_exports.String({ description: "Symbol name to find in the file. Alternative to line/character \u2014 resolves the symbol's position automatically." })),
+  endLine: typebox_exports.Optional(typebox_exports.Number({ description: "End line for range selection (1-indexed). Defaults to line." })),
+  endCharacter: typebox_exports.Optional(typebox_exports.Number({ description: "End column for range selection (1-indexed). Defaults to character." })),
+  kind: typebox_exports.Optional(typebox_exports.String({ description: 'Filter by action kind (e.g., "quickfix", "refactor", "source")' }))
+});
+function rangeContainsPosition(range, line, character) {
+  return !(line < range.start.line || line > range.end.line || line === range.start.line && character < range.start.character || line === range.end.line && character > range.end.character);
+}
+function formatEditSummary(edit, rootDir) {
+  let lines = [];
+  if (edit.documentChanges) {
+    for (let change of edit.documentChanges)
+      if ("textDocument" in change && "edits" in change) {
+        let relPath;
+        try {
+          relPath = relative9(rootDir, fileURLToPath5(change.textDocument.uri));
+        } catch {
+          relPath = change.textDocument.uri;
+        }
+        for (let textEdit of change.edits.slice(0, 5)) {
+          let ln = textEdit.range.start.line + 1, col = textEdit.range.start.character + 1, endLn = textEdit.range.end.line + 1, endCol = textEdit.range.end.character + 1, newText = textEdit.newText.length > 60 ? textEdit.newText.slice(0, 57) + "..." : textEdit.newText;
+          textEdit.range.start.line === textEdit.range.end.line && textEdit.range.start.character === textEdit.range.end.character ? lines.push(`     ${relPath}:${ln}:${col} insert "${newText.replace(/\n/g, "\\n")}"`) : lines.push(`     ${relPath}:${ln}:${col}-${endLn}:${endCol} \u2192 "${newText.replace(/\n/g, "\\n")}"`);
+        }
+        let remaining = change.edits.length - 5;
+        remaining > 0 && lines.push(`     ... and ${remaining} more edits in ${relPath}`);
+      }
+  }
+  let changes = edit.changes ?? {};
+  for (let [uri, edits] of Object.entries(changes)) {
+    let relPath;
+    try {
+      relPath = relative9(rootDir, fileURLToPath5(uri));
+    } catch {
+      relPath = uri;
+    }
+    for (let textEdit of edits.slice(0, 5)) {
+      let ln = textEdit.range.start.line + 1, col = textEdit.range.start.character + 1, endLn = textEdit.range.end.line + 1, endCol = textEdit.range.end.character + 1, newText = textEdit.newText.length > 60 ? textEdit.newText.slice(0, 57) + "..." : textEdit.newText;
+      textEdit.range.start.line === textEdit.range.end.line && textEdit.range.start.character === textEdit.range.end.character ? lines.push(`     ${relPath}:${ln}:${col} insert "${newText.replace(/\n/g, "\\n")}"`) : lines.push(`     ${relPath}:${ln}:${col}-${endLn}:${endCol} \u2192 "${newText.replace(/\n/g, "\\n")}"`);
+    }
+    let remaining = edits.length - 5;
+    remaining > 0 && lines.push(`     ... and ${remaining} more edits in ${relPath}`);
+  }
+  return lines;
+}
+function isCodeAction(item) {
+  return "kind" in item || "edit" in item || "diagnostics" in item || "isPreferred" in item;
+}
+function createCodeActionsTool(manager, treeSitter) {
+  return {
+    name: "lsp_code_actions",
+    label: "LSP Code Actions",
+    description: "Get available code actions (quick fixes, refactorings, source actions) at a position or range. Returns actionable fixes the LSP server can suggest \u2014 auto-imports, remove unused, extract method, etc.",
+    promptSnippet: "Get available code actions (quick fixes, refactorings) at a file position via LSP. Use after lsp_diagnostics shows errors to find auto-fixes.",
+    parameters: CodeActionsParams,
+    async execute(_toolCallId, params) {
+      let filePath = params.path.replace(/^@/, ""), line = params.line, character = params.character, resolvedFrom;
+      if ((line === void 0 || character === void 0) && params.query) {
+        let resolved = await resolveSymbolPosition(filePath, params.query, manager, treeSitter);
+        if (resolved)
+          line = resolved.line, character = resolved.character, resolvedFrom = `Resolved "${params.query}" \u2192 ${resolved.symbolName} at ${line}:${character} [${resolved.source}]`;
+        else {
+          let names = await getSymbolNames(filePath, manager, treeSitter), hint = names.length > 0 ? `
+Available symbols: ${names.slice(0, 20).join(", ")}` : "";
+          return { content: [{ type: "text", text: `Could not find symbol "${params.query}" in ${filePath}${hint}` }], details: { count: 0, preferredCount: 0 } };
+        }
+      }
+      if (line === void 0 || character === void 0)
+        return { content: [{ type: "text", text: "Either line/character or query is required." }], details: { count: 0, preferredCount: 0 } };
+      let client = await manager.getClientForFile(filePath).catch(() => null);
+      if (!client)
+        return { content: [{ type: "text", text: manager.getUnavailableReason(filePath) }], details: { count: 0, preferredCount: 0 } };
+      let caps = client.serverCapabilities;
+      if (caps && !caps.codeActionProvider)
+        return {
+          content: [{ type: "text", text: "LSP server for this file does not support code actions." }],
+          details: { count: 0, preferredCount: 0 }
+        };
+      let uri = manager.getFileUri(filePath), startLine = line - 1, startChar = character - 1, endLine = (params.endLine ?? line) - 1, endChar = (params.endCharacter ?? character) - 1, rangeDiags = (client.getDiagnostics(uri) ?? []).filter((d) => rangeContainsPosition(d.range, startLine, startChar) || rangeContainsPosition({ start: { line: startLine, character: startChar }, end: { line: endLine, character: endChar } }, d.range.start.line, d.range.start.character));
+      try {
+        let response = await client.sendRequest("textDocument/codeAction", {
+          textDocument: { uri },
+          range: {
+            start: { line: startLine, character: startChar },
+            end: { line: endLine, character: endChar }
+          },
+          context: {
+            diagnostics: rangeDiags,
+            only: params.kind ? [params.kind] : void 0
+          }
+        });
+        if (!response || response.length === 0)
+          return { content: [{ type: "text", text: resolvedFrom ? `${resolvedFrom}
+
+No code actions available at this position.` : "No code actions available at this position." }], details: { count: 0, preferredCount: 0 } };
+        let actions = [], commands = [];
+        for (let item of response)
+          isCodeAction(item) ? actions.push(item) : commands.push(item);
+        let kindOrder = { quickfix: 0, refactor: 1, source: 2 };
+        actions.sort((a, b) => {
+          if (a.isPreferred && !b.isPreferred)
+            return -1;
+          if (!a.isPreferred && b.isPreferred)
+            return 1;
+          let aKind = a.kind?.split(".")[0] ?? "zzz", bKind = b.kind?.split(".")[0] ?? "zzz";
+          return (kindOrder[aKind] ?? 3) - (kindOrder[bKind] ?? 3);
+        });
+        let rootDir = manager.resolvePath("."), outputLines = [], preferredCount = 0;
+        for (let i = 0; i < actions.length; i++) {
+          let action = actions[i], preferred = action.isPreferred ? "\u2605 " : "";
+          action.isPreferred && preferredCount++;
+          let kindStr = action.kind ? ` [${action.kind}]` : "";
+          if (outputLines.push(`  ${i + 1}. ${preferred}${action.title}${kindStr}`), action.edit) {
+            let editLines = formatEditSummary(action.edit, rootDir);
+            outputLines.push(...editLines);
+          } else action.command && !action.edit ? outputLines.push(`     (command: ${action.command.title || action.command.command})`) : outputLines.push("     (resolve required)");
+        }
+        for (let cmd of commands)
+          outputLines.push(`  \u2022 ${cmd.title} (command-only, requires IDE execution)`);
+        let totalCount = actions.length + commands.length, header = `${totalCount} code action(s) at ${filePath}:${line}:${character}`, preferredNote = preferredCount > 0 ? ` (${preferredCount} preferred)` : "", text = `${header}${preferredNote}
+
+${outputLines.join(`
+`)}`;
+        return resolvedFrom && (text = `${resolvedFrom}
+
+${text}`), {
+          content: [{ type: "text", text }],
+          details: { count: totalCount, preferredCount }
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `LSP code action request failed: ${err.message}` }],
+          details: { count: 0, preferredCount: 0 }
+        };
+      }
+    },
+    renderCall(args, theme) {
+      let text = theme.fg("toolTitle", theme.bold("lsp_code_actions "));
+      return args.query && !args.line ? (text += theme.fg("accent", args.path), text += theme.fg("muted", ` query="${args.query}"`)) : args.endLine ? text += theme.fg("accent", `${args.path}:${args.line}:${args.character}-${args.endLine}:${args.endCharacter}`) : text += theme.fg("accent", `${args.path}:${args.line}:${args.character}`), args.kind && (text += theme.fg("dim", ` [${args.kind}]`)), new Text9(text, 0, 0);
+    },
+    renderResult(result, { isPartial }, theme) {
+      if (isPartial)
+        return new Text9(theme.fg("warning", "Loading..."), 0, 0);
+      let details = result.details;
+      if (!details || details.count === 0)
+        return new Text9(theme.fg("dim", "No code actions available"), 0, 0);
+      let preferred = details.preferredCount > 0 ? ` (${details.preferredCount} preferred)` : "";
+      return new Text9(theme.fg("success", `${details.count} action(s)${preferred}`), 0, 0);
+    }
+  };
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/index.js
+import { relative as relative10 } from "node:path";
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { join, resolve as resolve3 } from "node:path";
+function loadProjectConfig(dir) {
+  let configPath = join(dir, ".pi-lsp.json");
+  try {
+    if (!existsSync2(configPath))
+      return null;
+    let raw = readFileSync(configPath, "utf-8"), parsed = JSON.parse(raw);
+    return typeof parsed != "object" || parsed === null ? null : parsed;
+  } catch {
+    return null;
+  }
+}
+function createServiceProxy(getTarget, label) {
+  return new Proxy({}, {
+    get(_target, prop, receiver) {
+      let service = getTarget();
+      if (!service)
+        throw new Error(`${label} is not initialized`);
+      let value = Reflect.get(service, prop, service);
+      return typeof value == "function" ? value.bind(service) : value;
+    }
+  });
+}
+function registerToolWithRuntime(pi, tool, ensure, host) {
+  pi.registerTool({
+    ...tool,
+    async execute(id, params, signal, onUpdate, ctx) {
+      let generation = host.getGeneration();
+      if (signal?.throwIfAborted(), await awaitWithAbort(ensure(), signal), signal?.throwIfAborted(), host.getGeneration() !== generation)
+        throw new Error("LSP session changed before execution");
+      return tool.execute(id, params, signal, onUpdate, ctx);
+    }
+  });
+}
+function lspExtension(pi) {
+  let origListeners = process.listeners("uncaughtException");
+  process.on("uncaughtException", (err) => {
+    if (err?.code !== "EPIPE") {
+      for (let listener of origListeners)
+        listener(err);
+      origListeners.length === 0 && console.error("[LSP] Uncaught exception:", err);
+    }
+  });
+  let host = new LspRuntimeHost(), pendingProvider = null, latestCtx = null, projectConfig = null, sessionCwd = process.cwd(), withLatestCtx = (fn) => {
+    let ctx = latestCtx;
+    if (ctx)
+      try {
+        fn(ctx);
+      } catch (err) {
+        if (typeof err?.message == "string" && err.message.includes("stale after session")) {
+          latestCtx = null;
+          return;
+        }
+        throw err;
+      }
+  }, applyProvider = (data) => {
+    let provider = data;
+    pendingProvider = provider, host.setPendingProvider(provider);
+    let statusText = provider.getStatusText();
+    statusText && withLatestCtx((ctx) => {
+      ctx.ui?.theme && ctx.ui.setStatus("lsp", ctx.ui.theme.fg("accent", `LSP: ${statusText}`));
+    });
+  };
+  pi.events.on("lsp:register-workspace-provider", applyProvider);
+  let existing = pi.events["lsp:workspace-provider"];
+  existing && applyProvider(existing);
+  let setLspStatus = (color, text) => {
+    withLatestCtx((ctx) => {
+      ctx.ui?.theme && ctx.ui.setStatus("lsp", ctx.ui.theme.fg(color, text));
+    });
+  }, makeCallbacks = () => ({
+    onWorkspaceSetupStart: () => {
+      setLspStatus("warning", "LSP: workspace setup...");
+    },
+    onWorkspaceSetupEnd: (success, duration) => {
+      let secs = (duration / 1e3).toFixed(1);
+      success ? setLspStatus("accent", `LSP: workspace ready (${secs}s)`) : setLspStatus("warning", `LSP: workspace setup failed (${secs}s)`);
+    },
+    onServerStart: (languageId, command) => {
+      setLspStatus("warning", `LSP: starting ${languageId} (${command})...`);
+    },
+    onServerReady: (languageId) => {
+      setLspStatus("accent", `LSP: ${languageId} ready`);
+    },
+    onServerError: (languageId, _error) => {
+      setLspStatus("error", `LSP: ${languageId} failed`);
+    },
+    onServerCrash: (languageId, restarting, attempt) => {
+      restarting ? setLspStatus("warning", `LSP: restarting ${languageId}... (attempt ${attempt}/3)`) : setLspStatus("error", `LSP: ${languageId} crashed \u2014 auto-restart exhausted`);
+    }
+  }), applyProjectConfigToManager = (manager, config) => {
+    if (config) {
+      if (config.servers)
+        for (let [lang, serverConf] of Object.entries(config.servers))
+          manager.setServerConfig(lang, {
+            command: serverConf.command,
+            args: serverConf.args ?? [],
+            env: serverConf.env,
+            initializationOptions: serverConf.initializationOptions,
+            settings: serverConf.settings
+          });
+      config.lombokJar && config.lombokJar !== "auto" && manager.setLombokJar(config.lombokJar);
+    }
+  }, buildBindOptions = (cwd) => ({
+    cwd,
+    callbacks: makeCallbacks(),
+    pendingProvider,
+    syntheticDotChecker: (uri) => syntheticDotLocks.has(uri),
+    configureManager: (manager) => {
+      applyProjectConfigToManager(manager, projectConfig);
+    }
+  }), ensureRuntime = async () => host.ensureServices(buildBindOptions(sessionCwd || process.cwd()));
+  pi.on("session_start", async (_event, ctx) => {
+    latestCtx = ctx, sessionCwd = ctx.cwd, projectConfig = loadProjectConfig(ctx.cwd), host.bindSession(buildBindOptions(ctx.cwd));
+    let statusText = pendingProvider?.getStatusText?.() ?? "";
+    if (statusText ? ctx.ui.setStatus("lsp", ctx.ui.theme.fg("accent", `LSP: ${statusText}`)) : ctx.ui.setStatus("lsp", ctx.ui.theme.fg("dim", "LSP: idle")), projectConfig?.autoStart && projectConfig.autoStart.length > 0) {
+      let langs = projectConfig.autoStart, generation = host.getGeneration();
+      ensureRuntime().then((services) => {
+        if (host.getGeneration() !== generation)
+          return;
+        let lombokJar = services.manager.getLombokJar?.() ?? null, lombokNote = langs.includes("java") && lombokJar ? ` (lombok: ${String(lombokJar).split(/[/\\]/).pop()})` : "";
+        setLspStatus("warning", `LSP: auto-starting ${langs.join(", ")}${lombokNote}...`), services.manager.startEagerly(langs);
+      }).catch((error) => {
+        host.getGeneration() === generation && setLspStatus("error", `LSP startup failed: ${String(error)}`);
+      });
+    }
+  });
+  let managerProxy = createServiceProxy(() => host.getServicesIfReady()?.manager ?? null, "LSP manager"), treeSitterProxy = createServiceProxy(() => host.getServicesIfReady()?.treeSitter ?? null, "Tree-sitter manager"), workspaceIndexProxy = createServiceProxy(() => host.getServicesIfReady()?.workspaceIndex ?? null, "Workspace index");
+  registerToolWithRuntime(pi, createDiagnosticsTool(managerProxy, treeSitterProxy), ensureRuntime, host), registerToolWithRuntime(pi, createHoverTool(managerProxy, treeSitterProxy), ensureRuntime, host), registerToolWithRuntime(pi, createDefinitionTool(managerProxy, treeSitterProxy, workspaceIndexProxy), ensureRuntime, host), registerToolWithRuntime(pi, createReferencesTool(managerProxy, treeSitterProxy), ensureRuntime, host), registerToolWithRuntime(pi, createSymbolsTool(managerProxy, treeSitterProxy, workspaceIndexProxy), ensureRuntime, host), registerToolWithRuntime(pi, createRenameTool(managerProxy, treeSitterProxy), ensureRuntime, host), registerToolWithRuntime(pi, createCodeActionsTool(managerProxy, treeSitterProxy), ensureRuntime, host), registerToolWithRuntime(pi, createCompletionsTool(managerProxy, {
+    getTrackedVersion: (uri) => {
+      let services = host.getServicesIfReady();
+      return services ? services.fileSync.getTrackedVersion(uri) : null;
+    },
+    setTrackedVersion: (uri, v) => {
+      host.getServicesIfReady()?.fileSync.setTrackedVersion(uri, v);
+    },
+    isSyntheticDotActive: (uri) => syntheticDotLocks.has(uri)
+  }, treeSitterProxy), ensureRuntime, host);
+  let getRootDir = () => {
+    let manager = host.getServicesIfReady()?.manager;
+    return manager ? manager.resolvePath(".") : sessionCwd || process.cwd();
+  };
+  registerToolWithRuntime(pi, createCodeOverviewTool(getRootDir, treeSitterProxy, workspaceIndexProxy), ensureRuntime, host), registerToolWithRuntime(pi, createCodeSearchTool(getRootDir, treeSitterProxy), ensureRuntime, host), registerToolWithRuntime(pi, createCodeRewriteTool(getRootDir, treeSitterProxy, {
+    onFileModified: (filePath) => {
+      let services = host.getServicesIfReady();
+      services && services.fileSync.handleFileWrite(filePath).catch(() => {
+      });
+    }
+  }), ensureRuntime, host), pi.on("tool_result", async (event) => {
+    let generation = host.getGeneration();
+    try {
+      if (isReadToolResult(event) && !event.isError) {
+        let services2 = host.getServicesIfReady();
+        if (services2) {
+          let path = event.input?.path;
+          if (path && await services2.fileSync.handleFileRead(path), host.getGeneration() !== generation)
+            return;
+        }
+      }
+      if ((isWriteToolResult(event) || isEditToolResult(event)) && !event.isError) {
+        let path = event.input?.path;
+        if (path) {
+          let services2 = await ensureRuntime();
+          if (host.getGeneration() !== generation)
+            return;
+          await services2.fileSync.handleFileWrite(path);
+        }
+      }
+    } catch {
+    }
+    if (host.getGeneration() !== generation)
+      return;
+    let services = host.getServicesIfReady();
+    if ((isWriteToolResult(event) || isEditToolResult(event)) && !event.isError && services) {
+      let path = event.input?.path;
+      if (!path)
+        return;
+      let manager = services.manager, languageId = manager.getLanguageId(path);
+      if (!languageId)
+        return;
+      let inject = projectConfig?.autoInjectDiagnostics;
+      if (inject === !1 || Array.isArray(inject) && !inject.includes(languageId))
+        return;
+      let client = manager.getRunningClient(languageId);
+      if (!client || (await new Promise((r) => setTimeout(r, 1500)), host.getGeneration() !== generation))
+        return;
+      let uri = manager.getFileUri(path), errors = client.getDiagnostics(uri).filter((d) => d.severity === import_vscode_languageserver_protocol3.DiagnosticSeverity.Error);
+      if (errors.length === 0)
+        return;
+      let relPath = relative10(manager.resolvePath("."), manager.resolvePath(path)), lines = errors.slice(0, 10).map((d) => {
+        let line = d.range.start.line + 1, col = d.range.start.character + 1, source = d.source ? ` [${d.source}]` : "";
+        return `${relPath}:${line}:${col} error: ${d.message}${source}`;
+      });
+      errors.length > 10 && lines.push(`... and ${errors.length - 10} more error(s)`);
+      let summary = `
+
+\u26A0 LSP: ${errors.length} error(s) in ${relPath}:
+${lines.join(`
+`)}`;
+      return {
+        content: [
+          ...event.content,
+          { type: "text", text: summary }
+        ]
+      };
+    }
+  }), pi.on("tool_execution_end", async (_event, ctx) => {
+    latestCtx = ctx;
+    let services = host.getServicesIfReady();
+    if (!services)
+      return;
+    let running = services.manager.getStatus().filter((s) => s.running);
+    if (running.length === 0)
+      ctx.ui.setStatus("lsp", ctx.ui.theme.fg("dim", "LSP: idle"));
+    else {
+      let totalDiags = running.reduce((n, s) => n + s.diagnosticsCount, 0), status = `LSP: ${running.map((s) => s.languageId).join(", ")}`;
+      totalDiags > 0 && (status += ` (${totalDiags} diagnostic${totalDiags !== 1 ? "s" : ""})`), ctx.ui.setStatus("lsp", ctx.ui.theme.fg("accent", status));
+    }
+  }), pi.registerCommand("lsp", {
+    description: "Show LSP server status",
+    handler: async (_args, ctx) => {
+      let services = host.getServicesIfReady();
+      if (!services) {
+        ctx.ui.notify("LSP manager not initialized", "warning");
+        return;
+      }
+      let statuses = services.manager.getStatus();
+      if (statuses.length === 0) {
+        ctx.ui.notify("No LSP servers configured", "info");
+        return;
+      }
+      let lines = statuses.map((s) => {
+        let icon = s.running ? "\u{1F7E2}" : "\u26AA", diags = s.diagnosticsCount > 0 ? ` (${s.diagnosticsCount} diagnostics)` : "", shared = s.shared ? " [shared]" : "";
+        return `${icon} ${s.languageId}: ${s.command}${diags}${shared}`;
+      });
+      ctx.ui.notify(lines.join(`
+`), "info");
+    }
+  }), pi.registerCommand("lsp-restart", {
+    description: "Restart an LSP server: /lsp-restart <language> (e.g. java, typescript)",
+    handler: async (args, ctx) => {
+      let services = host.getServicesIfReady();
+      if (!services) {
+        ctx.ui.notify("LSP manager not initialized", "warning");
+        return;
+      }
+      let languageId = args?.trim().toLowerCase();
+      if (!languageId) {
+        let statuses = services.manager.getStatus().filter((s) => s.running);
+        if (statuses.length === 0)
+          ctx.ui.notify(`No LSP servers are running.
+
+Usage: /lsp-restart <language>`, "info");
+        else {
+          let langs = statuses.map((s) => s.languageId).join(", ");
+          ctx.ui.notify(`Running servers: ${langs}
+
+Usage: /lsp-restart <language>
+Example: /lsp-restart java`, "info");
+        }
+        return;
+      }
+      ctx.ui.setStatus("lsp", ctx.ui.theme.fg("warning", `LSP: restarting ${languageId}...`)), ctx.ui.notify(`Restarting ${languageId} server (kills daemon if shared)...`, "info");
+      try {
+        await services.manager.restartServer(languageId);
+        let lombokJar = languageId === "java" ? services.manager.getLombokJar() : null, lombokNote = lombokJar ? `
+Lombok: ${lombokJar}` : "";
+        ctx.ui.notify(`${languageId} server restarted successfully.${lombokNote}`, "info"), ctx.ui.setStatus("lsp", ctx.ui.theme.fg("accent", `LSP: ${languageId} ready`));
+      } catch (err) {
+        ctx.ui.notify(`Failed to restart ${languageId}: ${err.message}`, "error"), ctx.ui.setStatus("lsp", ctx.ui.theme.fg("error", `LSP: ${languageId} restart failed`));
+      }
+    }
+  }), pi.registerCommand("lsp-config", {
+    description: "Configure an LSP server: /lsp-config <language> <command> [args...]",
+    handler: async (args, ctx) => {
+      if (!args?.trim()) {
+        ctx.ui.notify(`Usage: /lsp-config <language> <command> [args...]
+Example: /lsp-config python pylsp`, "info");
+        return;
+      }
+      let parts = args.trim().split(/\s+/);
+      if (parts.length < 2) {
+        ctx.ui.notify("Usage: /lsp-config <language> <command> [args...]", "warning");
+        return;
+      }
+      let [languageId, command, ...serverArgs] = parts, config = { command, args: serverArgs };
+      (await ensureRuntime()).manager.setServerConfig(languageId, config), ctx.ui.notify(`Configured LSP for ${languageId}: ${command} ${serverArgs.join(" ")}`, "info");
+    }
+  }), pi.registerCommand("lsp-lombok", {
+    description: "Set Lombok jar path for Java: /lsp-lombok <path-to-lombok.jar>",
+    handler: async (args, ctx) => {
+      let mgr = (await ensureRuntime()).manager;
+      if (!args?.trim()) {
+        let current = mgr.getLombokJar();
+        current ? ctx.ui.notify(`Lombok jar: ${current}`, "info") : ctx.ui.notify(`No Lombok jar configured or detected.
+
+Usage: /lsp-lombok <path-to-lombok.jar>
+Or set LOMBOK_JAR environment variable.
+
+Download from: https://projectlombok.org/download`, "info");
+        return;
+      }
+      let jarPath = args.trim(), resolved = resolve3(ctx.cwd, jarPath);
+      if (!existsSync2(resolved)) {
+        ctx.ui.notify(`File not found: ${resolved}`, "error");
+        return;
+      }
+      resolved.endsWith(".jar") || ctx.ui.notify(`Warning: ${resolved} doesn't end in .jar \u2014 setting anyway`, "warning"), mgr.setLombokJar(resolved), ctx.ui.notify(`Lombok jar set: ${resolved}`, "info");
+    }
+  }), pi.on("session_shutdown", async () => {
+    latestCtx = null, await host.shutdown();
+  });
+}
+export {
+  LspRuntimeHost,
+  lspExtension as default
+};