@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.19-dev.10.1

package/dist/builtin-extensions/pi-lsp-extension/src/index.js

@@ -16,18 +16,18 @@
  * accept an optional `query` parameter as an alternative to line/character,
  * resolving a symbol name to its position automatically.
  *
+ * Tool schemas, commands, and hooks register immediately. Heavy managers
+ * (LspManager, FileSync, Tree-sitter/WASM, WorkspaceIndex) load on first use.
+ *
  * Usage:
  *   1. npm install in this directory
  *   2. Add to pi via settings.json extensions, or: pi -e ./src/index.ts
  *   3. LSP servers start lazily when you first use a tool on a file
  */
-import { isReadToolResult, isWriteToolResult, isEditToolResult, } from "@ashx-j/lunr-dev";
+import { awaitWithAbort } from "../../../utils/await-with-abort.js";
+import { isReadToolResult, isWriteToolResult, isEditToolResult, } from "../../../core/extensions/types.js";
 import { DiagnosticSeverity } from "vscode-languageserver-protocol";
-import { LspManager } from "./lsp-manager.js";
-import { FileSync } from "./file-sync.js";
-import { TreeSitterManager } from "./tree-sitter/parser-manager.js";
-import { WorkspaceIndex } from "./tree-sitter/workspace-index.js";
-import "./workspace-provider.js";
+import { LspRuntimeHost } from "./runtime.js";
 import { createDiagnosticsTool } from "./tools/diagnostics.js";
 import { createHoverTool } from "./tools/hover.js";
 import { createDefinitionTool } from "./tools/definition.js";
@@ -42,7 +42,7 @@ import { createCodeActionsTool } from "./tools/code-actions.js";
 import { syntheticDotLocks } from "./tools/completions.js";
 import { relative } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { DIAGNOSTIC_SETTLE_DELAY_MS } from "./shared/timing.js";
 /** Load .pi-lsp.json from a directory. Returns null if not found or invalid. */
 function loadProjectConfig(dir) {
@@ -60,6 +60,35 @@ function loadProjectConfig(dir) {
         return null;
     }
 }
+function createServiceProxy(getTarget, label) {
+    return new Proxy({}, {
+        get(_target, prop, receiver) {
+            const service = getTarget();
+            if (!service) {
+                throw new Error(`${label} is not initialized`);
+            }
+            const value = Reflect.get(service, prop, service);
+            if (typeof value === "function") {
+                return value.bind(service);
+            }
+            return value;
+        },
+    });
+}
+function registerToolWithRuntime(pi, tool, ensure, host) {
+    pi.registerTool({
+        ...tool,
+        async execute(id, params, signal, onUpdate, ctx) {
+            const generation = host.getGeneration();
+            signal?.throwIfAborted();
+            await awaitWithAbort(ensure(), signal);
+            signal?.throwIfAborted();
+            if (host.getGeneration() !== generation)
+                throw new Error("LSP session changed before execution");
+            return tool.execute(id, params, signal, onUpdate, ctx);
+        },
+    });
+}
 export default function lspExtension(pi) {
     // Prevent EPIPE errors from LSP server exits from crashing the host process.
     // When an LSP server exits unexpectedly, in-flight writes to its stdin pipe
@@ -75,15 +104,11 @@ export default function lspExtension(pi) {
             console.error("[LSP] Uncaught exception:", err);
         }
     });
-    let manager = null;
-    let fileSync = null;
-    let treeSitter = null;
-    let workspaceIndex = null;
+    const host = new LspRuntimeHost();
     let pendingProvider = null;
-    // Store latest ctx for lifecycle callbacks (updated on each event)
     let latestCtx = null;
-    // Project config — loaded on session_start, used by auto-injection guard
     let projectConfig = null;
+    let sessionCwd = process.cwd();
     /**
      * Run `fn` with the currently captured ctx, swallowing stale-ctx errors.
      *
@@ -109,16 +134,10 @@ export default function lspExtension(pi) {
             throw err;
         }
     };
-    // Listen for external workspace providers (e.g. bemol extension).
-    // Also check if one was already registered before we loaded (load order varies).
-    // Store as pendingProvider so it's available when the manager is created later.
     const applyProvider = (data) => {
         const provider = data;
         pendingProvider = provider;
-        if (manager) {
-            manager.setWorkspaceProvider(provider);
-        }
-        // Update status if we have a UI context
+        host.setPendingProvider(provider);
         const statusText = provider.getStatusText();
         if (!statusText)
             return;
@@ -133,7 +152,6 @@ export default function lspExtension(pi) {
     const existing = pi.events["lsp:workspace-provider"];
     if (existing)
         applyProvider(existing);
-    /** Build lifecycle callbacks that update UI status */
     const setLspStatus = (color, text) => {
         withLatestCtx((ctx) => {
             if (!ctx.ui?.theme)
@@ -172,165 +190,144 @@ export default function lspExtension(pi) {
             }
         },
     });
-    // Create manager eagerly so tools can reference it, but servers start lazily
-    const getManager = () => {
-        if (!manager) {
-            manager = new LspManager(process.cwd(), undefined, makeCallbacks(), undefined, pendingProvider ?? undefined);
-            fileSync = new FileSync(manager);
-            fileSync.setSyntheticDotChecker((uri) => syntheticDotLocks.has(uri));
-            treeSitter = new TreeSitterManager();
-            workspaceIndex = new WorkspaceIndex(process.cwd(), treeSitter);
-            fileSync.setTreeSitter(treeSitter, workspaceIndex);
-        }
-        return manager;
-    };
-    const getFileSync = () => {
-        if (!fileSync) {
-            getManager(); // ensures fileSync is created
+    const applyProjectConfigToManager = (manager, config) => {
+        if (!config)
+            return;
+        if (config.servers) {
+            for (const [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,
+                });
+            }
         }
-        return fileSync;
-    };
-    const getTreeSitter = () => {
-        if (!treeSitter) {
-            getManager(); // ensures treeSitter is created
+        if (config.lombokJar && config.lombokJar !== "auto") {
+            manager.setLombokJar(config.lombokJar);
         }
-        return treeSitter;
     };
-    const getWorkspaceIndex = () => {
-        if (!workspaceIndex) {
-            getManager(); // ensures workspaceIndex is created
-        }
-        return workspaceIndex;
+    const buildBindOptions = (cwd) => ({
+        cwd,
+        callbacks: makeCallbacks(),
+        pendingProvider,
+        syntheticDotChecker: (uri) => syntheticDotLocks.has(uri),
+        configureManager: (manager) => {
+            applyProjectConfigToManager(manager, projectConfig);
+        },
+    });
+    const ensureRuntime = async () => {
+        return host.ensureServices(buildBindOptions(sessionCwd || process.cwd()));
     };
-    // Initialize manager (uses cwd at session start time)
+    // session_start binds cwd/config only. Heavy managers load on first use,
+    // unless autoStart is configured (then ensure + startEagerly).
     pi.on("session_start", async (_event, ctx) => {
         latestCtx = ctx;
-        // If manager was already created eagerly (e.g. by a tool before session_start),
-        // shut it down so we can re-create with the correct ctx.cwd.
-        if (manager) {
-            await manager.shutdownAll().catch(() => { });
-            if (treeSitter)
-                treeSitter.shutdown();
-        }
-        manager = new LspManager(ctx.cwd, undefined, makeCallbacks(), undefined, pendingProvider ?? undefined);
-        fileSync = new FileSync(manager);
-        fileSync.setSyntheticDotChecker((uri) => syntheticDotLocks.has(uri));
-        treeSitter = new TreeSitterManager();
-        workspaceIndex = new WorkspaceIndex(ctx.cwd, treeSitter);
-        fileSync.setTreeSitter(treeSitter, workspaceIndex);
-        // Initialize tree-sitter in the background (don't block session start)
-        treeSitter.init().catch((err) => {
-            console.error(`[pi-lsp-extension] tree-sitter WASM init failed: ${err?.message ?? err}`);
-        });
-        // Show workspace provider status
-        const wsProvider = manager.workspace;
-        const statusText = wsProvider.getStatusText();
+        sessionCwd = ctx.cwd;
+        projectConfig = loadProjectConfig(ctx.cwd);
+        await host.bindSession(buildBindOptions(ctx.cwd));
+        const statusText = pendingProvider?.getStatusText?.() ?? "";
         if (statusText) {
             ctx.ui.setStatus("lsp", ctx.ui.theme.fg("accent", `LSP: ${statusText}`));
         }
         else {
             ctx.ui.setStatus("lsp", ctx.ui.theme.fg("dim", "LSP: idle"));
         }
-        // Load project config and apply settings
-        projectConfig = loadProjectConfig(ctx.cwd);
-        if (projectConfig) {
-            // Apply custom server configs
-            if (projectConfig.servers) {
-                for (const [lang, serverConf] of Object.entries(projectConfig.servers)) {
-                    manager.setServerConfig(lang, {
-                        command: serverConf.command,
-                        args: serverConf.args ?? [],
-                        env: serverConf.env,
-                        initializationOptions: serverConf.initializationOptions,
-                        settings: serverConf.settings,
-                    });
-                }
-            }
-            // Set Lombok jar path (explicit path or "auto" for auto-detection)
-            if (projectConfig.lombokJar) {
-                if (projectConfig.lombokJar !== "auto") {
-                    manager.setLombokJar(projectConfig.lombokJar);
-                }
-                // "auto" is the default behavior — findLombokJar() already auto-detects.
-                // Setting it explicitly just confirms the user wants Lombok support.
-            }
-            // Auto-start configured languages in the background
-            if (projectConfig.autoStart && projectConfig.autoStart.length > 0) {
-                const langs = projectConfig.autoStart;
-                const lombokNote = langs.includes("java") && manager.getLombokJar()
-                    ? ` (lombok: ${manager.getLombokJar()?.split("/").pop()})` : "";
+        if (projectConfig?.autoStart && projectConfig.autoStart.length > 0) {
+            const langs = projectConfig.autoStart;
+            const generation = host.getGeneration();
+            void ensureRuntime().then((services) => {
+                if (host.getGeneration() !== generation)
+                    return;
+                const lombokJar = services.manager.getLombokJar?.() ?? null;
+                const lombokNote = langs.includes("java") && lombokJar
+                    ? ` (lombok: ${String(lombokJar).split(/[/\\]/).pop()})`
+                    : "";
                 setLspStatus("warning", `LSP: auto-starting ${langs.join(", ")}${lombokNote}...`);
-                manager.startEagerly(langs);
-            }
+                services.manager.startEagerly(langs);
+            }).catch((error) => {
+                if (host.getGeneration() === generation)
+                    setLspStatus("error", `LSP startup failed: ${String(error)}`);
+            });
         }
     });
-    // Register all LSP tools
-    // Tools call getManager() lazily so they work even if session_start hasn't fired
-    const managerProxy = new Proxy({}, {
-        get(_target, prop) {
-            return getManager()[prop];
-        },
-    });
-    const treeSitterProxy = new Proxy({}, {
-        get(_target, prop) {
-            return getTreeSitter()[prop];
+    const managerProxy = createServiceProxy(() => host.getServicesIfReady()?.manager ?? null, "LSP manager");
+    const treeSitterProxy = createServiceProxy(() => host.getServicesIfReady()?.treeSitter ?? null, "Tree-sitter manager");
+    const 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) => {
+            const services = host.getServicesIfReady();
+            if (!services)
+                return null;
+            return services.fileSync.getTrackedVersion(uri);
         },
-    });
-    const workspaceIndexProxy = new Proxy({}, {
-        get(_target, prop) {
-            return getWorkspaceIndex()[prop];
+        setTrackedVersion: (uri, v) => {
+            host.getServicesIfReady()?.fileSync.setTrackedVersion(uri, v);
         },
-    });
-    pi.registerTool(createDiagnosticsTool(managerProxy, treeSitterProxy));
-    pi.registerTool(createHoverTool(managerProxy, treeSitterProxy));
-    pi.registerTool(createDefinitionTool(managerProxy, treeSitterProxy, workspaceIndexProxy));
-    pi.registerTool(createReferencesTool(managerProxy, treeSitterProxy));
-    pi.registerTool(createSymbolsTool(managerProxy, treeSitterProxy, workspaceIndexProxy));
-    pi.registerTool(createRenameTool(managerProxy, treeSitterProxy));
-    pi.registerTool(createCodeActionsTool(managerProxy, treeSitterProxy));
-    pi.registerTool(createCompletionsTool(managerProxy, {
-        getTrackedVersion: (uri) => getFileSync().getTrackedVersion(uri),
-        setTrackedVersion: (uri, v) => getFileSync().setTrackedVersion(uri, v),
         isSyntheticDotActive: (uri) => syntheticDotLocks.has(uri),
-    }, treeSitterProxy));
-    const getRootDir = () => manager?.resolvePath(".") ?? process.cwd();
-    pi.registerTool(createCodeOverviewTool(getRootDir, treeSitterProxy, workspaceIndexProxy));
-    pi.registerTool(createCodeSearchTool(getRootDir, treeSitterProxy));
-    pi.registerTool(createCodeRewriteTool(getRootDir, treeSitterProxy, {
+    }, treeSitterProxy), ensureRuntime, host);
+    const getRootDir = () => {
+        const manager = host.getServicesIfReady()?.manager;
+        if (manager)
+            return manager.resolvePath(".");
+        return 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) => {
-            getFileSync().handleFileWrite(filePath).catch(() => { });
+            const services = host.getServicesIfReady();
+            if (!services)
+                return;
+            services.fileSync.handleFileWrite(filePath).catch(() => { });
         },
-    }));
-    pi.registerTool(createCodeActionsTool(managerProxy, treeSitterProxy));
-    // File sync: track file reads/writes/edits
-    // After writes/edits, append file-scoped error diagnostics to the tool result
+    }), ensureRuntime, host);
+    // File sync: track file reads/writes/edits without loading runtime on plain reads
+    // when LSP was never used. Writes may start a server (existing behavior) so they
+    // ensure runtime. After writes/edits, append file-scoped error diagnostics.
     pi.on("tool_result", async (event) => {
-        const sync = getFileSync();
+        const generation = host.getGeneration();
         try {
             if (isReadToolResult(event) && !event.isError) {
-                const path = event.input?.path;
-                if (path)
-                    await sync.handleFileRead(path);
-            }
-            if (isWriteToolResult(event) && !event.isError) {
-                const path = event.input?.path;
-                if (path)
-                    await sync.handleFileWrite(path);
+                const services = host.getServicesIfReady();
+                if (services) {
+                    const path = event.input?.path;
+                    if (path)
+                        await services.fileSync.handleFileRead(path);
+                    if (host.getGeneration() !== generation)
+                        return;
+                }
             }
-            if (isEditToolResult(event) && !event.isError) {
+            if ((isWriteToolResult(event) || isEditToolResult(event)) && !event.isError) {
                 const path = event.input?.path;
-                if (path)
-                    await sync.handleFileWrite(path);
+                if (path) {
+                    const services = await ensureRuntime();
+                    if (host.getGeneration() !== generation)
+                        return;
+                    await services.fileSync.handleFileWrite(path);
+                }
             }
         }
         catch {
             // File sync errors are non-fatal
         }
+        if (host.getGeneration() !== generation)
+            return;
         // Auto-append diagnostics for the changed file (write/edit only)
-        if ((isWriteToolResult(event) || isEditToolResult(event)) && !event.isError && manager) {
+        const services = host.getServicesIfReady();
+        if ((isWriteToolResult(event) || isEditToolResult(event)) && !event.isError && services) {
             const path = event.input?.path;
             if (!path)
                 return;
+            const manager = services.manager;
             const languageId = manager.getLanguageId(path);
             if (!languageId)
                 return;
@@ -345,6 +342,8 @@ export default function lspExtension(pi) {
                 return;
             // Wait briefly for the LSP to publish updated diagnostics
             await new Promise((r) => setTimeout(r, DIAGNOSTIC_SETTLE_DELAY_MS));
+            if (host.getGeneration() !== generation)
+                return;
             const uri = manager.getFileUri(path);
             const diagnostics = client.getDiagnostics(uri);
             const errors = diagnostics.filter((d) => d.severity === DiagnosticSeverity.Error);
@@ -373,9 +372,10 @@ export default function lspExtension(pi) {
     // Update status after tool execution ends
     pi.on("tool_execution_end", async (_event, ctx) => {
         latestCtx = ctx;
-        if (!manager)
+        const services = host.getServicesIfReady();
+        if (!services)
             return;
-        const statuses = manager.getStatus();
+        const statuses = services.manager.getStatus();
         const running = statuses.filter((s) => s.running);
         if (running.length === 0) {
             ctx.ui.setStatus("lsp", ctx.ui.theme.fg("dim", "LSP: idle"));
@@ -394,11 +394,12 @@ export default function lspExtension(pi) {
     pi.registerCommand("lsp", {
         description: "Show LSP server status",
         handler: async (_args, ctx) => {
-            if (!manager) {
-                ctx.ui.notify("LSP manager not initialized", "warning");
+            const services = host.getServicesIfReady();
+            if (!services) {
+                ctx.ui.notify(host.isInitializing() ? "LSP runtime is starting" : "LSP runtime is idle (not started)", "info");
                 return;
             }
-            const statuses = manager.getStatus();
+            const statuses = services.manager.getStatus();
             if (statuses.length === 0) {
                 ctx.ui.notify("No LSP servers configured", "info");
                 return;
@@ -416,14 +417,22 @@ export default function lspExtension(pi) {
     pi.registerCommand("lsp-restart", {
         description: "Restart an LSP server: /lsp-restart <language> (e.g. java, typescript)",
         handler: async (args, ctx) => {
-            if (!manager) {
-                ctx.ui.notify("LSP manager not initialized", "warning");
+            const services = host.getServicesIfReady();
+            if (!services) {
+                if (args?.trim()) {
+                    ctx.ui.notify(host.isInitializing()
+                        ? "LSP runtime is starting"
+                        : "LSP runtime is idle. Run an LSP tool before restarting a server.", "info");
+                }
+                else {
+                    ctx.ui.notify("No LSP servers are running.\n\nUsage: /lsp-restart <language>", "info");
+                }
                 return;
             }
             const languageId = args?.trim().toLowerCase();
             if (!languageId) {
                 // Show running servers and usage
-                const statuses = manager.getStatus().filter((s) => s.running);
+                const statuses = services.manager.getStatus().filter((s) => s.running);
                 if (statuses.length === 0) {
                     ctx.ui.notify("No LSP servers are running.\n\nUsage: /lsp-restart <language>", "info");
                 }
@@ -436,8 +445,8 @@ export default function lspExtension(pi) {
             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 manager.restartServer(languageId);
-                const lombokJar = languageId === "java" ? manager.getLombokJar() : null;
+                await services.manager.restartServer(languageId);
+                const lombokJar = languageId === "java" ? services.manager.getLombokJar() : null;
                 const lombokNote = lombokJar ? `\nLombok: ${lombokJar}` : "";
                 ctx.ui.notify(`${languageId} server restarted successfully.${lombokNote}`, "info");
                 ctx.ui.setStatus("lsp", ctx.ui.theme.fg("accent", `LSP: ${languageId} ready`));
@@ -463,7 +472,8 @@ export default function lspExtension(pi) {
             }
             const [languageId, command, ...serverArgs] = parts;
             const config = { command, args: serverArgs };
-            getManager().setServerConfig(languageId, config);
+            const services = await ensureRuntime();
+            services.manager.setServerConfig(languageId, config);
             ctx.ui.notify(`Configured LSP for ${languageId}: ${command} ${serverArgs.join(" ")}`, "info");
         },
     });
@@ -471,7 +481,8 @@ export default function lspExtension(pi) {
     pi.registerCommand("lsp-lombok", {
         description: "Set Lombok jar path for Java: /lsp-lombok <path-to-lombok.jar>",
         handler: async (args, ctx) => {
-            const mgr = getManager();
+            const services = await ensureRuntime();
+            const mgr = services.manager;
             if (!args?.trim()) {
                 const current = mgr.getLombokJar();
                 if (current) {
@@ -486,8 +497,6 @@ export default function lspExtension(pi) {
                 return;
             }
             const jarPath = args.trim();
-            const { existsSync } = await import("node:fs");
-            const { resolve } = await import("node:path");
             const resolved = resolve(ctx.cwd, jarPath);
             if (!existsSync(resolved)) {
                 ctx.ui.notify(`File not found: ${resolved}`, "error");
@@ -500,22 +509,14 @@ export default function lspExtension(pi) {
             ctx.ui.notify(`Lombok jar set: ${resolved}`, "info");
         },
     });
-    // Clean shutdown (includes workspace provider, all LSP servers, and tree-sitter)
+    // Clean shutdown — never loads heavy modules if they were unused
     pi.on("session_shutdown", async () => {
         // Drop the captured ctx immediately — once shutdown fires, any late
         // LSP manager callback that reaches setLspStatus/applyProvider would
         // otherwise hit an invalidated ctx and throw an uncaught exception.
         latestCtx = null;
-        if (manager) {
-            await manager.shutdownAll();
-            manager = null;
-            fileSync = null;
-        }
-        if (treeSitter) {
-            treeSitter.shutdown();
-            treeSitter = null;
-        }
-        workspaceIndex = null;
+        await host.shutdown();
     });
 }
+export { LspRuntimeHost } from "./runtime.js";
 //# sourceMappingURL=index.js.map