@mrclrchtr/supi-code-intelligence 4.9.0 → 4.10.0

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

@@ -3,6 +3,7 @@
 // and notification/request dispatching through vscode-jsonrpc's MessageConnection.
 
 import type { Readable, Writable } from "node:stream";
+import { startDebugTimer } from "@mrclrchtr/supi-core/debug";
 import {
   CancellationTokenSource,
   createMessageConnection,
@@ -20,6 +21,9 @@ const DEFAULT_TIMEOUT_MS = 30_000;
 export type NotificationHandler = (method: string, params: unknown) => void;
 export type RequestHandler = (method: string, params: unknown) => Promise<unknown> | unknown;
 
+type RequestMethodClass = "diagnostic" | "lifecycle" | "other" | "refactor" | "semantic";
+type RequestOutcome = "cancelled" | "completed" | "failed" | "timed-out";
+
 /** Re-export ResponseError so callers don't need a separate vscode-jsonrpc import. */
 const JsonRpcRequestError = ResponseError;
 
@@ -83,14 +87,23 @@ export class JsonRpcClient {
     params?: unknown,
     options?: { timeoutMs?: number },
   ): Promise<unknown> {
+    const timeoutMs = options?.timeoutMs ?? this.timeoutMs;
+    const methodClass = classifyRequestMethod(method);
+    const timer = startDebugTimer();
     if (this.closed || !this.connection) {
+      recordRequestTiming(timer, {
+        methodClass,
+        outcome: "cancelled",
+        timeoutMs,
+        timedOut: false,
+        cancelled: true,
+      });
       return Promise.reject(new Error("JSON-RPC client is closed"));
     }
 
-    const timeoutMs = options?.timeoutMs ?? this.timeoutMs;
     const tokenSource = new CancellationTokenSource();
-
     let timeout: ReturnType<typeof setTimeout> | undefined;
+    let timedOut = false;
     const timeoutError = new Error(`Request ${method} timed out after ${timeoutMs}ms`);
 
     const request = this.connection.sendRequest(method, params, tokenSource.token);
@@ -106,13 +119,43 @@ export class JsonRpcClient {
       request,
       new Promise<never>((_resolve, reject) => {
         timeout = setTimeout(() => {
+          timedOut = true;
           tokenSource.cancel();
           reject(timeoutError);
         }, timeoutMs);
       }),
-    ]).finally(() => {
-      if (timeout !== undefined) clearTimeout(timeout);
-    });
+    ])
+      .then(
+        (result) => {
+          recordRequestTiming(timer, {
+            methodClass,
+            outcome: "completed",
+            timeoutMs,
+            timedOut: false,
+            cancelled: false,
+          });
+          return result;
+        },
+        (error: unknown) => {
+          const cancelled = timedOut || this.closed || isCancellationError(error);
+          const outcome: RequestOutcome = timedOut
+            ? "timed-out"
+            : cancelled
+              ? "cancelled"
+              : "failed";
+          recordRequestTiming(timer, {
+            methodClass,
+            outcome,
+            timeoutMs,
+            timedOut,
+            cancelled,
+          });
+          throw error;
+        },
+      )
+      .finally(() => {
+        if (timeout !== undefined) clearTimeout(timeout);
+      });
 
     // Prevent unhandled rejection when dispose() cancels requests
     promise.catch(() => {});
@@ -142,3 +185,59 @@ export class JsonRpcClient {
     }
   }
 }
+
+const SEMANTIC_REQUESTS = new Set([
+  "textDocument/definition",
+  "textDocument/documentSymbol",
+  "textDocument/hover",
+  "textDocument/implementation",
+  "textDocument/references",
+  "workspace/symbol",
+]);
+
+/** Classify requests into bounded groups without retaining the raw method. */
+function classifyRequestMethod(method: string): RequestMethodClass {
+  if (method === "initialize" || method === "shutdown") return "lifecycle";
+  if (method === "textDocument/diagnostic" || method === "workspace/diagnostic") {
+    return "diagnostic";
+  }
+  if (method === "textDocument/codeAction" || method === "textDocument/rename") {
+    return "refactor";
+  }
+  return SEMANTIC_REQUESTS.has(method) ? "semantic" : "other";
+}
+
+function isCancellationError(error: unknown): boolean {
+  if (!(error instanceof Error)) return false;
+  const code = (error as Error & { code?: unknown }).code;
+  return (
+    code === -32_800 ||
+    code === -32_802 ||
+    error.name === "CancellationError" ||
+    /\bcancell?ed\b/i.test(error.message)
+  );
+}
+
+interface RequestTimingObservation {
+  readonly methodClass: RequestMethodClass;
+  readonly outcome: RequestOutcome;
+  readonly timeoutMs: number;
+  readonly timedOut: boolean;
+  readonly cancelled: boolean;
+}
+
+function recordRequestTiming(
+  timer: ReturnType<typeof startDebugTimer>,
+  observation: RequestTimingObservation,
+): void {
+  timer.finish(
+    () => ({
+      source: "lsp",
+      level: "debug",
+      category: "request.timing",
+      message: `LSP ${observation.methodClass} request ${observation.outcome}`,
+      data: { ...observation },
+    }),
+    "request",
+  );
+}

package/node_modules/@mrclrchtr/supi-tree-sitter/README.md

@@ -96,6 +96,16 @@ if (state.kind === "ready") {
 }
 ```
 
+## Structural performance baseline
+
+Run the stable outline fixture on the same machine and dependency versions:
+
+```bash
+pnpm --filter @mrclrchtr/supi-tree-sitter bench:structural
+```
+
+The benchmark reports a cold session parser baseline and a repeated parser baseline. Debug capture is active, so the baseline includes the internal timing observation cost. The benchmark records measurements but does not set a pass or fail threshold.
+
 ## Source
 
 - `src/api.ts` — public library entrypoint

package/node_modules/@mrclrchtr/supi-tree-sitter/node_modules/@mrclrchtr/supi-code-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-code-runtime",
-  "version": "4.9.0",
+  "version": "4.10.0",
   "description": "Shared workspace context and capability contracts for code intelligence",
   "license": "MIT",
   "repository": {

package/node_modules/@mrclrchtr/supi-tree-sitter/node_modules/@mrclrchtr/supi-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-core",
-  "version": "4.9.0",
+  "version": "4.10.0",
   "description": "Shared settings, configuration, reporting, and session infrastructure",
   "license": "MIT",
   "repository": {

package/node_modules/@mrclrchtr/supi-tree-sitter/node_modules/@mrclrchtr/supi-core/src/debug-timing.ts

@@ -46,13 +46,21 @@ export interface DebugTimer {
  * names are accumulated. Event data reserves the `timing` field. When Debug is
  * disabled at start, this returns a no-op timer and does not read the clock.
  * Pass a factory to `finish()` to avoid event-data construction when disabled.
+ * Clock, event-construction, and registry failures are isolated from the
+ * measured operation and make the timer a no-op.
  */
 export function startDebugTimer(options: DebugTimerOptions = {}): DebugTimer {
   if (!isDebugRegistryEnabled()) return DISABLED_DEBUG_TIMER;
   const now = options.now ?? performance.now.bind(performance);
-  const startedAt = now();
+  let startedAt: number;
+  try {
+    startedAt = now();
+  } catch {
+    return DISABLED_DEBUG_TIMER;
+  }
   let previousAt = startedAt;
   let finished = false;
+  let failed = false;
   const phases = new Map<string, number>();
 
   const markAt = (phase: string, current: number): void => {
@@ -65,30 +73,35 @@ export function startDebugTimer(options: DebugTimerOptions = {}): DebugTimer {
   return {
     enabled: true,
     mark(phase) {
-      if (finished) return;
-      markAt(phase, now());
+      if (finished || failed) return;
+      try {
+        markAt(phase, now());
+      } catch {
+        failed = true;
+      }
     },
     finish(input, finalPhase) {
-      if (finished) return null;
-      if (!isDebugRegistryEnabled()) {
-        finished = true;
+      if (finished || failed) return null;
+      finished = true;
+      try {
+        if (!isDebugRegistryEnabled()) return null;
+        const completedAt = now();
+        if (finalPhase) markAt(finalPhase, completedAt);
+        const phasesMs = Object.fromEntries(
+          [...phases.entries()].map(([name, value]) => [name, duration(value)]),
+        );
+        const timing: DebugTiming = {
+          durationMs: duration(completedAt - startedAt),
+          phasesMs,
+        };
+        const eventInput = typeof input === "function" ? input() : input;
+        return recordDebugEvent({
+          ...eventInput,
+          data: { ...eventInput.data, timing },
+        });
+      } catch {
         return null;
       }
-      const completedAt = now();
-      if (finalPhase) markAt(finalPhase, completedAt);
-      finished = true;
-      const phasesMs = Object.fromEntries(
-        [...phases.entries()].map(([name, value]) => [name, duration(value)]),
-      );
-      const timing: DebugTiming = {
-        durationMs: duration(completedAt - startedAt),
-        phasesMs,
-      };
-      const eventInput = typeof input === "function" ? input() : input;
-      return recordDebugEvent({
-        ...eventInput,
-        data: { ...eventInput.data, timing },
-      });
     },
   };
 }