@mrclrchtr/supi-code-intelligence 3.2.0 → 4.0.0

package/node_modules/@mrclrchtr/supi-lsp/node_modules/@mrclrchtr/supi-core/src/evidence-badge.ts

@@ -22,14 +22,15 @@ export interface EvidenceBadgeInput {
  * |------------------------------------------------------|---------------------------------------|
  * | shown=12, total=12, omitted=0, label="references"   | `12 references`                       |
  * | shown=8,  total=20, omitted=12, label="symbols"     | `8 of 20 symbols (12 omitted)`        |
- * | shown=5,  total=null, reason="timeout", label="matches" | `5 matches — timeout`              |
+ * | shown=5, total=null, omitted=2, reason="timeout" | `5 matches (2 collected omitted; more may exist — timeout)` |
  */
 export function formatEvidenceBadge(input: EvidenceBadgeInput): string {
   const { shownCount, totalCount, omittedCount, partialReason, label } = input;
 
   if (totalCount === null) {
     const reasonSuffix = partialReason ? ` — ${partialReason}` : "";
-    return `${shownCount} ${label}${reasonSuffix}`;
+    const omittedPrefix = (omittedCount ?? 0) > 0 ? `${omittedCount} collected omitted; ` : "";
+    return `${shownCount} ${label} (${omittedPrefix}more may exist${reasonSuffix})`;
   }
 
   if (omittedCount !== null && omittedCount > 0) {

package/node_modules/@mrclrchtr/supi-lsp/node_modules/@mrclrchtr/supi-core/src/index.ts

@@ -6,8 +6,6 @@
 // For lighter imports, use one of the domain subpaths directly
 // (e.g. @mrclrchtr/supi-core/config, @mrclrchtr/supi-core/context).
 
-// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
-export * from "./abort-utils.ts";
 // biome-ignore lint/performance/noReExportAll: intentional convenience barrel
 export * from "./config.ts";
 // biome-ignore lint/performance/noReExportAll: intentional convenience barrel
@@ -36,5 +34,3 @@ export * from "./status-spinner.ts";
 export * from "./terminal.ts";
 // biome-ignore lint/performance/noReExportAll: intentional convenience barrel
 export * from "./tool-framework.ts";
-// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
-export * from "./types.ts";

package/node_modules/@mrclrchtr/supi-lsp/node_modules/@mrclrchtr/supi-core/src/llm.ts

@@ -24,16 +24,6 @@ export interface WithRetryOptions {
   onRetry?: (attempt: number, delayMs: number) => void;
 }
 
-/**
- * Attempt an async operation with retries and exponential backoff.
- *
- * If the signal is already aborted on entry, the operation is skipped entirely.
- * If the signal aborts during a delay, the delay is cancelled immediately.
- *
- * @param fn - The async operation to retry.
- * @param options - Optional configuration for retries, backoff, signal, and callbacks.
- * @returns The result on success, or `null` if all attempts fail or the signal aborts.
- */
 /**
  * Create a promise that resolves after `ms` milliseconds, or rejects if
  * the signal fires before the timeout elapses.

package/node_modules/@mrclrchtr/supi-lsp/node_modules/@mrclrchtr/supi-core/src/path-utils.ts

@@ -1,4 +1,5 @@
 import * as path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
 
 /** Strip pi's optional leading `@` file-path prefix from a tool input. */
 export function stripToolPathPrefix(target: string): string {
@@ -16,25 +17,28 @@ export function resolveToolPath(cwd: string, target: string): string {
   return path.resolve(cwd, stripToolPathPrefix(target));
 }
 
-/** Convert a file path to a file:// URI. */
+/**
+ * Convert a file path to a file:// URI.
+ *
+ * Uses Node's `pathToFileURL` to produce a standards-compliant URI with
+ * proper percent-encoding of spaces, hashes, and other special characters.
+ */
 export function fileToUri(filePath: string): string {
-  const resolved = path.resolve(filePath);
-  if (process.platform === "win32") {
-    return `file:///${resolved.replace(/\\/g, "/")}`;
-  }
-  return `file://${resolved}`;
+  return pathToFileURL(filePath).href;
 }
 
-/** Convert a file:// URI to a file path. */
+/**
+ * Convert a file:// URI to a file path.
+ *
+ * Uses Node's `fileURLToPath` for standards-compliant decoding. Non-file
+ * URIs are passed through unchanged so consumers (such as LSP diagnostic
+ * handling) remain compatible with non-file URI schemes.
+ */
 export function uriToFile(uri: string): string {
   if (!uri.startsWith("file://")) return uri;
-  let filePath = decodeURIComponent(uri.slice(7));
-  if (
-    process.platform === "win32" &&
-    filePath.startsWith("/") &&
-    /^[A-Za-z]:/.test(filePath.slice(1))
-  ) {
-    filePath = filePath.slice(1);
+  try {
+    return fileURLToPath(uri);
+  } catch {
+    return uri;
   }
-  return filePath;
 }

package/node_modules/@mrclrchtr/supi-lsp/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mrclrchtr/supi-lsp",
-  "version": "3.2.0",
-  "description": "SuPi LSP extension — Language Server Protocol integration for pi",
+  "version": "4.0.0",
+  "description": "SuPi LSP runtime — Language Server Protocol integration library for pi",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -18,7 +18,6 @@
   "keywords": [
     "pi",
     "pi-coding-agent",
-    "pi-extension",
     "lsp",
     "language-server",
     "go-to-definition",
@@ -38,8 +37,8 @@
     "vscode-jsonrpc": "^9.0.0",
     "vscode-languageserver-protocol": "^3.17.5",
     "vscode-languageserver-types": "^3.17.5",
-    "@mrclrchtr/supi-code-runtime": "3.2.0",
-    "@mrclrchtr/supi-core": "3.2.0"
+    "@mrclrchtr/supi-code-runtime": "4.0.0",
+    "@mrclrchtr/supi-core": "4.0.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",

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

@@ -38,18 +38,18 @@ export type {
   LspStartResult,
 } from "./session/runtime-controller.ts";
 export { LspRuntimeController } from "./session/runtime-controller.ts";
-export { scanMissingServers } from "./session/scanner.ts";
 export type {
   OutstandingDiagnosticSummaryEntry,
   RecoverDiagnosticsResult,
   SemanticReadinessResult,
-  SessionLspServiceState,
   WorkspaceDiagnosticSummaryEntry,
-} from "./session/service-registry.ts";
+  WorkspaceLspRuntime,
+  WorkspaceLspRuntimeState,
+} from "./session/runtime-registry.ts";
 export {
-  clearSessionLspService,
-  getSessionLspService,
-  SessionLspService,
-  setSessionLspServiceState,
-  waitForSessionLspService,
-} from "./session/service-registry.ts";
+  clearWorkspaceLspRuntime,
+  getWorkspaceLspRuntime,
+  setWorkspaceLspRuntimeState,
+  waitForWorkspaceLspRuntime,
+} from "./session/runtime-registry.ts";
+export { scanMissingServers } from "./session/scanner.ts";

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

@@ -5,6 +5,11 @@
 import { type ChildProcess, execSync, spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import * as path from "node:path";
+import {
+  type CodeQueryResult,
+  completedCodeQuery,
+  unavailableCodeQuery,
+} from "@mrclrchtr/supi-code-runtime/api";
 import { recordDebugEvent } from "@mrclrchtr/supi-core/debug";
 import type { ProgressToken } from "vscode-languageserver-protocol";
 import { CLIENT_CAPABILITIES } from "../config/capabilities.ts";
@@ -37,6 +42,25 @@ import { JsonRpcClient, JsonRpcRequestError } from "./transport.ts";
 const SHUTDOWN_TIMEOUT_MS = 5_000;
 const DIAGNOSTIC_WAIT_MS = 3_000;
 
+/** Race an operation against a timeout without retaining the timer after settlement. */
+async function withTimeout<T>(
+  operation: Promise<T>,
+  timeoutMs: number,
+  message: string,
+): Promise<T> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      operation,
+      new Promise<never>((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+      }),
+    ]);
+  } finally {
+    if (timer !== undefined) clearTimeout(timer);
+  }
+}
+
 // ── Process-tree cleanup ──────────────────────────────────────────────
 
 /**
@@ -218,20 +242,13 @@ export class LspClient {
     if (!this.rpc || !this.process) return;
 
     try {
-      // Send shutdown request with a timeout
-      await Promise.race([
-        this.rpc.sendRequest("shutdown"),
-        new Promise((_, reject) =>
-          setTimeout(() => reject(new Error("shutdown timeout")), SHUTDOWN_TIMEOUT_MS),
-        ),
-      ]);
+      await withTimeout(this.rpc.sendRequest("shutdown"), SHUTDOWN_TIMEOUT_MS, "shutdown timeout");
       // Flush the final exit notification before disposing the transport.
-      await Promise.race([
+      await withTimeout(
         this.rpc.sendNotification("exit"),
-        new Promise((_, reject) =>
-          setTimeout(() => reject(new Error("exit notification timeout")), SHUTDOWN_TIMEOUT_MS),
-        ),
-      ]);
+        SHUTDOWN_TIMEOUT_MS,
+        "exit notification timeout",
+      );
     } catch {
       // Timeout or error — force kill
     }
@@ -382,11 +399,6 @@ export class LspClient {
     return result;
   }
 
-  /** Get the internal cache entry for a file (exposed for testing / version checks). */
-  getDiagnosticCacheEntry(uri: string): DiagnosticCacheEntry | undefined {
-    return this.diagnosticStore.get(uri);
-  }
-
   /**
    * Clear all pull-diagnostic result IDs, forcing full (not `unchanged`)
    * pull diagnostic responses on the next refresh cycle.
@@ -401,11 +413,6 @@ export class LspClient {
     }
   }
 
-  /** Get all currently open document URIs. */
-  get openUris(): string[] {
-    return Array.from(this.openDocs.keys());
-  }
-
   /** Check if server supports pull diagnostics. */
   get hasDiagnosticProvider(): boolean {
     return this.capabilities?.diagnosticProvider !== undefined;
@@ -462,8 +469,8 @@ export class LspClient {
   }
 
   // ── LSP Requests ───────────────────────────────────────────────────
-  async hover(filePath: string, position: Position): Promise<Hover | null> {
-    return this.request("textDocument/hover", {
+  async hover(filePath: string, position: Position): Promise<CodeQueryResult<Hover | null>> {
+    return this.query("textDocument/hover", {
       textDocument: { uri: fileToUri(filePath) },
       position,
     });
@@ -472,30 +479,39 @@ export class LspClient {
   async definition(
     filePath: string,
     position: Position,
-  ): Promise<Location | Location[] | LocationLink[] | null> {
-    return this.request("textDocument/definition", {
+  ): Promise<CodeQueryResult<Location | Location[] | LocationLink[] | null>> {
+    return this.query("textDocument/definition", {
       textDocument: { uri: fileToUri(filePath) },
       position,
     });
   }
 
-  async references(filePath: string, position: Position): Promise<Location[] | null> {
-    return this.request("textDocument/references", {
+  async references(
+    filePath: string,
+    position: Position,
+  ): Promise<CodeQueryResult<Location[] | null>> {
+    return this.query("textDocument/references", {
       textDocument: { uri: fileToUri(filePath) },
       position,
       context: { includeDeclaration: true },
     });
   }
 
-  async documentSymbols(filePath: string): Promise<DocumentSymbol[] | SymbolInformation[] | null> {
-    return this.request("textDocument/documentSymbol", {
+  async documentSymbols(
+    filePath: string,
+  ): Promise<CodeQueryResult<DocumentSymbol[] | SymbolInformation[] | null>> {
+    return this.query("textDocument/documentSymbol", {
       textDocument: { uri: fileToUri(filePath) },
     });
   }
 
-  async workspaceSymbol(query: string): Promise<SymbolInformation[] | WorkspaceSymbol[] | null> {
-    if (!this.capabilities?.workspaceSymbolProvider) return null;
-    return this.request("workspace/symbol", { query });
+  async workspaceSymbol(
+    query: string,
+  ): Promise<CodeQueryResult<SymbolInformation[] | WorkspaceSymbol[] | null>> {
+    if (!this.capabilities?.workspaceSymbolProvider) {
+      return unavailableCodeQuery("Workspace-symbol requests are not supported by this server.");
+    }
+    return this.query("workspace/symbol", { query });
   }
 
   async rename(
@@ -525,25 +541,38 @@ export class LspClient {
   async implementation(
     filePath: string,
     position: Position,
-  ): Promise<Location | Location[] | LocationLink[] | null> {
-    if (!this.capabilities?.implementationProvider) return null;
-    return this.request("textDocument/implementation", {
+  ): Promise<CodeQueryResult<Location | Location[] | LocationLink[] | null>> {
+    if (!this.capabilities?.implementationProvider) {
+      return unavailableCodeQuery("Implementation requests are not supported by this server.");
+    }
+    return this.query("textDocument/implementation", {
       textDocument: { uri: fileToUri(filePath) },
       position,
     });
   }
 
   // ── Private ─────────────────────────────────────────────────────────
-  private async request<T>(method: string, params: unknown): Promise<T | null> {
-    if (!this.rpc || this._status !== "running") return null;
+  private async query<T>(method: string, params: unknown): Promise<CodeQueryResult<T | null>> {
+    if (!this.rpc || this._status !== "running") {
+      return unavailableCodeQuery(
+        `LSP request ${method} is unavailable because the client is not running.`,
+      );
+    }
     try {
       await this.getReady();
-      return (await this.rpc.sendRequest(method, params)) as T;
-    } catch {
-      return null;
+      const data = (await this.rpc.sendRequest(method, params)) as T | null | undefined;
+      return completedCodeQuery(data ?? null);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      return unavailableCodeQuery(`LSP request ${method} failed: ${detail}`);
     }
   }
 
+  private async request<T>(method: string, params: unknown): Promise<T | null> {
+    const result = await this.query<T>(method, params);
+    return result.kind === "unavailable" ? null : result.data;
+  }
+
   private handleServerRequest(method: string, params: unknown): unknown {
     switch (method) {
       case "workspace/configuration":

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

@@ -90,26 +90,29 @@ export class JsonRpcClient {
     const timeoutMs = options?.timeoutMs ?? this.timeoutMs;
     const tokenSource = new CancellationTokenSource();
 
-    const timer = setTimeout(() => tokenSource.cancel(), timeoutMs);
+    let timeout: ReturnType<typeof setTimeout> | undefined;
+    const timeoutError = new Error(`Request ${method} timed out after ${timeoutMs}ms`);
 
     const request = this.connection.sendRequest(method, params, tokenSource.token);
     // Catch the raw request promise to prevent unhandled rejections when
-    // dispose() cancels the token without a preceding timeout (the raced
-    // promise below covers the timeout-then-dispose path separately).
+    // dispose() cancels the token without a preceding timeout.
     request.catch(() => {});
 
-    // Race the request against a timeout so callers don't hang forever.
-    // The CancellationToken is also passed to sendRequest so the connection
-    // can short-circuit writes and cleanup when the token fires.
+    // Race the request against a single shared timeout that both cancels
+    // 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.
     const promise = Promise.race([
       request,
-      new Promise<never>((_, reject) =>
-        setTimeout(
-          () => reject(new Error(`Request ${method} timed out after ${timeoutMs}ms`)),
-          timeoutMs,
-        ),
-      ),
-    ]).finally(() => clearTimeout(timer));
+      new Promise<never>((_resolve, reject) => {
+        timeout = setTimeout(() => {
+          tokenSource.cancel();
+          reject(timeoutError);
+        }, timeoutMs);
+      }),
+    ]).finally(() => {
+      if (timeout !== undefined) clearTimeout(timeout);
+    });
 
     // Prevent unhandled rejection when dispose() cancels requests
     promise.catch(() => {});

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

@@ -49,13 +49,13 @@ export function loadConfig(cwd: string, options?: LoadConfigOptions): LspConfig
   const globalLsp = loadSupiConfigForScope(
     "lsp",
     cwd,
-    { enabled: true, severity: 1, active: [], servers: {} as Record<string, ServerConfig> },
+    { enabled: true, active: [], servers: {} as Record<string, ServerConfig> },
     { scope: "global", homeDir: options?.homeDir },
   );
   const projectLsp = loadSupiConfigForScope(
     "lsp",
     cwd,
-    { enabled: true, severity: 1, active: [], servers: {} as Record<string, ServerConfig> },
+    { enabled: true, active: [], servers: {} as Record<string, ServerConfig> },
     { scope: "project" },
   );
 

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

@@ -10,14 +10,12 @@ import { loadSupiConfig, loadSupiConfigForScope } from "@mrclrchtr/supi-core/con
 
 export interface LspSettings extends Record<string, unknown> {
   enabled: boolean;
-  severity: number;
   active: string[];
   exclude: string[];
 }
 
 export const LSP_DEFAULTS: LspSettings = {
   enabled: true,
-  severity: 1,
   active: [],
   exclude: [],
 };

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

@@ -31,11 +31,11 @@ export type {
   OutstandingDiagnosticSummaryEntry,
   RecoverDiagnosticsResult,
   SemanticReadinessResult,
-  SessionLspServiceState,
   WorkspaceDiagnosticSummaryEntry,
-} from "./session/service-registry.ts";
+  WorkspaceLspRuntime,
+  WorkspaceLspRuntimeState,
+} from "./session/runtime-registry.ts";
 export {
-  getSessionLspService,
-  SessionLspService,
-  waitForSessionLspService,
-} from "./session/service-registry.ts";
+  getWorkspaceLspRuntime,
+  waitForWorkspaceLspRuntime,
+} from "./session/runtime-registry.ts";

package/node_modules/@mrclrchtr/supi-lsp/src/manager/manager-diagnostics.ts

@@ -3,108 +3,18 @@ import type { LspClient } from "../client/client.ts";
 import type { Diagnostic } from "../config/types.ts";
 import { relativeFilePathFromUri } from "../diagnostics/diagnostic-summary.ts";
 import { shouldIgnoreLspPath } from "../summary.ts";
-import { fileToUri, uriToFile } from "../utils.ts";
 import { isExcludedByPattern } from "./manager-helpers.ts";
 
-export interface DiagnosticSnapshotEntry {
-  receivedAt: number;
-  diagnostics: Diagnostic[];
-}
-
-export interface CascadeDiagnosticEntry {
-  uri: string;
-  diagnostics: Diagnostic[];
-}
-
-export interface CascadingDiagnosticsResult {
-  primary: Diagnostic[];
-  cascade: CascadeDiagnosticEntry[];
-}
-
-/**
- * Find diagnostics for open files updated during a sync of another file.
- *
- * Files are considered cascade-affected when their diagnostic cache entry is
- * new or has a newer `receivedAt` timestamp than the pre-sync snapshot.
- */
-export function findCascadeDiagnosticEntries(
-  preSnapshot: Map<string, DiagnosticSnapshotEntry>,
-  postEntries: Map<string, DiagnosticSnapshotEntry>,
-  editedUri: string,
-  maxSeverity: number,
-): CascadeDiagnosticEntry[] {
-  const result: CascadeDiagnosticEntry[] = [];
-
-  for (const [uri, entry] of postEntries) {
-    if (uri === editedUri) continue;
-
-    const previous = preSnapshot.get(uri);
-    if (previous && entry.receivedAt <= previous.receivedAt) continue;
-
-    const diagnostics = filterDiagnosticsBySeverity(entry.diagnostics, maxSeverity);
-    if (diagnostics.length === 0) continue;
-
-    result.push({ uri, diagnostics });
-  }
-
-  return result.sort((a, b) => a.uri.localeCompare(b.uri));
-}
-
-/** Snapshot current diagnostic cache entries for the client's open URIs. */
-export function snapshotOpenClientDiagnostics(
-  client: Pick<LspClient, "openUris" | "getDiagnosticCacheEntry">,
-): Map<string, DiagnosticSnapshotEntry> {
-  const snapshot = new Map<string, DiagnosticSnapshotEntry>();
-
-  for (const uri of client.openUris) {
-    const entry = client.getDiagnosticCacheEntry(uri);
-    if (!entry) continue;
-    snapshot.set(uri, {
-      receivedAt: entry.receivedAt,
-      diagnostics: entry.diagnostics,
-    });
-  }
-
-  return snapshot;
-}
-
-/** Build post-sync entries map for the client's open URIs. */
-export function collectOpenClientDiagnosticEntries(
-  client: Pick<LspClient, "openUris" | "getDiagnosticCacheEntry">,
-): Map<string, DiagnosticSnapshotEntry> {
-  return snapshotOpenClientDiagnostics(client);
-}
-
-/** Sync a file and return its diagnostics plus cascade-affected open files. */
-export async function syncClientFileAndGetCascadingDiagnostics(
-  client: Pick<
-    LspClient,
-    "openUris" | "getDiagnosticCacheEntry" | "syncAndWaitForDiagnostics" | "clearPullResultIds"
-  >,
+/** Sync one file and return diagnostics up to the supplied severity threshold. */
+export async function syncClientFileAndGetDiagnostics(
+  client: Pick<LspClient, "syncAndWaitForDiagnostics">,
   filePath: string,
   maxSeverity: number,
-): Promise<CascadingDiagnosticsResult> {
-  const preSnapshot = snapshotOpenClientDiagnostics(client);
-  const primary = filterDiagnosticsBySeverity(
+): Promise<Diagnostic[]> {
+  return filterDiagnosticsBySeverity(
     await client.syncAndWaitForDiagnostics(filePath, readFileSync(filePath, "utf-8")),
     maxSeverity,
   );
-  client.clearPullResultIds();
-
-  const cascade = findCascadeDiagnosticEntries(
-    preSnapshot,
-    collectOpenClientDiagnosticEntries(client),
-    fileToUri(filePath),
-    maxSeverity,
-  );
-
-  return { primary, cascade };
-}
-
-export function mapCascadeDiagnosticsToFiles(
-  entries: CascadeDiagnosticEntry[],
-): Array<{ file: string; diagnostics: Diagnostic[] }> {
-  return entries.map((entry) => ({ file: uriToFile(entry.uri), diagnostics: entry.diagnostics }));
 }
 
 export function collectOutstandingDiagnosticsDetailed(

package/node_modules/@mrclrchtr/supi-lsp/src/manager/manager-workspace-recovery.ts

@@ -5,7 +5,8 @@ import {
 } from "../diagnostics/stale-diagnostics.ts";
 
 export interface WorkspaceRecoveryResult {
-  refreshedClients: number;
+  /** Active clients targeted by the best-effort refresh, not confirmed successful refreshes. */
+  attemptedClients: number;
   restartedClients: number;
   staleAssessment: StaleDiagnosticAssessment;
 }
@@ -41,7 +42,7 @@ export async function recoverWorkspaceDiagnostics(
     quietMs?: number;
   } = {},
 ): Promise<WorkspaceRecoveryResult> {
-  const refreshedClients = softRecoverWorkspaceDiagnostics(host, options.changes ?? []);
+  const attemptedClients = softRecoverWorkspaceDiagnostics(host, options.changes ?? []);
 
   try {
     await host.refreshOpenDiagnostics({ maxWaitMs: options.maxWaitMs, quietMs: options.quietMs });
@@ -72,7 +73,7 @@ export async function recoverWorkspaceDiagnostics(
   }
 
   return {
-    refreshedClients,
+    attemptedClients,
     restartedClients,
     staleAssessment,
   };