@mrclrchtr/supi-lsp 11.1.0 → 11.3.0

package/src/session/runtime-registry.ts

@@ -139,6 +139,8 @@ function recordScopeDecisionEvent(manager: LspManager): void {
   }
 }
 
+const FILE_STARTUP_FAILURE_REASON = "The routed LSP client could not be started for this file";
+
 class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
   constructor(private readonly manager: LspManager) {}
 
@@ -157,6 +159,7 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     const resolvedPath = this.resolveFilePath(filePath);
     const client = await this.manager.ensureFileOpen(resolvedPath, {
       recoverProcessCrash: true,
+      protectInputs: true,
       control,
     });
     if (!client) return unavailableFileQuery("hover", resolvedPath);
@@ -171,6 +174,7 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     const resolvedPath = this.resolveFilePath(filePath);
     const client = await this.manager.ensureFileOpen(resolvedPath, {
       recoverProcessCrash: true,
+      protectInputs: true,
       control,
     });
     if (!client) return unavailableFileQuery("definition", resolvedPath);
@@ -185,6 +189,7 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     const resolvedPath = this.resolveFilePath(filePath);
     const client = await this.manager.ensureFileOpen(resolvedPath, {
       recoverProcessCrash: true,
+      protectInputs: true,
       control,
     });
     if (!client) return unavailableFileQuery("references", resolvedPath);
@@ -202,6 +207,7 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     const resolvedPath = this.resolveFilePath(filePath);
     const client = await this.manager.ensureFileOpen(resolvedPath, {
       recoverProcessCrash: true,
+      protectInputs: true,
       control,
     });
     if (!client) return unavailableFileQuery("implementation", resolvedPath);
@@ -215,6 +221,7 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     const resolvedPath = this.resolveFilePath(filePath);
     const client = await this.manager.ensureFileOpen(resolvedPath, {
       recoverProcessCrash: true,
+      protectInputs: true,
       control,
     });
     if (!client) return unavailableFileQuery("document symbols", resolvedPath);
@@ -260,6 +267,7 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     const resolvedPath = this.resolveFilePath(filePath);
     const client = await this.manager.ensureFileOpen(resolvedPath, {
       recoverProcessCrash: true,
+      protectInputs: true,
       control,
     });
     if (!client) return null;
@@ -309,7 +317,7 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
       const processCrashRecovery = this.manager.getProcessCrashRecoveryReportForFile(resolvedPath);
       return {
         kind: "unavailable",
-        reason: "No LSP client can serve this file",
+        reason: this.fileUnavailableReason(resolvedPath, "No LSP client can serve this file"),
         ...(processCrashRecovery ? { processCrashRecovery } : {}),
       };
     }
@@ -347,7 +355,7 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     if (!client) {
       return {
         kind: "unavailable",
-        reason: "The routed LSP client could not be started for this file",
+        reason: this.fileUnavailableReason(resolvedPath, FILE_STARTUP_FAILURE_REASON),
         ...startup,
         ...recovery,
       };
@@ -355,6 +363,15 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     return { kind: "ready", ...startup, ...recovery };
   }
 
+  private fileUnavailableReason(filePath: string, configuredRouteReason: string): string {
+    if (!this.manager.hasConfiguredServerForFile(filePath)) {
+      return "No compatible LSP server is configured for this file";
+    }
+    return this.manager.hasFailedStartupForFile(filePath)
+      ? FILE_STARTUP_FAILURE_REASON
+      : configuredRouteReason;
+  }
+
   /**
    * Wait until all started LSP clients are ready for semantic queries.
    * Performs one representative warm-up probe per client/root.

package/src/session/runtime-rename.ts

@@ -21,6 +21,7 @@ export async function runRoutedRename(options: {
   const { manager, file, position, newName, control } = options;
   const client = await manager.ensureFileOpen(file, {
     recoverProcessCrash: true,
+    protectInputs: true,
     control,
   });
   if (!client) return null;

package/src/session/scanner.ts

@@ -7,6 +7,7 @@ import type {
   MissingServer,
   ServerConfig,
 } from "../config/types.ts";
+import { inspectTypeScriptLaunch } from "../config/typescript-launch.ts";
 import type { LspManager } from "../manager/manager.ts";
 import { commandExists } from "../utils.ts";
 import {
@@ -32,20 +33,16 @@ export function scanProjectCapabilities(
 
   return Object.entries(config.servers)
     .flatMap(([serverName, server]) => {
-      if (!commandExists(server.command)) return [];
       const allRoots = new Set(markerMatches.get(serverName) ?? []);
       if (extensionBasedServers.has(serverName)) {
         allRoots.add(cwd);
       }
       const roots = dedupeTopmostRoots(Array.from(allRoots));
-      return roots.map(
-        (root) =>
-          ({
-            name: serverName,
-            root,
-            fileTypes: [...server.fileTypes],
-          }) satisfies DetectedProjectServer,
-      );
+      return roots.flatMap((root) => {
+        const { command, ...selection } = inspectTypeScriptLaunch(serverName, server, root);
+        if (!selection.failureMessage && !commandExists(command)) return [];
+        return [{ name: serverName, root, fileTypes: [...server.fileTypes], ...selection }];
+      });
     })
     .sort((a, b) => a.root.localeCompare(b.root) || a.name.localeCompare(b.name));
 }
@@ -79,8 +76,6 @@ function inspectDirectory(
   ctx: HintContext,
 ): void {
   for (const [serverName, server] of Object.entries(servers)) {
-    if (!commandExists(server.command)) continue;
-
     if (server.rootMarkers.length === 0) {
       if (hasMatchingFile(directory, entryNames, server.fileTypes)) {
         ctx.extensionBasedServers.add(serverName);
@@ -122,7 +117,7 @@ export async function startDetectedServers(
 
 /**
  * Scan the project for languages whose source files exist but whose LSP server
- * binary is not installed on PATH. Walks the project directory tree collecting
+ * executable or selected compiler is unavailable. Walks the project tree collecting
  * file extensions, then checks each configured server.
  */
 export function scanMissingServers(
@@ -142,14 +137,31 @@ export function scanMissingServers(
   });
 
   const missing: MissingServer[] = [];
+  const { markerMatches } = collectServerHints(config, cwd, maxDepth, policy);
 
   for (const [name, server] of Object.entries(config.servers)) {
-    if (commandExists(server.command)) continue;
-
     const matching = server.fileTypes.filter((ft) => foundExtensions.has(ft));
     if (matching.length === 0) continue;
 
-    missing.push({ name, command: server.command, foundExtensions: matching });
+    const roots = dedupeTopmostRoots(Array.from(markerMatches.get(name) ?? []));
+    for (const root of roots.length ? roots : [cwd]) {
+      const selection = inspectTypeScriptLaunch(name, server, root);
+      const command = selection.command;
+      if (selection.failureMessage) {
+        missing.push({
+          name,
+          command,
+          foundExtensions: matching,
+          root,
+          failureMessage: selection.failureMessage,
+        });
+        continue;
+      }
+      if (!commandExists(command)) {
+        missing.push({ name, command, foundExtensions: matching });
+        break;
+      }
+    }
   }
 
   return missing;

package/src/session/workspace-lsp-runtime.ts

@@ -143,7 +143,11 @@ export interface WorkspaceLspRuntime extends WorkspaceLspDiagnosticSurface {
     filePath: string,
     control?: CodeRequestControl,
   ): Promise<CodeQueryResult<DocumentSymbol[] | SymbolInformation[]>>;
-  /** Collect symbols from routes that can contribute within the optional path scopes. */
+  /**
+   * Collect symbols from contributing routes; completeness is relative to scopes.
+   * Data may include out-of-scope rows, which callers must filter themselves.
+   * Only policy exclusions proven outside every scope are irrelevant to completeness.
+   */
   workspaceSymbol(
     query: string,
     control?: CodeRequestControl,