@mrclrchtr/supi-lsp 11.1.0 → 11.3.0

package/src/client/client.ts

@@ -51,6 +51,7 @@ import type {
   WorkspaceEdit,
   WorkspaceSymbol,
 } from "../config/types.ts";
+import { resolveTypeScriptLaunch, type TypeScriptLaunch } from "../config/typescript-launch.ts";
 import { boundCwd } from "../debug-telemetry.ts";
 import type { DiagnosticEvidenceSummary } from "../diagnostics/evidence.ts";
 import { raceRequestControl } from "../session/readiness.ts";
@@ -79,6 +80,11 @@ import type {
   SemanticInputSnapshot,
 } from "./client-semantic-input-barrier.ts";
 import { SemanticInputSynchronizationError } from "./client-semantic-input-errors.ts";
+import {
+  type ProjectMembership,
+  readTypeScriptProjectMembership,
+  typeScriptProjectInfoParams,
+} from "./client-typescript-project.ts";
 import { JsonRpcClient, JsonRpcRequestError } from "./transport.ts";
 
 const SHUTDOWN_TIMEOUT_MS = 5_000;
@@ -88,6 +94,12 @@ const CONTENT_MODIFIED_RETRY_DELAY_MS = 100;
 
 /** Bounded stderr tail kept for startup-failure error messages. */
 const STDERR_TAIL_MAX_CHARS = 4_000;
+/**
+ * Bound for draining a failed startup's stdio. An initialize write can fail
+ * (`EPIPE`) before the exiting server's stderr is read; waiting for `close`
+ * lets the failure report the server's own reason instead of the transport error.
+ */
+const STARTUP_FAILURE_DRAIN_MS = 500;
 
 interface SemanticRequestAttemptState {
   inputRevision: number | undefined;
@@ -491,6 +503,20 @@ function killFailedStartupProcess(child: ChildProcess): void {
   child.kill();
 }
 
+/** Resolve once `closed()` holds or the child emits `close`, bounded by `ms`. */
+function waitForStdioClose(child: ChildProcess, closed: () => boolean, ms: number): Promise<void> {
+  if (closed()) return Promise.resolve();
+  return new Promise((resolve) => {
+    const done = () => {
+      clearTimeout(timer);
+      child.off("close", done);
+      resolve();
+    };
+    const timer = setTimeout(done, ms);
+    child.once("close", done);
+  });
+}
+
 // ── Types ─────────────────────────────────────────────────────────────
 export type ClientStatus = "initializing" | "running" | "error" | "shutdown";
 
@@ -591,6 +617,13 @@ export class LspClient {
     });
   }
 
+  private launchSelection: TypeScriptLaunch | undefined;
+
+  /** Compiler used by this generation, never re-probed while it is healthy. */
+  get typescriptSelection() {
+    return this.launchSelection?.typescript;
+  }
+
   get status(): ClientStatus {
     return this._status;
   }
@@ -670,8 +703,14 @@ export class LspClient {
   // ── Lifecycle ───────────────────────────────────────────────────────
   /** Spawn the server process and perform the initialize handshake. */
   async start(): Promise<void> {
-    const cmd = this.config.command;
-    const args = this.config.args ?? [];
+    try {
+      this.launchSelection = resolveTypeScriptLaunch(this.name, this.config, this.root);
+    } catch (error) {
+      this.handleProcessFailure(error instanceof Error ? error : new Error(String(error)));
+      throw error;
+    }
+    const { command: cmd = this.config.command, args = this.config.args ?? [] } =
+      this.launchSelection;
     this.startedAt = Date.now();
 
     try {
@@ -712,19 +751,24 @@ export class LspClient {
     });
     this.rpc.onRequest((method, params) => this.handleServerRequest(method, params));
 
-    // Handle crashes
+    // Handle crashes. A failing initialize reports its own detailed failure.
+    let reportingStartupFailure = false;
     this.process.on("exit", (_code) => {
-      this.handleProcessFailure(new Error("Client crashed"));
+      if (!reportingStartupFailure) this.handleProcessFailure(new Error("Client crashed"));
     });
 
     this.process.on("error", (_err) => {
-      this.handleProcessFailure(new Error("Client process error"));
+      if (!reportingStartupFailure) this.handleProcessFailure(new Error("Client process error"));
     });
 
     // Capture a bounded stderr tail (discarded otherwise) so startup
     // failures can surface the server's own exit reason — expired builds,
     // missing runtimes, or invalid flags. Stderr never reaches the agent.
     let stderrTail = "";
+    let stdioClosed = false;
+    this.process.once("close", () => {
+      stdioClosed = true;
+    });
     this.process.stderr?.on("data", (chunk: Buffer | string) => {
       stderrTail = `${stderrTail}${chunk}`.slice(-STDERR_TAIL_MAX_CHARS);
     });
@@ -741,7 +785,7 @@ export class LspClient {
           },
         ],
         capabilities: CLIENT_CAPABILITIES,
-        initializationOptions: this.config.initializationOptions,
+        initializationOptions: this.launchSelection.initializationOptions,
       })) as InitializeResult;
 
       const positionEncoding = result.capabilities.positionEncoding ?? "utf-16";
@@ -763,12 +807,16 @@ export class LspClient {
 
       this.armNoProgressTimer();
     } catch (err) {
+      const child = this.process;
+      reportingStartupFailure = true;
+      killFailedStartupProcess(child);
+      // Let already-written stderr drain before reporting the failure.
+      await waitForStdioClose(child, () => stdioClosed, STARTUP_FAILURE_DRAIN_MS);
       const stderrDetail = stderrTail.trim() ? `\n${this.name} stderr:\n${stderrTail.trim()}` : "";
       const failure = new Error(`${this.name}: initialize failed: ${err}${stderrDetail}`, {
         cause: err,
       });
       this.handleProcessFailure(failure);
-      killFailedStartupProcess(this.process);
       throw failure;
     }
   }
@@ -865,6 +913,33 @@ export class LspClient {
   }
 
   // ── Document Synchronization and Diagnostics ────────────────────────
+  /**
+   * Admit a first open between semantic attempts, reading content after the wait.
+   * Semantic/refactor callers protect their original inputs; ordinary tracking
+   * can adopt fresh content after a known change instead.
+   */
+  async openDocument(
+    filePath: string,
+    readContent: () => string,
+    control?: CodeRequestControl,
+    protectInputs = false,
+  ): Promise<void> {
+    const trackedCount = this.openFiles.length;
+    await this.diagnostics.openDocument(filePath, readContent, control, protectInputs);
+    this.publishTrackedFileChange(trackedCount);
+  }
+
+  /** Restore retained state without resurrecting a closed or replaced document. */
+  async restoreDocument(
+    filePath: string,
+    readContent: () => string,
+    isCurrent: () => boolean,
+  ): Promise<void> {
+    const trackedCount = this.openFiles.length;
+    await this.diagnostics.restoreDocument(filePath, readContent, isCurrent);
+    this.publishTrackedFileChange(trackedCount);
+  }
+
   /** Open a document, or update it when it is already open. */
   didOpen(filePath: string, content: string): void {
     const trackedCount = this.openFiles.length;
@@ -1147,6 +1222,23 @@ export class LspClient {
     );
   }
 
+  /**
+   * Report whether the server placed an open file in a configured project.
+   * Only the TypeScript route can answer; other routes return `unknown`.
+   */
+  async projectMembership(
+    filePath: string,
+    control?: CodeRequestControl,
+  ): Promise<ProjectMembership> {
+    if (!this.hasTypeScriptRequestCommand()) return "unknown";
+    const result = await this.query<unknown>(
+      "workspace/executeCommand",
+      typeScriptProjectInfoParams(fileToUri(filePath)),
+      control,
+    );
+    return result.kind === "completed" ? readTypeScriptProjectMembership(result.data) : "unknown";
+  }
+
   async workspaceSymbol(
     query: string,
     control?: CodeRequestControl,
@@ -1244,6 +1336,7 @@ export class LspClient {
           | undefined;
       },
       {
+        documentUri: params.textDocument.uri,
         inputRevision: options.inputRevision,
         onVerifiedSnapshot: (snapshot) => {
           inputRevision = snapshot.revision;
@@ -1273,8 +1366,10 @@ export class LspClient {
     context: CodeActionContext,
     control?: CodeRequestControl,
   ): Promise<CodeQueryResult<CodeAction[] | null>> {
+    const backend = this.typescriptSelection?.backend;
+    const server = `LSP server "${this.name}"${backend ? ` (${backend} backend)` : ""}`;
     if (!this.supportsCodeActions) {
-      return unavailableCodeQuery("The server does not advertise textDocument/codeAction.");
+      return unavailableCodeQuery(`${server} does not advertise textDocument/codeAction.`);
     }
     if (typeof filePath !== "string" || filePath.length === 0 || !isRange(range)) {
       return unavailableCodeQuery("Code actions require a valid file and range.");
@@ -1283,7 +1378,9 @@ export class LspClient {
       return unavailableCodeQuery("Code actions require a valid context.");
     }
     if (context.only && !this.supportsCodeActionKinds(context.only)) {
-      return unavailableCodeQuery("The server does not advertise the requested code-action kind.");
+      return unavailableCodeQuery(
+        `${server} does not advertise the requested code-action kind: ${context.only.join(", ")}.`,
+      );
     }
 
     const requestContext: CodeActionContext = {
@@ -1291,17 +1388,22 @@ export class LspClient {
       triggerKind: context.triggerKind ?? CodeActionTriggerKind.Invoked,
       ...(context.only ? { only: [...context.only] } : {}),
     };
-    return this.runRefactorTransaction("textDocument/codeAction", control, async (transaction) => {
-      const raw = await transaction.rpc.sendRequest(
-        "textDocument/codeAction",
-        { textDocument: { uri: fileToUri(filePath) }, range, context: requestContext },
-        control,
-      );
-      if (raw === null || raw === undefined) return null;
-      if (!Array.isArray(raw)) throw new Error("LSP server returned malformed code actions.");
+    return this.runRefactorTransaction(
+      "textDocument/codeAction",
+      control,
+      async (transaction) => {
+        const raw = await transaction.rpc.sendRequest(
+          "textDocument/codeAction",
+          { textDocument: { uri: fileToUri(filePath) }, range, context: requestContext },
+          control,
+        );
+        if (raw === null || raw === undefined) return null;
+        if (!Array.isArray(raw)) throw new Error("LSP server returned malformed code actions.");
 
-      return this.resolveCodeActions(raw, transaction, control, requestContext.only);
-    });
+        return this.resolveCodeActions(raw, transaction, control, requestContext.only);
+      },
+      { documentUri: fileToUri(filePath) },
+    );
   }
 
   async implementation(
@@ -1366,9 +1468,10 @@ export class LspClient {
     control: CodeRequestControl | undefined,
     operation: (transaction: RefactorTransaction) => Promise<T | null | undefined>,
     options: {
+      readonly documentUri: string;
       readonly onVerifiedSnapshot?: (snapshot: SemanticInputSnapshot) => void;
       readonly inputRevision?: number;
-    } = {},
+    },
   ): Promise<CodeQueryResult<T | null>> {
     throwIfCodeRequestInterrupted(control);
     if (!this.rpc || this._status !== "running") {
@@ -1387,6 +1490,7 @@ export class LspClient {
         retryGuard.assertCurrent();
         const data = await this.runRefactorTransactionAttempt({
           method,
+          documentUri: options.documentUri,
           control,
           operation,
           retryGuard,
@@ -1428,9 +1532,10 @@ export class LspClient {
     }
   }
 
-  /** Run the complete prepare/request/resolve transaction for one input snapshot. */
+  /** Admit one prepare/request/resolve attempt, not retries or rename's own enrollment. */
   private async runRefactorTransactionAttempt<T>(options: {
     method: string;
+    documentUri: string;
     control?: CodeRequestControl;
     operation: (transaction: RefactorTransaction) => Promise<T | null | undefined>;
     retryGuard: SemanticInputRequestRetryGuard;
@@ -1441,27 +1546,36 @@ export class LspClient {
     throwIfCodeRequestInterrupted(control);
     retryGuard.assertCurrent();
     await this.getReady(control);
-    const inputSnapshot = await this.diagnostics.synchronizeSemanticInputs(control);
-    attempt.inputRevision = inputSnapshot.revision;
-    throwIfCodeRequestInterrupted(control);
-    retryGuard.assertCurrent();
-    const rpc = this.rpc;
-    if (!rpc || this._status !== "running") {
-      throw new Error(`LSP request ${method} is unavailable because the client is not running.`);
-    }
-    const data = await operation({
-      rpc,
-      assertCurrent: async () => {
+    return this.diagnostics.withSemanticRequest(
+      async () => {
         retryGuard.assertCurrent();
-        return this.diagnostics.assertSemanticInputsCurrent(inputSnapshot, control);
+        const inputSnapshot = await this.diagnostics.synchronizeSemanticInputs(control);
+        attempt.inputRevision = inputSnapshot.revision;
+        throwIfCodeRequestInterrupted(control);
+        retryGuard.assertCurrent();
+        const rpc = this.rpc;
+        if (!rpc || this._status !== "running") {
+          throw new Error(
+            `LSP request ${method} is unavailable because the client is not running.`,
+          );
+        }
+        const data = await operation({
+          rpc,
+          assertCurrent: async () => {
+            retryGuard.assertCurrent();
+            return this.diagnostics.assertSemanticInputsCurrent(inputSnapshot, control);
+          },
+        });
+        const verifiedSnapshot = await this.diagnostics.assertSemanticInputsCurrent(
+          inputSnapshot,
+          control,
+        );
+        onVerifiedSnapshot?.(verifiedSnapshot);
+        return data ?? null;
       },
-    });
-    const verifiedSnapshot = await this.diagnostics.assertSemanticInputsCurrent(
-      inputSnapshot,
       control,
+      options.documentUri,
     );
-    onVerifiedSnapshot?.(verifiedSnapshot);
-    return data ?? null;
   }
 
   private async query<T>(
@@ -1633,17 +1747,28 @@ export class LspClient {
     throwIfCodeRequestInterrupted(control);
     retryGuard.assertCurrent();
     await this.getReady(control);
-    const inputSnapshot = await this.diagnostics.synchronizeSemanticInputs(control);
-    attempt.inputRevision = inputSnapshot.revision;
-    throwIfCodeRequestInterrupted(control);
-    retryGuard.assertCurrent();
-    const rpc = this.rpc;
-    if (!rpc || this._status !== "running") {
-      throw new Error(`LSP request ${method} is unavailable because the client is not running.`);
-    }
-    const data = (await rpc.sendRequest(method, params, control)) as T | null | undefined;
-    await this.diagnostics.assertSemanticInputsCurrent(inputSnapshot, control);
-    return data ?? null;
+    // Local query methods construct the standard TextDocumentIdentifier envelope.
+    const documentUri = (params as { textDocument?: { uri: string } } | null)?.textDocument?.uri;
+    return this.diagnostics.withSemanticRequest(
+      async () => {
+        retryGuard.assertCurrent();
+        const inputSnapshot = await this.diagnostics.synchronizeSemanticInputs(control);
+        attempt.inputRevision = inputSnapshot.revision;
+        throwIfCodeRequestInterrupted(control);
+        retryGuard.assertCurrent();
+        const rpc = this.rpc;
+        if (!rpc || this._status !== "running") {
+          throw new Error(
+            `LSP request ${method} is unavailable because the client is not running.`,
+          );
+        }
+        const data = (await rpc.sendRequest(method, params, control)) as T | null | undefined;
+        await this.diagnostics.assertSemanticInputsCurrent(inputSnapshot, control);
+        return data ?? null;
+      },
+      control,
+      documentUri,
+    );
   }
 
   private handleServerRequest(method: string, params: unknown): unknown {

package/src/config/config.ts

@@ -3,10 +3,16 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import { loadSupiConfigForScope, loadSupiConfigSectionForScope } from "@mrclrchtr/supi-core/config";
+import {
+  getSupiConfigPath,
+  loadSupiConfigForScope,
+  loadSupiConfigSectionForScope,
+} from "@mrclrchtr/supi-core/config";
 import { truncateDebugIdentity } from "@mrclrchtr/supi-core/debug";
 import type { JsonObject, JsonValue, LspConfig, ServerConfig } from "./types.ts";
 
+import { isManualTypeScriptLaunch, isTypeScriptPackageName } from "./typescript-launch.ts";
+
 const CONFIG_DIR = path.dirname(fileURLToPath(import.meta.url));
 
 // Load defaults at module level — resolve relative to this file.
@@ -65,11 +71,47 @@ export function loadConfig(cwd: string, options?: LoadConfigOptions): LspConfig
           { scope: "project" },
         );
 
+  const fields: NonNullable<ServerConfig["typescriptExplicitFields"]> = {};
+  for (const [scope, servers] of [
+    ["global", globalLsp.servers],
+    ["project", projectLsp.servers],
+  ] as const) {
+    captureTypeScriptOrigins(fields, servers?.typescript, getSupiConfigPath(scope, cwd, options));
+  }
   const merged = mergeServerConfigs(defaults.servers, globalLsp.servers, projectLsp.servers);
-
+  if (merged.typescript) {
+    merged.typescript = { ...merged.typescript, typescriptExplicitFields: fields };
+    isManualTypeScriptLaunch(merged.typescript, cwd);
+  }
   return { servers: merged };
 }
 
+/** Retain only effective explicit launch fields; initializationOptions replaces its inherited object. */
+function captureTypeScriptOrigins(
+  fields: NonNullable<ServerConfig["typescriptExplicitFields"]>,
+  value: unknown,
+  origin: string,
+): void {
+  if (!isRecord(value)) return;
+  if (
+    Object.hasOwn(value, "typescriptPackage") &&
+    !isTypeScriptPackageName(value.typescriptPackage)
+  ) {
+    throw new Error(
+      `Invalid lsp.servers.typescript.typescriptPackage in ${origin}: use an installed package name or alias, not a path.`,
+    );
+  }
+  const { override } = validateServerOverride(value);
+  for (const field of ["command", "args", "typescriptPackage"] as const) {
+    if (Object.hasOwn(override, field)) fields[field] = origin;
+  }
+  if (!Object.hasOwn(override, "initializationOptions")) return;
+  delete fields.tsserverPath;
+  const init = override.initializationOptions;
+  if (isRecord(init) && isRecord(init.tsserver) && Object.hasOwn(init.tsserver, "path"))
+    fields.tsserverPath = origin;
+}
+
 /**
  * Read effective explicit language disablement for the active LSP snapshot.
  * Project values override global values, including an explicit re-enable.
@@ -205,6 +247,10 @@ function mergeSingleServer(options: {
 }): ServerConfig | null {
   const { name, base, value, builtIn, reportWarning } = options;
   const { override, invalidFields } = validateServerOverride(value);
+  if (name !== "typescript" && override.typescriptPackage !== undefined) {
+    delete override.typescriptPackage;
+    invalidFields.push("typescriptPackage");
+  }
   const missingFields = base
     ? []
     : [
@@ -232,6 +278,11 @@ function mergeSingleServer(options: {
 type ServerOverrideSetter = (override: Partial<ServerConfig>, candidate: unknown) => boolean;
 
 const SERVER_OVERRIDE_SETTERS: Record<string, ServerOverrideSetter> = {
+  typescriptPackage(override, candidate) {
+    if (!isTypeScriptPackageName(candidate)) return false;
+    override.typescriptPackage = candidate;
+    return true;
+  },
   command(override, candidate) {
     if (typeof candidate !== "string" || candidate.trim().length === 0) return false;
     override.command = candidate;

package/src/config/operation-support.ts

@@ -26,12 +26,15 @@ export type ServerOperationSupportMap = Partial<
   Record<ServerOperationName, ServerOperationSupport>
 >;
 
+const REMOVE_UNUSED_KIND = "source.removeUnused";
+const REMOVE_UNUSED_IMPORTS_KIND = "source.removeUnusedImports";
+
 /** Code-action kinds requested by each operation-specific planner. */
 export const REFACTOR_CODE_ACTION_KINDS = {
   extract_function: ["refactor.extract.function"],
   extract_variable: ["refactor.extract.constant", "refactor.extract.variable"],
   update_imports: ["source.organizeImports"],
-  delete_dead_code: ["source.removeUnused"],
+  delete_dead_code: [REMOVE_UNUSED_KIND, REMOVE_UNUSED_IMPORTS_KIND],
 } as const satisfies Record<
   "extract_function" | "extract_variable" | "update_imports" | "delete_dead_code",
   readonly string[]
@@ -143,6 +146,20 @@ function supportedOperation(
   return { server, supi, ...(reason ? { reason } : {}) };
 }
 
+function deleteDeadCodeSupport(capabilities: ServerCapabilities | null): ServerOperationSupport {
+  const server = codeActionAdvertisement(capabilities, REFACTOR_CODE_ACTION_KINDS.delete_dead_code);
+  const importsOnly =
+    codeActionAdvertisement(capabilities, [REMOVE_UNUSED_KIND]) !== "advertised" &&
+    codeActionAdvertisement(capabilities, [REMOVE_UNUSED_IMPORTS_KIND]) === "advertised";
+  return importsOnly
+    ? supportedOperation(
+        server,
+        "limited",
+        "Only unused-import removal is supported by this mapping, not arbitrary unused declarations.",
+      )
+    : supportedOperation(server);
+}
+
 /** Build the honest operation-support projection for one negotiated server. */
 export function getServerOperationSupport(
   capabilities: ServerCapabilities | null,
@@ -181,9 +198,7 @@ export function getServerOperationSupport(
     update_imports: supportedOperation(
       codeActionAdvertisement(capabilities, REFACTOR_CODE_ACTION_KINDS.update_imports),
     ),
-    delete_dead_code: supportedOperation(
-      codeActionAdvertisement(capabilities, REFACTOR_CODE_ACTION_KINDS.delete_dead_code),
-    ),
+    delete_dead_code: deleteDeadCodeSupport(capabilities),
     code_action_resolve: supportedOperation(resolveServer),
   };
 }

package/src/config/server-config.ts

@@ -26,6 +26,20 @@ export interface ServerConfig {
   initializationOptions?: unknown;
   /** Maximum time to wait for a single $/progress cycle, in ms. Default: 10_000. */
   readinessTimeoutMs?: number;
+  /** TypeScript compiler package name or installed alias, resolved from the route root. */
+  typescriptPackage?: string;
+  /** @internal Effective explicit-field origins for TypeScript launch policy, not user configuration. */
+  typescriptExplicitFields?: Partial<
+    Record<"command" | "args" | "tsserverPath" | "typescriptPackage", string>
+  >;
+}
+
+/** Compiler selection facts; absent versions are unknown, not inferred from the wrapper. */
+export interface TypeScriptSelection {
+  backend: "tsserver" | "native";
+  packageName: string;
+  compilerVersion?: string;
+  wrapperVersion?: string;
 }
 
 /** LSP configuration keyed by language name (e.g. `typescript`, `python`). */
@@ -37,6 +51,10 @@ export interface DetectedProjectServer {
   name: string;
   root: string;
   fileTypes: string[];
+  /** Resolved automatic compiler selection, when available. */
+  typescript?: TypeScriptSelection;
+  /** Actionable launch-selection failure, including its root and package. */
+  failureMessage?: string;
 }
 
 /** Structured reason for a route-level process-crash recovery state. */
@@ -64,4 +82,8 @@ export interface MissingServer {
   command: string;
   /** File extensions found in the project (subset of server.fileTypes). */
   foundExtensions: string[];
+  /** Route root when a compiler-selection failure prevents launch. */
+  root?: string;
+  /** Compiler selection failure, distinct from a missing executable. */
+  failureMessage?: string;
 }