@mrclrchtr/supi-code-intelligence 4.10.0 → 6.0.0

package/node_modules/@mrclrchtr/supi-lsp/src/client/transport.ts

@@ -3,16 +3,22 @@
 // and notification/request dispatching through vscode-jsonrpc's MessageConnection.
 
 import type { Readable, Writable } from "node:stream";
+import {
+  type CodeRequestControl,
+  CodeRequestDeadlineError,
+} from "@mrclrchtr/supi-code-runtime/api";
 import { startDebugTimer } from "@mrclrchtr/supi-core/debug";
 import {
   CancellationTokenSource,
   createMessageConnection,
+  ErrorCodes,
   type MessageConnection,
   NullLogger,
   ResponseError,
   StreamMessageReader,
   StreamMessageWriter,
 } from "vscode-jsonrpc/node";
+import { boundCwd, LSP_REQUEST_TIMEOUT_ERROR_CODE, truncateIdentity } from "../debug-telemetry.ts";
 
 const DEFAULT_TIMEOUT_MS = 30_000;
 
@@ -37,13 +43,19 @@ export class JsonRpcClient {
   private requestHandler: RequestHandler | null = null;
   private closed = false;
   private readonly timeoutMs: number;
+  private readonly server: string | undefined;
+  private readonly cwd: string | undefined;
+  /** Failures that signal a stalled protocol: repeated errors and local timeouts. */
+  private protocolFailureCount = 0;
 
   constructor(
     private readonly input: Readable,
     private readonly output: Writable,
-    options?: { timeoutMs?: number },
+    options?: { timeoutMs?: number; server?: string; cwd?: string },
   ) {
     this.timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.server = options?.server;
+    this.cwd = options?.cwd;
 
     const reader = new StreamMessageReader(this.input);
     const writer = new StreamMessageWriter(this.output);
@@ -55,6 +67,13 @@ export class JsonRpcClient {
       this.notificationHandler?.(method, params);
     });
 
+    // vscode-jsonrpc registers an internal $/progress handler that never
+    // reaches the catch-all handler. Route it explicitly so LSP progress
+    // notifications reach the client's readiness state machine.
+    this.connection.onNotification("$/progress", (params) => {
+      this.notificationHandler?.("$/progress", params);
+    });
+
     // Register catch-all request handler for server-initiated requests
     this.connection.onRequest(async (method, params, _token) => {
       if (!this.requestHandler) {
@@ -85,26 +104,53 @@ export class JsonRpcClient {
   sendRequest(
     method: string,
     params?: unknown,
-    options?: { timeoutMs?: number },
+    options?: { timeoutMs?: number } & CodeRequestControl,
   ): Promise<unknown> {
     const timeoutMs = options?.timeoutMs ?? this.timeoutMs;
+    const signal = options?.signal;
+    const deadlineMs = options?.deadline === undefined ? undefined : options.deadline - Date.now();
     const methodClass = classifyRequestMethod(method);
+    const boundedMethod = truncateIdentity(method);
     const timer = startDebugTimer();
+    // An expired absolute deadline must not even send the request: the caller
+    // no longer awaits a result, so no protocol traffic may start.
+    if (deadlineMs !== undefined && deadlineMs <= 0) {
+      recordRequestTiming(
+        timer,
+        options?.operationId,
+        {
+          method: boundedMethod,
+          methodClass,
+          outcome: "timed-out",
+          errorCode: LSP_REQUEST_TIMEOUT_ERROR_CODE,
+        },
+        { server: this.server, cwd: this.cwd },
+      );
+      return Promise.reject(new CodeRequestDeadlineError());
+    }
     if (this.closed || !this.connection) {
-      recordRequestTiming(timer, {
-        methodClass,
-        outcome: "cancelled",
-        timeoutMs,
-        timedOut: false,
-        cancelled: true,
-      });
+      recordRequestTiming(
+        timer,
+        options?.operationId,
+        {
+          method: boundedMethod,
+          methodClass,
+          outcome: "cancelled",
+        },
+        { server: this.server, cwd: this.cwd },
+      );
       return Promise.reject(new Error("JSON-RPC client is closed"));
     }
-
     const tokenSource = new CancellationTokenSource();
     let timeout: ReturnType<typeof setTimeout> | undefined;
     let timedOut = false;
-    const timeoutError = new Error(`Request ${method} timed out after ${timeoutMs}ms`);
+    let aborted = false;
+    const timerDelayMs = deadlineMs === undefined ? timeoutMs : Math.min(timeoutMs, deadlineMs);
+    const timeoutError = Object.assign(
+      new Error(`Request ${method} timed out after ${timerDelayMs}ms`),
+      { code: LSP_REQUEST_TIMEOUT_ERROR_CODE },
+    );
+    const abortError = new Error(`Request ${method} was cancelled`);
 
     const request = this.connection.sendRequest(method, params, tokenSource.token);
     // Catch the raw request promise to prevent unhandled rejections when
@@ -115,46 +161,79 @@ export class JsonRpcClient {
     // the JSON-RPC token and rejects the caller. Using one timer avoids
     // a leak where the rejecting timer in a second Promise stays alive
     // after a successful response.
+    let abortHandler: (() => void) | undefined;
+    const abort = new Promise<never>((_resolve, reject) => {
+      abortHandler = () => {
+        aborted = true;
+        tokenSource.cancel();
+        // Reject with the caller's abort reason when one exists, matching the
+        // canonical throwIfCodeRequestInterrupted() behavior.
+        reject(signal?.reason ?? abortError);
+      };
+      if (signal?.aborted) abortHandler();
+      else signal?.addEventListener("abort", abortHandler, { once: true });
+    });
     const promise = Promise.race([
       request,
       new Promise<never>((_resolve, reject) => {
         timeout = setTimeout(() => {
           timedOut = true;
           tokenSource.cancel();
-          reject(timeoutError);
-        }, timeoutMs);
+          // A deadline that binds earlier than the timeout is a deadline
+          // outcome, distinct from an ordinary per-request timeout.
+          reject(
+            deadlineMs !== undefined && deadlineMs < timeoutMs
+              ? new CodeRequestDeadlineError()
+              : timeoutError,
+          );
+        }, timerDelayMs);
       }),
+      abort,
     ])
       .then(
         (result) => {
-          recordRequestTiming(timer, {
-            methodClass,
-            outcome: "completed",
-            timeoutMs,
-            timedOut: false,
-            cancelled: false,
-          });
+          recordRequestTiming(
+            timer,
+            options?.operationId,
+            {
+              method: boundedMethod,
+              methodClass,
+              outcome: "completed",
+            },
+            { server: this.server, cwd: this.cwd },
+          );
           return result;
         },
         (error: unknown) => {
-          const cancelled = timedOut || this.closed || isCancellationError(error);
+          const cancelled = timedOut || aborted || this.closed || isCancellationError(error);
           const outcome: RequestOutcome = timedOut
             ? "timed-out"
             : cancelled
               ? "cancelled"
               : "failed";
-          recordRequestTiming(timer, {
-            methodClass,
-            outcome,
-            timeoutMs,
-            timedOut,
-            cancelled,
-          });
+          const errorCode = requestErrorCode(outcome, error);
+          this.countProtocolStallFailure(outcome, errorCode, error);
+          recordRequestTiming(
+            timer,
+            options?.operationId,
+            {
+              method: boundedMethod,
+              methodClass,
+              outcome,
+              // Failed requests record the server-reported JSON-RPC error code
+              // when the error carries one; timed-out requests record the
+              // defined timeout code (also for deadline expiries, whose error
+              // carries none); cancellations carry no error code.
+              errorCode,
+            },
+            { server: this.server, cwd: this.cwd },
+          );
           throw error;
         },
       )
       .finally(() => {
         if (timeout !== undefined) clearTimeout(timeout);
+        if (abortHandler) signal?.removeEventListener("abort", abortHandler);
       });
 
     // Prevent unhandled rejection when dispose() cancels requests
@@ -184,6 +263,30 @@ export class JsonRpcClient {
       this.connection = null;
     }
   }
+
+  /**
+   * Count one protocol-stall failure: a local timeout (not a caller-imposed
+   * deadline expiry) or a repeated server-reported protocol error. A deadline
+   * expiry is not a stall: the request may be perfectly healthy (ADR 0020).
+   */
+  private countProtocolStallFailure(
+    outcome: RequestOutcome,
+    errorCode: number | undefined,
+    error: unknown,
+  ): void {
+    if (
+      (outcome === "timed-out" && !(error instanceof CodeRequestDeadlineError)) ||
+      errorCode === ErrorCodes.ServerNotInitialized ||
+      errorCode === ErrorCodes.InvalidRequest
+    ) {
+      this.protocolFailureCount++;
+    }
+  }
+
+  /** Number of protocol-stall failures observed on this connection. */
+  getProtocolFailureCount(): number {
+    return this.protocolFailureCount;
+  }
 }
 
 const SEMANTIC_REQUESTS = new Set([
@@ -218,25 +321,50 @@ function isCancellationError(error: unknown): boolean {
   );
 }
 
+/** One bounded request-timing observation with exact method identity. */
 interface RequestTimingObservation {
+  readonly method: string;
   readonly methodClass: RequestMethodClass;
   readonly outcome: RequestOutcome;
-  readonly timeoutMs: number;
-  readonly timedOut: boolean;
-  readonly cancelled: boolean;
+  /** JSON-RPC error code reported by the server for a failed request. */
+  readonly errorCode?: number;
+}
+
+/** Return the JSON-RPC error code for one request outcome. */
+function requestErrorCode(outcome: RequestOutcome, error: unknown): number | undefined {
+  if (outcome === "failed") return jsonRpcErrorCode(error);
+  if (outcome === "timed-out") return jsonRpcErrorCode(error) ?? LSP_REQUEST_TIMEOUT_ERROR_CODE;
+  return undefined;
+}
+
+/** Return the numeric JSON-RPC error code carried by an error, if any. */
+function jsonRpcErrorCode(error: unknown): number | undefined {
+  if (typeof error !== "object" || error === null) return undefined;
+  const code = (error as { code?: unknown }).code;
+  return typeof code === "number" && Number.isInteger(code) ? code : undefined;
 }
 
 function recordRequestTiming(
   timer: ReturnType<typeof startDebugTimer>,
+  operationId: string | undefined,
   observation: RequestTimingObservation,
+  identity: { server?: string; cwd?: string },
 ): void {
   timer.finish(
     () => ({
+      operationId,
       source: "lsp",
       level: "debug",
       category: "request.timing",
-      message: `LSP ${observation.methodClass} request ${observation.outcome}`,
-      data: { ...observation },
+      message: `LSP ${observation.methodClass} request ${observation.outcome} for ${observation.method}`,
+      cwd: boundCwd(identity.cwd),
+      data: {
+        method: observation.method,
+        methodClass: observation.methodClass,
+        outcome: observation.outcome,
+        ...(identity.server !== undefined ? { server: truncateIdentity(identity.server) } : {}),
+        ...(observation.errorCode !== undefined ? { errorCode: observation.errorCode } : {}),
+      },
     }),
     "request",
   );

package/node_modules/@mrclrchtr/supi-lsp/src/config/capabilities.ts

@@ -3,6 +3,9 @@
 import type { ClientCapabilities } from "./types.ts";
 
 export const CLIENT_CAPABILITIES: ClientCapabilities = {
+  general: {
+    positionEncodings: ["utf-16"],
+  },
   textDocument: {
     synchronization: {
       didSave: true,
@@ -49,7 +52,10 @@ export const CLIENT_CAPABILITIES: ClientCapabilities = {
       versionSupport: true,
     },
     diagnostic: {
-      dynamicRegistration: false,
+      // Dynamic registration lets servers such as pyright-langserver register
+      // `textDocument/diagnostic` support after initialization. Probes show
+      // only Pyright acts on this global flag among the built-in servers.
+      dynamicRegistration: true,
       relatedDocumentSupport: true,
     },
   },
@@ -57,9 +63,12 @@ export const CLIENT_CAPABILITIES: ClientCapabilities = {
     workDoneProgress: true,
   },
   workspace: {
-    workspaceFolders: false,
+    workspaceFolders: true,
+    workspaceEdit: {
+      documentChanges: true,
+    },
     diagnostics: {
-      refreshSupport: false,
+      refreshSupport: true,
     },
   },
 };

package/node_modules/@mrclrchtr/supi-lsp/src/config/config.ts

@@ -125,15 +125,15 @@ function mergeSingleServer(
   override: Partial<ServerConfig>,
 ): ServerConfig | null {
   if (!base) {
-    // New custom language — must have all required fields
+    // A custom server needs a command and at least one file extension.
     if (
-      override.command &&
+      typeof override.command === "string" &&
+      override.command.length > 0 &&
       Array.isArray(override.fileTypes) &&
       override.fileTypes.length > 0 &&
-      Array.isArray(override.rootMarkers) &&
-      override.rootMarkers.length > 0
+      (override.rootMarkers === undefined || Array.isArray(override.rootMarkers))
     ) {
-      return override as ServerConfig;
+      return { ...override, rootMarkers: override.rootMarkers ?? [] } as ServerConfig;
     }
     return null;
   }

package/node_modules/@mrclrchtr/supi-lsp/src/config/defaults.json

@@ -50,7 +50,7 @@
     },
     "kotlin": {
       "command": "kotlin-lsp",
-      "args": [],
+      "args": ["--stdio"],
       "fileTypes": ["kt", "kts"],
       "rootMarkers": ["build.gradle.kts", "pom.xml"]
     },

package/node_modules/@mrclrchtr/supi-lsp/src/config/server-config.ts

@@ -5,8 +5,11 @@ export interface ServerConfig {
   command: string;
   args?: string[];
   fileTypes: string[];
+  /** Files that identify the project root. An empty list uses the session root. */
   rootMarkers: string[];
   enabled?: boolean;
+  /** Environment values added when the server process starts. */
+  env?: Record<string, string>;
   initializationOptions?: unknown;
   /** Maximum time to wait for a single $/progress cycle, in ms. Default: 10_000. */
   readinessTimeoutMs?: number;

package/node_modules/@mrclrchtr/supi-lsp/src/config/tsconfig-extends.ts

@@ -0,0 +1,68 @@
+import * as path from "node:path";
+import ts from "typescript";
+import { normalizeTsconfigPath as normalizePath } from "./tsconfig-path.ts";
+
+/**
+ * Collect recognized local project configs declared by `extends`, including
+ * transitive dependencies and paths that do not exist yet.
+ */
+export function collectExtendedProjectConfigs(configPath: string): Set<string> {
+  const dependencies = new Set<string>();
+  const visited = new Set<string>();
+
+  const visit = (currentConfigPath: string): void => {
+    const normalizedConfigPath = normalizePath(currentConfigPath);
+    if (visited.has(normalizedConfigPath)) return;
+    visited.add(normalizedConfigPath);
+
+    const config = ts.readConfigFile(currentConfigPath, ts.sys.readFile).config;
+    if (!config || typeof config !== "object") return;
+
+    const extendsValues =
+      typeof config.extends === "string"
+        ? [config.extends]
+        : Array.isArray(config.extends)
+          ? config.extends.filter((value: unknown): value is string => typeof value === "string")
+          : [];
+
+    for (const extendsValue of extendsValues) {
+      const extendedConfigPath = resolveLocalExtendedConfigPath(currentConfigPath, extendsValue);
+      if (!extendedConfigPath) continue;
+
+      const normalizedExtendedConfigPath = normalizePath(extendedConfigPath);
+      dependencies.add(normalizedExtendedConfigPath);
+      visit(extendedConfigPath);
+    }
+  };
+
+  visit(configPath);
+  return dependencies;
+}
+
+/**
+ * Resolve a local project-config extends entry.
+ *
+ * Package names are not local paths and are deliberately ignored. TypeScript
+ * uses the `.json` suffix for extensionless local config references. Only
+ * recognized project-config names are tracked; arbitrary local JSON files may
+ * still be parsed by TypeScript but are outside this invalidation contract.
+ */
+function resolveLocalExtendedConfigPath(configPath: string, extendsValue: string): string | null {
+  if (!path.isAbsolute(extendsValue) && !/^\.{1,2}(?:[\\/]|$)/.test(extendsValue)) {
+    return null;
+  }
+
+  const resolved = path.resolve(path.dirname(configPath), extendsValue);
+  const candidate =
+    path.extname(resolved).toLowerCase() === ".json" ? resolved : `${resolved}.json`;
+  return isProjectConfigFileName(path.basename(candidate)) ? candidate : null;
+}
+
+/** Whether a file name is a tsconfig.json, jsconfig.json, or tsconfig.*.json name. */
+export function isProjectConfigFileName(name: string): boolean {
+  return (
+    name === "tsconfig.json" ||
+    name === "jsconfig.json" ||
+    (name.startsWith("tsconfig.") && name.endsWith(".json"))
+  );
+}

package/node_modules/@mrclrchtr/supi-lsp/src/config/tsconfig-path.ts

@@ -0,0 +1,8 @@
+import * as path from "node:path";
+import ts from "typescript";
+
+/** Normalize a path for tsconfig cache keys and comparisons. */
+export function normalizeTsconfigPath(target: string): string {
+  const resolved = path.resolve(target).replaceAll("\\", "/");
+  return ts.sys.useCaseSensitiveFileNames ? resolved : resolved.toLowerCase();
+}