@mrclrchtr/supi-lsp 1.7.0 → 1.9.0

package/src/lsp.ts

@@ -1,75 +1,25 @@
-// LSP Extension for pi — registers an expert semantic toolset, keeps language servers warm,
-// surfaces inline diagnostics, and injects diagnostic context only when outstanding issues exist.
-// biome-ignore-all lint/nursery/noExcessiveLinesPerFile: lsp.ts stays cohesive wiring; recovery and sentinel helpers live in focused modules.
-
-import * as path from "node:path";
-import type {
-  AgentEndEvent,
-  BeforeAgentStartEvent,
-  BeforeAgentStartEventResult,
-  ContextEvent,
-  ExtensionAPI,
-  ExtensionContext,
-  SessionStartEvent,
-  ToolResultEvent,
-} from "@earendil-works/pi-coding-agent";
-import { pruneAndReorderContextMessages, restorePromptContent } from "@mrclrchtr/supi-core/api";
-import { loadConfig, resolveLanguageAlias } from "./config/config.ts";
-import { clearTsconfigCache } from "./config/tsconfig-scope.ts";
-import { FileChangeType, type FileEvent } from "./config/types.ts";
-import {
-  diagnosticsContextFingerprint,
-  formatDiagnosticsContext,
-  MAX_DETAILED_DIAGNOSTICS,
-} from "./diagnostics/diagnostic-context.ts";
-import { formatDiagnosticsDisplayContent } from "./diagnostics/diagnostic-display.ts";
-import { assessStaleDiagnostics } from "./diagnostics/stale-diagnostics.ts";
-import {
-  isWorkspaceRecoveryTrigger,
-  scanWorkspaceSentinels,
-  syncWorkspaceSentinelSnapshot,
-} from "./diagnostics/workspace-sentinels.ts";
-import { LspManager } from "./manager/manager.ts";
-import { forceResyncStaleModuleFiles } from "./manager/manager-stale-resync.ts";
-import {
-  createRuntimeState,
-  disableLspState,
-  ensureLspToolsActive,
-  isLspAwareTool,
-  type LspRuntimeState,
-  refreshProjectServers,
-  removeLspTools,
-} from "./session/lsp-state.ts";
-import {
-  scanMissingServers,
-  scanProjectCapabilities,
-  startDetectedServers,
-} from "./session/scanner.ts";
-import {
-  clearSessionLspService,
-  SessionLspService,
-  setSessionLspServiceState,
-} from "./session/service-registry.ts";
-import {
-  getLspDisabledMessage,
-  loadLspSettings,
-  registerLspSettings,
-} from "./session/settings-registration.ts";
-import {
-  persistLspActiveState,
-  persistLspInactiveState,
-  registerTreePersistHandlers,
-} from "./session/tree-persist.ts";
-import { buildLspToolPromptSurfaces, defaultLspToolPromptSurfaces } from "./tool/guidance.ts";
+// LSP Extension for pi — wires together the expert semantic toolset and all
+// event/behaviour handlers. Handler registration is delegated to focused
+// modules so each orchestration concern lives in its own file.
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { getDefaultWorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
+import { registerDiagnosticInjectionHandlers } from "./handlers/diagnostic-injection.ts";
+import { registerSessionLifecycleHandlers } from "./handlers/session-lifecycle.ts";
+import { registerLspStatusCommand } from "./handlers/status-command.ts";
+import { registerWorkspaceRecoveryHandler } from "./handlers/workspace-recovery.ts";
+import { createRuntimeState } from "./session/lsp-state.ts";
+import { registerLspSettings } from "./session/settings-registration.ts";
+import { registerTreePersistHandlers } from "./session/tree-persist.ts";
+import { defaultLspToolPromptSurfaces } from "./tool/guidance.ts";
 import { registerLspAwareToolOverrides } from "./tool/overrides.ts";
 import { registerLspTools } from "./tool/register-tools.ts";
 import { registerLspMessageRenderer } from "./ui/renderer.ts";
-import { toggleLspStatusOverlay, updateLspUi } from "./ui/ui.ts";
-import { fileToUri, resolveSessionPath } from "./utils.ts";
 
 export default function lspExtension(pi: ExtensionAPI) {
   registerLspSettings();
   const state = createRuntimeState();
+  const runtime = getDefaultWorkspaceRuntime();
 
   registerLspAwareToolOverrides(pi, {
     getInlineSeverity: () => state.inlineSeverity,
@@ -78,356 +28,10 @@ export default function lspExtension(pi: ExtensionAPI) {
   });
 
   registerLspTools(pi, defaultLspToolPromptSurfaces);
-  registerSessionLifecycleHandlers(pi, state);
-  registerBehaviorHandlers(pi, state);
+  registerSessionLifecycleHandlers(pi, state, runtime);
+  registerDiagnosticInjectionHandlers(pi, state);
+  registerWorkspaceRecoveryHandler(pi, state);
   registerTreePersistHandlers(pi, state);
   registerLspStatusCommand(pi, state);
   registerLspMessageRenderer(pi);
 }
-
-function registerSessionLifecycleHandlers(pi: ExtensionAPI, state: LspRuntimeState): void {
-  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: session_start orchestrates setup, server detection, settings, and persistence.
-  pi.on("session_start", async (_event: SessionStartEvent, ctx: ExtensionContext) => {
-    if (state.manager) {
-      clearSessionLspService(state.manager.getCwd());
-      await state.manager.shutdownAll();
-    }
-
-    const cwd = ctx.cwd;
-    clearTsconfigCache();
-    const lspSettings = loadLspSettings(cwd);
-
-    if (!lspSettings.enabled) {
-      clearSessionLspService(cwd);
-      disableLspState(pi, state);
-      persistLspInactiveState(pi, state);
-      setSessionLspServiceState(cwd, { kind: "disabled" });
-      return;
-    }
-
-    state.inlineSeverity = lspSettings.severity;
-
-    const config = loadConfig(cwd);
-
-    // Apply server allowlist filter from supi shared config
-    if (lspSettings.active.length > 0) {
-      const allowList = new Set(lspSettings.active.map(resolveLanguageAlias));
-      for (const name of Object.keys(config.servers)) {
-        if (!allowList.has(name)) {
-          delete config.servers[name];
-        }
-      }
-    }
-
-    clearSessionLspService(cwd);
-    state.manager = new LspManager(config, cwd);
-    state.manager.setExcludePatterns(lspSettings.exclude ?? []);
-    setSessionLspServiceState(cwd, { kind: "pending" });
-    state.detectedServers = scanProjectCapabilities(config, cwd);
-    state.manager.registerDetectedServers(state.detectedServers);
-    await startDetectedServers(state.manager, state.detectedServers);
-
-    const missing = scanMissingServers(config, cwd);
-    if (missing.length > 0) {
-      const parts = missing.map((m) => `${m.name} (${m.command})`);
-      ctx.ui.notify(
-        `LSP server not found for: ${parts.join(", ")}. Install the server to enable language intelligence.`,
-        "warning",
-      );
-    }
-
-    state.sentinelSnapshot = scanWorkspaceSentinels(cwd);
-    state.lastWorkspaceChangeAt = 0;
-    state.staleSuspected = false;
-    refreshProjectServers(state);
-    state.lastDiagnosticsFingerprint = null;
-    state.currentContextToken = null;
-    state.lspActive = true;
-    setSessionLspServiceState(cwd, {
-      kind: "ready",
-      service: new SessionLspService(state.manager),
-    });
-    registerLspTools(pi, buildLspToolPromptSurfaces(state.projectServers, cwd));
-    ensureLspToolsActive(pi);
-    persistLspActiveState(pi, state);
-    updateLspUi(ctx, state.manager, state.inlineSeverity, state.projectServers);
-  });
-
-  pi.on("session_shutdown", async () => {
-    clearTsconfigCache();
-    if (state.manager) {
-      clearSessionLspService(state.manager.getCwd());
-      await state.manager.shutdownAll();
-      state.manager = null;
-    }
-
-    state.inspector.close?.();
-    state.detectedServers = [];
-    state.projectServers = [];
-    state.lastDiagnosticsFingerprint = null;
-    state.currentContextToken = null;
-    state.staleSuspected = false;
-    state.lastWorkspaceChangeAt = 0;
-    state.sentinelSnapshot = new Map();
-  });
-
-  pi.on("agent_end", async (_event: AgentEndEvent, ctx: ExtensionContext) => {
-    state.currentContextToken = null;
-    refreshProjectServers(state);
-
-    if (state.manager) {
-      updateLspUi(ctx, state.manager, state.inlineSeverity, state.projectServers);
-    }
-  });
-}
-
-function markWorkspaceChange(state: LspRuntimeState): void {
-  state.lastWorkspaceChangeAt = Date.now();
-  state.staleSuspected = true;
-  state.lastDiagnosticsFingerprint = null;
-  state.currentContextToken = null;
-}
-
-function softRecoverWorkspaceChanges(
-  state: LspRuntimeState,
-  changes: import("./config/types.ts").FileEvent[],
-): boolean {
-  if (!state.manager || changes.length === 0) return false;
-
-  clearTsconfigCache();
-  state.manager.clearAllPullResultIds();
-  state.manager.notifyWorkspaceFileChanges(changes);
-  markWorkspaceChange(state);
-  return true;
-}
-
-function refreshWorkspaceSentinels(state: LspRuntimeState, cwd: string): boolean {
-  const { snapshot, changes } = syncWorkspaceSentinelSnapshot(cwd, state.sentinelSnapshot);
-  state.sentinelSnapshot = snapshot;
-  return softRecoverWorkspaceChanges(state, changes);
-}
-
-function shouldInvalidateTsconfigScopeCache(filePath: string): boolean {
-  const ext = path.extname(filePath).toLowerCase();
-  return ext === ".json" || ext === ".jsonc";
-}
-
-function recoverWorkspaceChangesFromToolResult(
-  state: LspRuntimeState,
-  cwd: string,
-  event: { toolName: string; isError: boolean; input?: unknown },
-): boolean {
-  if (!state.manager || event.isError) return false;
-  if (event.toolName !== "write" && event.toolName !== "edit") return false;
-  if (!event.input || typeof event.input !== "object") return false;
-
-  const pathValue = (event.input as { path?: unknown }).path;
-  if (typeof pathValue !== "string") return false;
-
-  const resolvedPath = resolveSessionPath(cwd, pathValue);
-  if (shouldInvalidateTsconfigScopeCache(resolvedPath)) {
-    clearTsconfigCache();
-  }
-  const fileEvent: FileEvent = { uri: fileToUri(resolvedPath), type: FileChangeType.Changed };
-
-  // Sentinel files (package.json, tsconfig.json, lockfiles, .d.ts)
-  if (isWorkspaceRecoveryTrigger(resolvedPath, cwd)) {
-    if (resolvedPath.endsWith(".d.ts")) {
-      return softRecoverWorkspaceChanges(state, [fileEvent]);
-    }
-
-    const { snapshot, changes } = syncWorkspaceSentinelSnapshot(cwd, state.sentinelSnapshot);
-    state.sentinelSnapshot = snapshot;
-    return softRecoverWorkspaceChanges(state, changes.length > 0 ? changes : [fileEvent]);
-  }
-
-  // Source files matching an active language server's file types
-  if (state.manager.hasServerForExtension(resolvedPath)) {
-    return softRecoverWorkspaceChanges(state, [fileEvent]);
-  }
-
-  return false;
-}
-
-/** Build the `lsp-context` custom message used to surface outstanding diagnostics. */
-// biome-ignore lint/complexity/useMaxParams: wrapper groups the prompt payload fields in one place.
-function buildDiagnosticResult(
-  diagnostics: import("./manager/manager-types.ts").OutstandingDiagnosticSummaryEntry[],
-  detailed: { file: string; diagnostics: import("./config/types.ts").Diagnostic[] }[] | undefined,
-  severity: number,
-  token: string,
-  staleWarning?: string | null,
-): BeforeAgentStartEventResult {
-  return {
-    message: {
-      customType: "lsp-context",
-      content: formatDiagnosticsDisplayContent(diagnostics, detailed),
-      display: true,
-      details: {
-        contextToken: token,
-        promptContent: formatDiagnosticsContext(diagnostics, 3, detailed, staleWarning),
-        inlineSeverity: severity,
-        ...(staleWarning ? { staleWarning } : {}),
-        diagnostics: diagnostics.map((d) => ({
-          file: d.file,
-          errors: d.errors,
-          warnings: d.warnings,
-          information: d.information,
-          hints: d.hints,
-        })),
-      },
-    },
-  };
-}
-
-function registerBehaviorHandlers(pi: ExtensionAPI, state: LspRuntimeState): void {
-  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: before_agent_start coordinates sentinel recovery, pruning, refresh, and diagnostic injection.
-  pi.on("before_agent_start", async (_event: BeforeAgentStartEvent, ctx: ExtensionContext) => {
-    if (!state.manager || !state.lspActive) {
-      removeLspTools(pi);
-      if (!state.manager && state.lspActive) {
-        persistLspInactiveState(pi, state);
-      }
-      return;
-    }
-
-    ensureLspToolsActive(pi);
-
-    refreshWorkspaceSentinels(state, ctx.cwd);
-
-    /**
-     * Two-pass prune/refresh pattern:
-     *
-     * 1. Prune files deleted since the last turn and send didClose.
-     * 2. Re-sync remaining open docs and wait for diagnostics to settle.
-     * 3. Prune *again* — late publishDiagnostics notifications (already
-     *    in-flight when step 1 ran) may have re-created stale entries for
-     *    files that no longer exist. `getAllDiagnostics()` also filters
-     *    by existence, so this second pass is belt-and-suspenders.
-     */
-    state.manager.pruneMissingFiles();
-    try {
-      await state.manager.refreshOpenDiagnostics();
-    } catch {
-      // Refresh failures must not prevent agent startup
-    }
-    state.manager.pruneMissingFiles();
-
-    // Force re-open files with module-resolution errors to clear stale
-    // diagnostics that persist when the TS server caches by content hash.
-    // Must run before the diagnostic summary so fresh results are captured.
-    try {
-      await forceResyncStaleModuleFiles(state.manager, ctx.cwd);
-    } catch {
-      // Best-effort: don't fail the agent turn
-    }
-
-    refreshProjectServers(state);
-    updateLspUi(ctx, state.manager, state.inlineSeverity, state.projectServers);
-
-    const diagnostics = state.manager.getOutstandingDiagnosticSummary(state.inlineSeverity);
-    const totalDiags = diagnostics.reduce((sum, d) => sum + d.total, 0);
-    const detailed =
-      totalDiags <= MAX_DETAILED_DIAGNOSTICS
-        ? state.manager.getOutstandingDiagnostics(state.inlineSeverity)
-        : undefined;
-    const staleAssessment = state.staleSuspected
-      ? assessStaleDiagnostics(state.manager.getOutstandingDiagnostics(4))
-      : { suspected: false, matchedFiles: [], warning: null };
-    state.staleSuspected = staleAssessment.suspected;
-
-    const staleWarning = staleAssessment.suspected ? staleAssessment.warning : null;
-    const content = formatDiagnosticsContext(diagnostics, 3, detailed, staleWarning);
-    const fingerprint = diagnosticsContextFingerprint(content);
-
-    if (!content) {
-      state.lastDiagnosticsFingerprint = null;
-      state.currentContextToken = null;
-      return;
-    }
-
-    if (fingerprint === state.lastDiagnosticsFingerprint) {
-      state.currentContextToken = null;
-      return;
-    }
-
-    state.lastDiagnosticsFingerprint = fingerprint;
-    state.currentContextToken = `lsp-context-${++state.contextCounter}`;
-
-    return buildDiagnosticResult(
-      diagnostics,
-      detailed,
-      state.inlineSeverity,
-      state.currentContextToken,
-      staleWarning,
-    );
-  });
-
-  pi.on("context", (event: ContextEvent) => {
-    const messages = pruneAndReorderContextMessages(
-      event.messages as Array<{
-        role?: string;
-        customType?: string;
-        content?: unknown;
-        details?: unknown;
-      }>,
-      "lsp-context",
-      state.currentContextToken,
-    );
-    const contextMessages = restorePromptContent(
-      messages,
-      "lsp-context",
-      state.currentContextToken,
-    ) as typeof event.messages;
-
-    if (
-      contextMessages.length === event.messages.length &&
-      contextMessages.every((message, index) => message === event.messages[index])
-    ) {
-      return;
-    }
-    return { messages: contextMessages };
-  });
-
-  pi.on("tool_result", async (event: ToolResultEvent, ctx: ExtensionContext) => {
-    if (!state.manager) return;
-
-    const recoveryTriggered = recoverWorkspaceChangesFromToolResult(state, ctx.cwd, {
-      toolName: event.toolName,
-      isError: event.isError,
-      input: (event as { input?: unknown }).input,
-    });
-
-    if (recoveryTriggered || isLspAwareTool(event.toolName)) {
-      refreshProjectServers(state);
-      updateLspUi(ctx, state.manager, state.inlineSeverity, state.projectServers);
-    }
-  });
-}
-
-function registerLspStatusCommand(pi: ExtensionAPI, state: LspRuntimeState): void {
-  pi.registerCommand("lsp-status", {
-    description: "Show detected LSP servers, roots, open files, and diagnostics",
-    handler: async (_args: string, ctx: ExtensionContext) => {
-      const lspSettings = loadLspSettings(ctx.cwd);
-      if (!lspSettings.enabled) {
-        ctx.ui.notify(getLspDisabledMessage(ctx.cwd), "warning");
-        return;
-      }
-
-      if (!state.manager) {
-        ctx.ui.notify("LSP not initialized", "warning");
-        return;
-      }
-
-      refreshProjectServers(state);
-      toggleLspStatusOverlay(
-        ctx,
-        state.manager,
-        state.inlineSeverity,
-        state.inspector,
-        state.projectServers,
-      );
-    },
-  });
-}

package/src/manager/capability-index.ts

@@ -0,0 +1,24 @@
+// Capability index — indexes and queries server capabilities.
+
+import type { ServerCapabilities } from "../config/types.ts";
+import { getSupportedLspServerActions } from "../tool/tool-specs.ts";
+import type { LspManager } from "./manager.ts";
+
+/**
+ * Indexes and queries what each server supports.
+ */
+export interface CapabilityIndex {
+  /** Get the list of supported LSP actions for a server's capabilities. */
+  getSupportedActions(capabilities: ServerCapabilities | null | undefined): string[];
+}
+
+/**
+ * Create a CapabilityIndex for a workspace.
+ */
+export function createCapabilityIndex(_manager: LspManager): CapabilityIndex {
+  return {
+    getSupportedActions(capabilities) {
+      return getSupportedLspServerActions(capabilities);
+    },
+  };
+}

package/src/manager/client-pool.ts

@@ -0,0 +1,33 @@
+// Client pool — manages LSP client lifecycle (start, stop, reconnect).
+
+import type { LspManager } from "./manager.ts";
+
+/**
+ * Manages the lifecycle of LSP client instances for a workspace.
+ * Currently delegates to LspManager; the extraction will grow
+ * as responsibilities are migrated from manager.ts.
+ */
+export interface ClientPool {
+  /**
+   * Ensure a file has an active client and return it.
+   * Returns null if no server can serve the file.
+   */
+  ensureFileOpen(filePath: string): ReturnType<LspManager["ensureFileOpen"]>;
+
+  /** Shut down all active clients. */
+  shutdownAll(): Promise<void>;
+}
+
+/**
+ * Create a ClientPool backed by LspManager.
+ */
+export function createClientPool(manager: LspManager): ClientPool {
+  return {
+    async ensureFileOpen(filePath: string) {
+      return manager.ensureFileOpen(filePath);
+    },
+    async shutdownAll() {
+      return manager.shutdownAll();
+    },
+  };
+}

package/src/manager/diagnostic-store.ts

@@ -0,0 +1,51 @@
+// Diagnostic store — stores, aggregates, and queries diagnostics.
+
+import type { Diagnostic } from "../config/types.ts";
+import type { LspManager } from "./manager.ts";
+
+/**
+ * Stores and queries diagnostics per file.
+ * Currently delegates to LspManager methods.
+ */
+export interface DiagnosticStore {
+  /** Get workspace diagnostic summary grouped by file. */
+  getDiagnosticSummary(): Array<{ file: string; errors: number; warnings: number }>;
+
+  /** Get outstanding diagnostics at or above severity. */
+  getOutstandingDiagnostics(
+    maxSeverity?: number,
+  ): Array<{ file: string; diagnostics: Diagnostic[] }>;
+
+  /** Get outstanding diagnostic summary grouped by file. */
+  getOutstandingDiagnosticSummary(maxSeverity?: number): Array<{
+    file: string;
+    total: number;
+    errors: number;
+    warnings: number;
+    information: number;
+    hints: number;
+  }>;
+
+  /** Sync a file and return its diagnostics. */
+  syncAndGetDiagnostics(filePath: string, maxSeverity?: number): Promise<Diagnostic[] | null>;
+}
+
+/**
+ * Create a DiagnosticStore backed by LspManager.
+ */
+export function createDiagnosticStore(manager: LspManager): DiagnosticStore {
+  return {
+    getDiagnosticSummary() {
+      return manager.getDiagnosticSummary();
+    },
+    getOutstandingDiagnostics(maxSeverity = 1) {
+      return manager.getOutstandingDiagnostics(maxSeverity);
+    },
+    getOutstandingDiagnosticSummary(maxSeverity = 1) {
+      return manager.getOutstandingDiagnosticSummary(maxSeverity);
+    },
+    async syncAndGetDiagnostics(filePath: string, maxSeverity = 4) {
+      return manager.syncFileAndGetDiagnostics(filePath, maxSeverity);
+    },
+  };
+}

package/src/manager/manager-helpers.ts

@@ -1,5 +1,5 @@
 import * as path from "node:path";
-import * as projectRoots from "@mrclrchtr/supi-core/api";
+import * as projectRoots from "@mrclrchtr/supi-core/project";
 import { isGlobMatch } from "../pattern-matcher.ts";
 import { resolveSessionPath } from "../utils.ts";
 

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

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { walkProject } from "@mrclrchtr/supi-core/api";
+import { walkProject } from "@mrclrchtr/supi-core/project";
 import type { LspClient } from "../client/client.ts";
 import type {
   DocumentSymbol,

package/src/manager/manager.ts

@@ -2,7 +2,7 @@
 // biome-ignore-all lint/nursery/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 * as projectRoots from "@mrclrchtr/supi-core/api";
+import * as projectRoots from "@mrclrchtr/supi-core/project";
 import { LspClient } from "../client/client.ts";
 import { getServerForFile } from "../config/config.ts";
 import type {

package/src/manager/recovery-coordinator.ts

@@ -0,0 +1,37 @@
+// Recovery coordinator — orchestrates stale diagnostic recovery.
+
+import type { LspManager } from "./manager.ts";
+
+/**
+ * Orchestrates stale diagnostic detection and recovery.
+ */
+export interface RecoveryCoordinator {
+  /**
+   * Trigger a workspace-wide diagnostics refresh.
+   * Returns info about refreshed/restarted clients and stale assessment.
+   */
+  recover(options?: {
+    restartIfStillStale?: boolean;
+    maxWaitMs?: number;
+    quietMs?: number;
+  }): Promise<{
+    refreshedClients: number;
+    restartedClients: number;
+    staleAssessment: {
+      suspected: boolean;
+      matchedFiles: Array<{ file: string; diagnostics: unknown[] }>;
+      warning: string | null;
+    };
+  }>;
+}
+
+/**
+ * Create a RecoveryCoordinator backed by LspManager.
+ */
+export function createRecoveryCoordinator(manager: LspManager): RecoveryCoordinator {
+  return {
+    async recover(options) {
+      return manager.recoverWorkspaceDiagnostics(options);
+    },
+  };
+}

package/src/manager/workspace-router.ts

@@ -0,0 +1,44 @@
+// Workspace router — routes files to the correct LSP client based on project root.
+
+import type { ProjectServerInfo } from "../config/server-config.ts";
+import type { LspManager } from "./manager.ts";
+
+/**
+ * Routes file paths to the correct LSP client and tracks
+ * which project roots are known.
+ */
+export interface WorkspaceRouter {
+  /** Check whether a file can be served by any active server. */
+  canServeFile(filePath: string): boolean;
+
+  /** Check whether a source file type is supported. */
+  isSupportedSourceFile(filePath: string): boolean;
+
+  /** Get known project server info. */
+  getProjectServers(): ProjectServerInfo[];
+
+  /** Register detected servers from the workspace scan. */
+  registerDetectedServers(servers: Array<{ language: string; root: string }>): void;
+}
+
+/**
+ * Create a WorkspaceRouter backed by LspManager.
+ */
+export function createWorkspaceRouter(manager: LspManager): WorkspaceRouter {
+  return {
+    canServeFile(filePath: string) {
+      return manager.canServeFile(filePath);
+    },
+    isSupportedSourceFile(filePath: string) {
+      return manager.isSupportedSourceFile(filePath);
+    },
+    getProjectServers(): ProjectServerInfo[] {
+      return manager.getKnownProjectServers([]);
+    },
+    registerDetectedServers(servers: Array<{ language: string; root: string }>) {
+      manager.registerDetectedServers(
+        servers as unknown as Parameters<typeof manager.registerDetectedServers>[0],
+      );
+    },
+  };
+}