@mrclrchtr/supi-lsp 3.2.0 → 4.1.0

package/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/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,
   };

package/src/manager/manager-workspace-symbol.ts

@@ -1,5 +1,11 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import {
+  type CodeQueryResult,
+  completedCodeQuery,
+  partialCodeQuery,
+  unavailableCodeQuery,
+} from "@mrclrchtr/supi-code-runtime/api";
 import { walkProject } from "@mrclrchtr/supi-core/project";
 import type { LspClient } from "../client/client.ts";
 import type {
@@ -39,30 +45,62 @@ export function getWorkspaceSymbolWarmPosition(
   return null;
 }
 
+export interface WorkspaceSymbolCollection {
+  results: WorkspaceSymbolLike[];
+  hasSupport: boolean;
+  completedClientCount: number;
+  failures: string[];
+}
+
 export async function collectWorkspaceSymbols(
   clients: Iterable<LspClient>,
   query: string,
-): Promise<{ results: WorkspaceSymbolLike[]; hasSupport: boolean }> {
+): Promise<WorkspaceSymbolCollection> {
   const results: WorkspaceSymbolLike[] = [];
+  const failures: string[] = [];
   let hasSupport = false;
+  let completedClientCount = 0;
 
   for (const client of clients) {
     if (client.status !== "running") continue;
     if (!client.serverCapabilities?.workspaceSymbolProvider) continue;
     hasSupport = true;
     const result = await client.workspaceSymbol(query);
-    if (result) results.push(...result);
+    if (result.kind === "unavailable") {
+      failures.push(result.reason);
+      continue;
+    }
+    completedClientCount++;
+    results.push(...(result.data ?? []));
+    if (result.kind === "partial") failures.push(result.reason);
   }
 
-  return { results, hasSupport };
+  return { results, hasSupport, completedClientCount, failures };
+}
+
+/** Project one multi-client collection into the shared typed query contract. */
+export function workspaceSymbolCollectionResult(
+  collection: WorkspaceSymbolCollection,
+): CodeQueryResult<WorkspaceSymbolLike[]> {
+  if (!collection.hasSupport) {
+    return unavailableCodeQuery("No active LSP client supports workspace-symbol requests.");
+  }
+  if (collection.completedClientCount === 0) {
+    return unavailableCodeQuery(
+      collection.failures.join("; ") || "No workspace-symbol request completed.",
+    );
+  }
+  if (collection.failures.length > 0) {
+    return partialCodeQuery(collection.results, collection.failures.join("; "));
+  }
+  return completedCodeQuery(collection.results);
 }
 
 export async function managerWorkspaceSymbol(
   clients: Iterable<LspClient>,
   query: string,
-): Promise<WorkspaceSymbolLike[] | null> {
-  const { results, hasSupport } = await collectWorkspaceSymbols(clients, query);
-  return hasSupport ? results : null;
+): Promise<CodeQueryResult<WorkspaceSymbolLike[]>> {
+  return workspaceSymbolCollectionResult(await collectWorkspaceSymbols(clients, query));
 }
 
 export function findWorkspaceSymbolWarmTargets(

package/src/manager/manager.ts

@@ -2,6 +2,7 @@
 // biome-ignore-all lint/style/noExcessiveLinesPerFile: LspManager stays cohesive; recovery and sync helpers are split into manager-*.ts modules.
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { type CodeQueryResult, unavailableCodeQuery } from "@mrclrchtr/supi-code-runtime/api";
 import * as projectRoots from "@mrclrchtr/supi-core/project";
 import { LspClient } from "../client/client.ts";
 import { getServerForFile } from "../config/config.ts";
@@ -36,8 +37,7 @@ import {
 } from "./manager-client-state.ts";
 import {
   collectOutstandingDiagnosticsDetailed,
-  mapCascadeDiagnosticsToFiles,
-  syncClientFileAndGetCascadingDiagnostics,
+  syncClientFileAndGetDiagnostics,
 } from "./manager-diagnostics.ts";
 import {
   clientKey,
@@ -56,8 +56,11 @@ import type {
 } from "./manager-types.ts";
 import { recoverWorkspaceDiagnostics as recoverWorkspaceDiagnosticsImpl } from "./manager-workspace-recovery.ts";
 import {
+  collectWorkspaceSymbols,
   findWorkspaceSymbolWarmTargets,
   getWorkspaceSymbolWarmPosition,
+  type WorkspaceSymbolCollection,
+  workspaceSymbolCollectionResult,
 } from "./manager-workspace-symbol.ts";
 
 type UnavailableReason = "missing-command" | "start-failed" | "runtime-error";
@@ -361,8 +364,11 @@ export class LspManager {
     return client;
   }
 
-  /** Wait until all started clients are query-ready, then warm one project file per client/root. */
-  async waitUntilWorkspaceReady(): Promise<void> {
+  /**
+   * Wait until all started clients are query-ready, then warm one project file per client/root.
+   * Returns the number of concrete clients that reached readiness.
+   */
+  async waitUntilWorkspaceReady(): Promise<number> {
     const activeClients = Array.from(this.clients.values()).filter(
       (client) => client.status === "running",
     );
@@ -379,38 +385,26 @@ export class LspManager {
       if (!target) continue;
       await this.warmSemanticProject(client, target.file);
     }
+    return activeClients.length;
   }
   async syncFileAndGetDiagnostics(
     filePath: string,
     maxSeverity: number = 1,
-  ): Promise<Diagnostic[]> {
-    const resolvedPath = resolveSessionPath(this.cwd, filePath);
-    return (
-      (await this.syncFileAndGetCascadingDiagnostics(resolvedPath, maxSeverity)).find(
-        (entry) => entry.file === resolvedPath,
-      )?.diagnostics ?? []
-    );
-  }
-  async syncFileAndGetCascadingDiagnostics(
-    filePath: string,
-    maxSeverity: number = 1,
-  ): Promise<Array<{ file: string; diagnostics: Diagnostic[] }>> {
+  ): Promise<CodeQueryResult<Diagnostic[]>> {
     const resolvedPath = resolveSessionPath(this.cwd, filePath);
     const client = await this.getClientForFile(resolvedPath);
-    if (!client) return [];
+    if (!client) {
+      return unavailableCodeQuery(`No LSP client can collect diagnostics for ${resolvedPath}.`);
+    }
     try {
-      const { primary, cascade } = await syncClientFileAndGetCascadingDiagnostics(
-        client,
-        resolvedPath,
-        maxSeverity,
-      );
-      return [
-        ...(primary.length > 0 ? [{ file: resolvedPath, diagnostics: primary }] : []),
-        ...mapCascadeDiagnosticsToFiles(cascade),
-      ];
-    } catch {
+      return {
+        kind: "completed",
+        data: await syncClientFileAndGetDiagnostics(client, resolvedPath, maxSeverity),
+      };
+    } catch (error) {
       this.closeFile(resolvedPath);
-      return [];
+      const detail = error instanceof Error ? error.message : String(error);
+      return unavailableCodeQuery(`Diagnostic collection failed for ${resolvedPath}: ${detail}`);
     }
   }
   /** Close a file across any active LSP clients and clear its cached diagnostics. */
@@ -447,7 +441,7 @@ export class LspManager {
     maxWaitMs?: number;
     quietMs?: number;
   }): Promise<{
-    refreshedClients: number;
+    attemptedClients: number;
     restartedClients: number;
     staleAssessment: {
       suspected: boolean;
@@ -613,21 +607,21 @@ export class LspManager {
       maxSeverity,
     );
   }
-  async workspaceSymbol(query: string): Promise<(SymbolInformation | WorkspaceSymbol)[] | null> {
-    const helper = await import("./manager-workspace-symbol.ts");
-    const initial = await helper.collectWorkspaceSymbols(this.clients.values(), query);
-    if (!initial.hasSupport) return null;
-    if (initial.results.length > 0) return initial.results;
+  async workspaceSymbol(
+    query: string,
+  ): Promise<CodeQueryResult<(SymbolInformation | WorkspaceSymbol)[]>> {
+    const initial = await collectWorkspaceSymbols(this.clients.values(), query);
+    if (!initial.hasSupport || initial.results.length > 0) {
+      return workspaceSymbolCollectionResult(initial);
+    }
 
     const warmed = await this.warmWorkspaceSymbolProjectsUntilResult(
-      helper.findWorkspaceSymbolWarmTargets,
-      helper.getWorkspaceSymbolWarmPosition,
-      helper.collectWorkspaceSymbols,
+      findWorkspaceSymbolWarmTargets,
+      getWorkspaceSymbolWarmPosition,
+      collectWorkspaceSymbols,
       query,
     );
-    if (warmed.results) return warmed.results;
-
-    return initial.results;
+    return workspaceSymbolCollectionResult(warmed.collection ?? initial);
   }
   async ensureFileOpen(filePath: string): Promise<LspClient | null> {
     const resolvedPath = resolveSessionPath(this.cwd, filePath);
@@ -650,14 +644,11 @@ export class LspManager {
       fileTypes: string[],
     ) => Array<{ projectRoot: string; file: string }>,
     getWarmPosition: (
-      symbols: Awaited<ReturnType<LspClient["documentSymbols"]>>,
+      symbols: import("../config/types.ts").DocumentSymbol[] | SymbolInformation[] | null,
     ) => import("../config/types.ts").Position | null,
-    collect: (
-      clients: Iterable<LspClient>,
-      query: string,
-    ) => Promise<{ results: (SymbolInformation | WorkspaceSymbol)[]; hasSupport: boolean }>,
+    collect: (clients: Iterable<LspClient>, query: string) => Promise<WorkspaceSymbolCollection>,
     query: string,
-  ): Promise<{ warmedAny: boolean; results: (SymbolInformation | WorkspaceSymbol)[] | null }> {
+  ): Promise<{ warmedAny: boolean; collection: WorkspaceSymbolCollection | null }> {
     let warmedAny = false;
 
     for (const client of Array.from(this.clients.values())) {
@@ -687,24 +678,20 @@ export class LspManager {
         this.warmedWorkspaceSymbolProjects.add(projectKey);
         warmedAny = true;
 
-        try {
-          const symbols = await openedClient.documentSymbols(target.file);
-          const hoverPosition = getWarmPosition(symbols);
-          if (hoverPosition) {
-            await openedClient.hover(target.file, hoverPosition);
-          }
-        } catch {
-          // Best-effort warm-up only.
+        const symbols = await openedClient.documentSymbols(target.file);
+        if (symbols.kind !== "unavailable") {
+          const hoverPosition = getWarmPosition(symbols.data);
+          if (hoverPosition) await openedClient.hover(target.file, hoverPosition);
         }
 
         const collected = await collect(this.clients.values(), query);
         if (collected.hasSupport && collected.results.length > 0) {
-          return { warmedAny, results: collected.results };
+          return { warmedAny, collection: collected };
         }
       }
     }
 
-    return { warmedAny, results: null };
+    return { warmedAny, collection: null };
   }
 
   private async warmSemanticProject(
@@ -750,15 +737,10 @@ export class LspManager {
 
     this.warmedSemanticProjects.add(projectKey);
 
-    try {
-      const symbols = await openedClient.documentSymbols(resolvedFile);
-      const hoverPosition = getWorkspaceSymbolWarmPosition(symbols);
-      if (hoverPosition) {
-        await openedClient.hover(resolvedFile, hoverPosition);
-      }
-    } catch {
-      // Best-effort warm-up only.
-    }
+    const symbols = await openedClient.documentSymbols(resolvedFile);
+    if (symbols.kind === "unavailable") return;
+    const hoverPosition = getWorkspaceSymbolWarmPosition(symbols.data);
+    if (hoverPosition) await openedClient.hover(resolvedFile, hoverPosition);
   }
 
   private hasOpenFileInProject(client: LspClient, projectRoot: string): boolean {