@mrclrchtr/supi-lsp 4.7.0 → 4.9.0

package/src/client/client-refresh.ts

@@ -1,234 +0,0 @@
-// LSP Client diagnostic refresh — pull diagnostics and push settle logic.
-// Extracted from client.ts to keep file sizes manageable.
-
-import { existsSync, readFileSync } from "node:fs";
-import type { DocumentDiagnosticReport, TextDocumentIdentifier } from "../config/types.ts";
-import { uriToFile } from "../utils.ts";
-import type { DiagnosticCacheEntry, LspClient } from "./client.ts";
-import type { JsonRpcClient } from "./transport.ts";
-
-interface ClientAccess {
-  openDocs: Map<string, { version: number; languageId: string }>;
-  rpc: JsonRpcClient | null;
-  diagnosticStore: Map<string, DiagnosticCacheEntry>;
-  releaseDiagnosticWaiters(uri: string): void;
-}
-
-function accessClient(client: LspClient): ClientAccess {
-  return client as unknown as ClientAccess;
-}
-
-/**
- * Re-read and re-sync all currently open, existing documents for a client.
- * Uses pull diagnostics when the server supports them, otherwise falls back
- * to push-diagnostic settling. Never throws.
- */
-export async function refreshClientOpenDiagnostics(
-  client: LspClient,
-  options: { maxWaitMs?: number; quietMs?: number } = {},
-): Promise<void> {
-  const maxWaitMs = options.maxWaitMs ?? 3_000;
-  const quietMs = options.quietMs ?? 200;
-
-  if (client.status !== "running") return;
-
-  const syncStart = Date.now();
-
-  // Re-sync all open documents that still exist on disk
-  const openDocs = accessClient(client).openDocs as Map<
-    string,
-    { version: number; languageId: string }
-  >;
-
-  for (const [uri, doc] of openDocs) {
-    const filePath = uriToFile(uri);
-    try {
-      if (!existsSync(filePath)) {
-        clearFileState(client, uri);
-        sendNotification(client, "textDocument/didClose", {
-          textDocument: { uri } satisfies TextDocumentIdentifier,
-        });
-        continue;
-      }
-      const content = readFileSync(filePath, "utf-8");
-      doc.version++;
-      sendDidChange(client, uri, doc.version, content);
-    } catch {
-      // Read error — skip this file, keep it open
-    }
-  }
-
-  if (openDocs.size === 0) return;
-
-  // Try pull diagnostics if server supports them
-  if (client.hasDiagnosticProvider) {
-    try {
-      await pullDiagnosticsForOpenDocs(client, syncStart, maxWaitMs);
-      return;
-    } catch {
-      // Pull diagnostics failed — fall back to push settle
-    }
-  }
-
-  // Fall back to push-diagnostic settling
-  await waitForDiagnosticSettle(client, syncStart, maxWaitMs, quietMs);
-}
-
-/** Send a didChange notification through the client's RPC. */
-function sendDidChange(client: LspClient, uri: string, version: number, content: string): void {
-  sendNotification(client, "textDocument/didChange", {
-    textDocument: { uri, version },
-    contentChanges: [{ text: content }],
-  });
-}
-
-/** Send an RPC notification through the client. */
-function sendNotification(client: LspClient, method: string, params: unknown): void {
-  const rpc = accessClient(client).rpc;
-  if (rpc) void rpc.sendNotification(method, params);
-}
-
-/** Clear open doc and diagnostic state for a URI. */
-function clearFileState(client: LspClient, uri: string): void {
-  accessClient(client).openDocs.delete(uri);
-  accessClient(client).diagnosticStore.delete(uri);
-  accessClient(client).releaseDiagnosticWaiters(uri);
-}
-
-/**
- * Request pull diagnostics for all open documents.
- * Throws if no diagnostics were successfully retrieved.
- */
-async function pullDiagnosticsForOpenDocs(
-  client: LspClient,
-  syncStart: number,
-  maxWaitMs: number,
-): Promise<void> {
-  const deadline = syncStart + maxWaitMs;
-  const uris = Array.from((accessClient(client).openDocs as Map<string, unknown>).keys());
-  const results = await Promise.allSettled(
-    uris.map(async (uri) => {
-      const remaining = deadline - Date.now();
-      if (remaining <= 0) throw new Error("pull diagnostic timeout");
-
-      return pullDiagnosticsForUri(client, uri, remaining);
-    }),
-  );
-
-  const anySuccess = results.some((result) => result.status === "fulfilled" && result.value);
-  const hadFailure = results.some((result) => result.status === "rejected");
-
-  if ((hadFailure || !anySuccess) && uris.length > 0) {
-    throw new Error("pull diagnostics incomplete");
-  }
-}
-
-/** Pull diagnostics for a single URI and apply the report to the cache. */
-export async function pullDiagnosticsForUri(
-  client: LspClient,
-  uri: string,
-  timeoutMs: number,
-): Promise<boolean> {
-  const report = await pullDocumentDiagnostics(client, uri, timeoutMs);
-  if (!report) return false;
-  applyPullReport(client, uri, report);
-  return true;
-}
-
-/** Pull diagnostics for a single document with timeout. */
-async function pullDocumentDiagnostics(
-  client: LspClient,
-  uri: string,
-  timeoutMs: number,
-): Promise<DocumentDiagnosticReport | null> {
-  const rpc = accessClient(client).rpc;
-  if (!rpc || client.status !== "running") {
-    throw new Error("client not running");
-  }
-
-  const previousResultId = accessClient(client).diagnosticStore.get(uri)?.resultId;
-  // Wait for server readiness before pulling diagnostics. In steady state
-  // this resolves immediately (isReady check). During active indexing, this
-  // may add extra latency on top of the per-URI timeout budget — acceptable
-  // because the server wouldn't return useful diagnostics while indexing anyway.
-  await client.getReady();
-  return rpc.sendRequest(
-    "textDocument/diagnostic",
-    {
-      textDocument: { uri },
-      previousResultId,
-    },
-    { timeoutMs },
-  ) as Promise<DocumentDiagnosticReport>;
-}
-
-/** Apply a pull diagnostic report to the cache, including related documents. */
-function applyPullReport(client: LspClient, uri: string, report: DocumentDiagnosticReport): void {
-  if (report.kind === "full") {
-    accessClient(client).diagnosticStore.set(uri, {
-      diagnostics: report.items,
-      receivedAt: Date.now(),
-      resultId: report.resultId,
-    });
-  } else if (report.kind === "unchanged" && report.resultId) {
-    const current = accessClient(client).diagnosticStore.get(uri);
-    if (current) current.resultId = report.resultId;
-  }
-
-  applyRelatedDocuments(client, report);
-}
-
-/** Extract and store related document diagnostics from a pull report. */
-function applyRelatedDocuments(client: LspClient, report: DocumentDiagnosticReport): void {
-  const related = (report as unknown as Record<string, unknown>).relatedDocuments;
-  if (!related || typeof related !== "object") return;
-
-  for (const [relatedUri, relatedReport] of Object.entries(
-    related as Record<string, DocumentDiagnosticReport>,
-  )) {
-    if (relatedReport.kind === "full" && relatedReport.items) {
-      accessClient(client).diagnosticStore.set(relatedUri, {
-        diagnostics: relatedReport.items,
-        receivedAt: Date.now(),
-        resultId: relatedReport.resultId,
-      });
-    }
-  }
-}
-
-/**
- * Wait until no publishDiagnostics notifications arrive for quietMs
- * after syncStart, or until maxWaitMs elapses.
- */
-async function waitForDiagnosticSettle(
-  client: LspClient,
-  syncStart: number,
-  maxWaitMs: number,
-  quietMs: number,
-): Promise<void> {
-  const deadline = syncStart + maxWaitMs;
-
-  while (Date.now() < deadline) {
-    const lastReceived = lastDiagnosticReceivedTimeAfter(client, syncStart) || syncStart;
-    const elapsed = Date.now() - lastReceived;
-    if (elapsed >= quietMs) {
-      return;
-    }
-
-    await new Promise((resolve) =>
-      setTimeout(resolve, Math.min(quietMs - elapsed, deadline - Date.now(), 50)),
-    );
-  }
-}
-
-/** Get the most recent receivedAt timestamp after a given time. */
-function lastDiagnosticReceivedTimeAfter(client: LspClient, afterTime: number): number {
-  let latest = 0;
-  const store = accessClient(client).diagnosticStore as Map<string, { receivedAt: number }>;
-  for (const entry of store.values()) {
-    if (entry.receivedAt > afterTime && entry.receivedAt > latest) {
-      latest = entry.receivedAt;
-    }
-  }
-  return latest;
-}

package/src/diagnostics/diagnostics.ts

@@ -1,99 +0,0 @@
-// Diagnostic formatting and severity utilities.
-
-import * as path from "node:path";
-import type { Diagnostic } from "../config/types.ts";
-
-/** Map severity number to label. */
-export function severityLabel(severity: number | undefined): string {
-  switch (severity) {
-    case 1:
-      return "error";
-    case 2:
-      return "warning";
-    case 3:
-      return "info";
-    case 4:
-      return "hint";
-    default:
-      return "unknown";
-  }
-}
-
-/** Map severity number to emoji. */
-function severityIcon(severity: number | undefined): string {
-  switch (severity) {
-    case 1:
-      return "❌";
-    case 2:
-      return "⚠️";
-    case 3:
-      return "ℹ️";
-    case 4:
-      return "💡";
-    default:
-      return "❓";
-  }
-}
-
-/**
- * Format a single diagnostic for display.
- * Output: "❌ error [source] (line:col): message"
- */
-export function formatDiagnostic(diag: Diagnostic): string {
-  const icon = severityIcon(diag.severity);
-  const sev = severityLabel(diag.severity);
-  const line = diag.range.start.line + 1; // Convert 0-based to 1-based
-  const col = diag.range.start.character + 1;
-  const source = diag.source ? ` [${diag.source}]` : "";
-  const code = diag.code !== undefined ? ` (${diag.code})` : "";
-  const msg = typeof diag.message === "string" ? diag.message : diag.message.value;
-  return `${icon} ${sev}${source}${code} (${line}:${col}): ${msg}`;
-}
-
-/**
- * Format a list of diagnostics for a file.
- */
-export function formatDiagnostics(
-  filePath: string,
-  diagnostics: Diagnostic[],
-  cwd: string,
-): string {
-  if (diagnostics.length === 0) return "No diagnostics.";
-
-  const relPath = path.relative(cwd, filePath);
-  const lines = [`**${relPath}**:`];
-
-  for (const diag of diagnostics) {
-    lines.push(`  ${formatDiagnostic(diag)}`);
-  }
-
-  return lines.join("\n");
-}
-
-/**
- * Format diagnostics grouped by file.
- */
-export function formatGroupedDiagnostics(
-  entries: Array<{ file: string; diagnostics: Diagnostic[] }>,
-  cwd: string,
-): string {
-  if (entries.length === 0) return "No diagnostics across any files.";
-
-  const sections: string[] = [];
-  for (const entry of entries) {
-    if (entry.diagnostics.length > 0) {
-      sections.push(formatDiagnostics(entry.file, entry.diagnostics, cwd));
-    }
-  }
-
-  return sections.length > 0 ? sections.join("\n\n") : "No diagnostics.";
-}
-
-/**
- * Filter diagnostics by severity threshold.
- * Returns diagnostics with severity <= maxSeverity.
- * Severity 1 = error, 2 = warning, 3 = info, 4 = hint.
- */
-export function filterBySeverity(diagnostics: Diagnostic[], maxSeverity: number): Diagnostic[] {
-  return diagnostics.filter((d) => d.severity !== undefined && d.severity <= maxSeverity);
-}

package/src/diagnostics/suppression-diagnostics.ts

@@ -1,60 +0,0 @@
-import type { Diagnostic } from "../config/types.ts";
-
-const SUPPRESSION_WARNING_SEVERITY = 2;
-
-/** Detect diagnostics that represent stale suppression comments. */
-export function isStaleSuppressionDiagnostic(diagnostic: Diagnostic): boolean {
-  const rawMessage =
-    typeof diagnostic.message === "string" ? diagnostic.message : diagnostic.message.value;
-  const message = rawMessage.toLowerCase();
-
-  if (message.includes("unused '@ts-expect-error' directive")) {
-    return true;
-  }
-
-  if (diagnostic.source !== "biome") {
-    return false;
-  }
-
-  return (
-    message.includes("suppression comment has no effect") || message.includes("unused suppression")
-  );
-}
-
-/**
- * Split diagnostics into regular inline diagnostics and stale suppression cleanup.
- *
- * Stale suppression warnings stay visible even when regular inline diagnostics are
- * configured to show errors only.
- */
-export function splitSuppressionDiagnostics(
-  diagnostics: Diagnostic[],
-  maxSeverity: number,
-): {
-  regular: Diagnostic[];
-  suppressions: Diagnostic[];
-} {
-  const suppressionMaxSeverity = Math.max(maxSeverity, SUPPRESSION_WARNING_SEVERITY);
-  const regular: Diagnostic[] = [];
-  const suppressions: Diagnostic[] = [];
-
-  for (const diagnostic of diagnostics) {
-    const severity = diagnostic.severity;
-    if (severity === undefined) {
-      continue;
-    }
-
-    if (isStaleSuppressionDiagnostic(diagnostic)) {
-      if (severity <= suppressionMaxSeverity) {
-        suppressions.push(diagnostic);
-      }
-      continue;
-    }
-
-    if (severity <= maxSeverity) {
-      regular.push(diagnostic);
-    }
-  }
-
-  return { regular, suppressions };
-}

package/src/index.ts

@@ -1,41 +0,0 @@
-// Public library entrypoint for @mrclrchtr/supi-lsp/api.
-// Consumers should import the published API surface from
-// `@mrclrchtr/supi-lsp/api`, not the package root.
-
-export type { LspSettings } from "./config/lsp-settings.ts";
-export {
-  getLspDisabledMessage,
-  loadLspSettings,
-} from "./config/lsp-settings.ts";
-export type {
-  CodeAction,
-  Diagnostic,
-  DocumentSymbol,
-  Hover,
-  Location,
-  LocationLink,
-  Position,
-  ProjectServerInfo,
-  Range,
-  SymbolInformation,
-  WorkspaceEdit,
-  WorkspaceSymbol,
-} from "./config/types.ts";
-export { toLspPosition, toOneBasedPosition } from "./coordinates.ts";
-export type {
-  LspControllerState,
-  LspStartResult,
-} from "./session/runtime-controller.ts";
-export { LspRuntimeController } from "./session/runtime-controller.ts";
-export type {
-  OutstandingDiagnosticSummaryEntry,
-  RecoverDiagnosticsResult,
-  SemanticReadinessResult,
-  WorkspaceDiagnosticSummaryEntry,
-  WorkspaceLspRuntime,
-  WorkspaceLspRuntimeState,
-} from "./session/runtime-registry.ts";
-export {
-  getWorkspaceLspRuntime,
-  waitForWorkspaceLspRuntime,
-} from "./session/runtime-registry.ts";