@mrclrchtr/supi-lsp 0.1.0 → 1.1.2

package/src/manager/manager-project-info.ts

@@ -0,0 +1,46 @@
+import type { LspClient } from "../client/client.ts";
+import { displayRelativeFilePath } from "../summary.ts";
+import type { ProjectServerInfo } from "../types.ts";
+
+interface ProjectServerInfoInput {
+  serverName: string;
+  root: string;
+  fileTypes: string[];
+  client: LspClient | undefined;
+  unavailable: boolean;
+}
+
+export function buildProjectServerInfo(
+  input: ProjectServerInfoInput,
+  cwd: string,
+): ProjectServerInfo {
+  const status = input.unavailable
+    ? "unavailable"
+    : input.client?.status === "running"
+      ? "running"
+      : input.client?.status === "error"
+        ? "error"
+        : "unavailable";
+
+  return {
+    name: input.serverName,
+    root: input.root,
+    fileTypes: input.fileTypes,
+    status,
+    supportedActions: getSupportedActions(input.client?.serverCapabilities),
+    openFiles: input.client?.openFiles.map((file) => displayRelativeFilePath(file, cwd)) ?? [],
+  };
+}
+
+function getSupportedActions(capabilities: LspClient["serverCapabilities"] | undefined): string[] {
+  if (!capabilities) return [];
+
+  const actions: string[] = ["diagnostics [optional file]"];
+  if (capabilities.hoverProvider) actions.push("hover(file,line,char)");
+  if (capabilities.definitionProvider) actions.push("definition(file,line,char)");
+  if (capabilities.referencesProvider) actions.push("references(file,line,char)");
+  if (capabilities.documentSymbolProvider) actions.push("symbols(file)");
+  if (capabilities.renameProvider) actions.push("rename(file,line,char,newName)");
+  if (capabilities.codeActionProvider) actions.push("code_actions(file,line,char)");
+  return actions;
+}

package/src/manager/manager-stale-resync.ts

@@ -0,0 +1,47 @@
+import * as path from "node:path";
+import { isLikelyStaleDiagnostic } from "../diagnostics/stale-diagnostics.ts";
+import type { LspManager } from "./manager.ts";
+
+/**
+ * Force re-open files with module-resolution errors (e.g., "Cannot find module")
+ * to trigger fresh analysis by the language server.
+ *
+ * The TypeScript server caches diagnostics by file content hash. When a new
+ * file is created that resolves an existing file's import, the stale diagnostic
+ * persists because the importing file's content hasn't changed. Re-opening the
+ * file (didClose + didOpen) forces the server to re-resolve all imports.
+ *
+ * Returns true if any files were re-synced.
+ */
+export async function forceResyncStaleModuleFiles(
+  manager: LspManager,
+  cwd: string,
+): Promise<boolean> {
+  const outstanding = manager.getOutstandingDiagnostics(1);
+  const staleFiles: string[] = [];
+
+  for (const entry of outstanding) {
+    if (entry.diagnostics.some((d) => isLikelyStaleDiagnostic(d))) {
+      staleFiles.push(entry.file);
+    }
+  }
+
+  if (staleFiles.length === 0) return false;
+
+  for (const file of staleFiles) {
+    const filePath = path.resolve(cwd, file);
+    // Close the file to clear cached diagnostics and remove from openDocs
+    manager.closeFile(filePath);
+    // Re-open to force the server to re-resolve imports
+    await manager.ensureFileOpen(filePath);
+  }
+
+  // Re-sync and wait for fresh diagnostics after the re-opens
+  try {
+    await manager.refreshOpenDiagnostics({ quietMs: 300, maxWaitMs: 2000 });
+  } catch {
+    // Best-effort: don't fail the agent turn if refresh has issues
+  }
+
+  return true;
+}

package/src/manager/manager-types.ts

@@ -0,0 +1,39 @@
+// LSP manager types — shared summaries and status shapes used by UI/guidance.
+
+export interface ServerStatus {
+  name: string;
+  status: "running" | "error" | "unavailable";
+  root: string;
+  openFiles: string[];
+}
+
+export interface DiagnosticSummary {
+  file: string;
+  errors: number;
+  warnings: number;
+}
+
+export interface CoverageSummaryEntry {
+  name: string;
+  fileTypes: string[];
+  active: boolean;
+  openFiles: number;
+}
+
+export interface ActiveCoverageSummaryEntry {
+  name: string;
+  openFiles: string[];
+}
+
+export interface OutstandingDiagnosticSummaryEntry {
+  file: string;
+  total: number;
+  errors: number;
+  warnings: number;
+  information: number;
+  hints: number;
+}
+
+export interface ManagerStatus {
+  servers: ServerStatus[];
+}

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

@@ -0,0 +1,83 @@
+import {
+  assessStaleDiagnostics,
+  type StaleDiagnosticAssessment,
+} from "../diagnostics/stale-diagnostics.ts";
+import type { Diagnostic, FileEvent } from "../types.ts";
+
+export interface WorkspaceRecoveryResult {
+  refreshedClients: number;
+  restartedClients: number;
+  staleAssessment: StaleDiagnosticAssessment;
+}
+
+export interface WorkspaceRecoveryHost {
+  clearAllPullResultIds(): void;
+  notifyWorkspaceFileChanges(changes: FileEvent[]): void;
+  refreshOpenDiagnostics(options?: { maxWaitMs?: number; quietMs?: number }): Promise<void>;
+  getOutstandingDiagnostics(
+    maxSeverity?: number,
+  ): Array<{ file: string; diagnostics: Diagnostic[] }>;
+  getStatus(): { servers: Array<{ status: "running" | "error" | "unavailable" }> };
+  restartClientsForFiles(filePaths: string[]): Promise<string[]>;
+}
+
+/** Clear cached pull IDs and forward watched-file changes to active clients. */
+export function softRecoverWorkspaceDiagnostics(
+  host: WorkspaceRecoveryHost,
+  changes: FileEvent[] = [],
+): number {
+  host.clearAllPullResultIds();
+  if (changes.length > 0) host.notifyWorkspaceFileChanges(changes);
+  return countRunningClients(host);
+}
+
+/** Run a recovery pass, refreshing diagnostics and escalating if stale state remains. */
+export async function recoverWorkspaceDiagnostics(
+  host: WorkspaceRecoveryHost,
+  options: {
+    changes?: FileEvent[];
+    restartIfStillStale?: boolean;
+    maxWaitMs?: number;
+    quietMs?: number;
+  } = {},
+): Promise<WorkspaceRecoveryResult> {
+  const refreshedClients = softRecoverWorkspaceDiagnostics(host, options.changes ?? []);
+
+  try {
+    await host.refreshOpenDiagnostics({ maxWaitMs: options.maxWaitMs, quietMs: options.quietMs });
+  } catch {
+    // Recovery should be best-effort.
+  }
+
+  let staleAssessment = assessStaleDiagnostics(host.getOutstandingDiagnostics(1));
+  let restartedClients = 0;
+
+  if (options.restartIfStillStale && staleAssessment.suspected) {
+    const restarted = await host.restartClientsForFiles(
+      staleAssessment.matchedFiles.map((entry) => entry.file),
+    );
+    restartedClients = restarted.length;
+
+    if (restartedClients > 0) {
+      try {
+        await host.refreshOpenDiagnostics({
+          maxWaitMs: options.maxWaitMs,
+          quietMs: options.quietMs,
+        });
+      } catch {
+        // Keep the previous assessment if the follow-up refresh fails.
+      }
+      staleAssessment = assessStaleDiagnostics(host.getOutstandingDiagnostics(1));
+    }
+  }
+
+  return {
+    refreshedClients,
+    restartedClients,
+    staleAssessment,
+  };
+}
+
+function countRunningClients(host: WorkspaceRecoveryHost): number {
+  return host.getStatus().servers.filter((server) => server.status === "running").length;
+}

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

@@ -0,0 +1,18 @@
+import type { LspClient } from "../client/client.ts";
+import type { SymbolInformation, WorkspaceSymbol } from "../types.ts";
+
+export async function managerWorkspaceSymbol(
+  clients: Iterable<LspClient>,
+  query: string,
+): Promise<(SymbolInformation | WorkspaceSymbol)[] | null> {
+  const all: (SymbolInformation | WorkspaceSymbol)[] = [];
+  let hasSupport = false;
+  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) all.push(...result);
+  }
+  return hasSupport ? all : null;
+}