@mrclrchtr/supi-lsp 0.1.0 → 1.0.0

package/manager.ts

@@ -1,396 +0,0 @@
-// LSP Manager — server pool with lazy spawning and diagnostic collection.
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { LspClient } from "./client.ts";
-import { getServerForFile } from "./config.ts";
-import {
-  accumulateOutstandingDiagnostics,
-  collectDiagnosticSummaryCounts,
-  createOutstandingDiagnosticSummary,
-  relativeFilePathFromUri,
-} from "./diagnostic-summary.ts";
-import {
-  displayRelativeFilePath,
-  formatCoverageSummaryText,
-  formatOutstandingDiagnosticsSummaryText,
-  isPathRelevant,
-  normalizeRelevantPaths,
-  shouldIgnoreLspPath,
-} from "./summary.ts";
-import type { Diagnostic, LspConfig } from "./types.ts";
-import { commandExists, findProjectRoot } from "./utils.ts";
-
-// ── Types ─────────────────────────────────────────────────────────────
-
-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[];
-}
-
-// ── LspManager ────────────────────────────────────────────────────────
-
-export class LspManager {
-  /** Active clients keyed by "serverName:root" */
-  private clients = new Map<string, LspClient>();
-  /** Servers we've already tried and failed to start */
-  private unavailable = new Set<string>();
-  /** Memoized per-command availability of LSP server binaries on PATH */
-  private commandAvailability = new Map<string, boolean>();
-
-  constructor(private readonly config: LspConfig) {}
-
-  // ── Public API ────────────────────────────────────────────────────
-
-  /**
-   * Synchronously check whether a file path maps to a configured LSP server
-   * whose binary is actually installed and has not already failed to start.
-   * Used by tool-event activation so we don't advertise LSP readiness for
-   * files whose server cannot run in this environment.
-   */
-  isSupportedSourceFile(filePath: string): boolean {
-    // Dependency directories are intentionally excluded from recent-path
-    // tracking and diagnostic summaries (shouldIgnoreLspPath). Keep runtime
-    // guidance activation consistent: reading or editing a file under
-    // node_modules / .pnpm must not arm LSP guidance for dependency sources.
-    if (shouldIgnoreLspPath(filePath)) return false;
-    const match = getServerForFile(this.config, filePath);
-    if (!match) return false;
-    const [serverName, serverConfig] = match;
-    // Mirror getClientForFile's root resolution so the unavailable check stays
-    // root-specific. A failed startup in one workspace must not suppress
-    // activation for unrelated roots served by the same language server.
-    const fileDir = path.dirname(path.resolve(filePath));
-    const root = findProjectRoot(fileDir, serverConfig.rootMarkers, process.cwd());
-    if (this.unavailable.has(`${serverName}:${root}`)) return false;
-    return this.isServerCommandAvailable(serverConfig.command);
-  }
-
-  private isServerCommandAvailable(command: string): boolean {
-    // Only memoize positive lookups. A negative result may become stale if the
-    // user installs the binary mid-session (e.g. `mise install`), and
-    // getClientForFile calls commandExists directly — caching false here would
-    // leave runtime guidance permanently dormant while client spawning can
-    // still succeed.
-    if (this.commandAvailability.get(command) === true) return true;
-    const available = commandExists(command);
-    if (available) this.commandAvailability.set(command, true);
-    return available;
-  }
-
-  /**
-   * Get or create an LSP client for the given file.
-   * Returns null if no server is configured or available.
-   */
-  async getClientForFile(filePath: string): Promise<LspClient | null> {
-    const match = getServerForFile(this.config, filePath);
-    if (!match) return null;
-
-    const [serverName, serverConfig] = match;
-
-    // Find project root
-    const fileDir = path.dirname(path.resolve(filePath));
-    const root = findProjectRoot(fileDir, serverConfig.rootMarkers, process.cwd());
-    const key = `${serverName}:${root}`;
-
-    // Check if unavailable
-    if (this.unavailable.has(key)) return null;
-
-    // Return existing client
-    const existing = this.clients.get(key);
-    if (existing && existing.status === "running") return existing;
-
-    // If existing client errored, remove it
-    if (existing && existing.status === "error") {
-      this.clients.delete(key);
-      this.unavailable.add(key);
-      return null;
-    }
-
-    // Validate command exists
-    if (!commandExists(serverConfig.command)) {
-      this.unavailable.add(key);
-      return null;
-    }
-
-    // Spawn new client
-    const client = new LspClient(serverName, serverConfig, root);
-    this.clients.set(key, client);
-
-    try {
-      await client.start();
-      return client;
-    } catch (_err) {
-      this.unavailable.add(key);
-      this.clients.delete(key);
-      return null;
-    }
-  }
-
-  /**
-   * Sync a file with its LSP server and wait for diagnostics.
-   * Returns diagnostics filtered to the given severity threshold.
-   */
-  async syncFileAndGetDiagnostics(
-    filePath: string,
-    maxSeverity: number = 1,
-  ): Promise<Diagnostic[]> {
-    const client = await this.getClientForFile(filePath);
-    if (!client) return [];
-
-    const resolvedPath = path.resolve(filePath);
-    let content: string;
-    try {
-      content = fs.readFileSync(resolvedPath, "utf-8");
-    } catch {
-      this.closeFile(resolvedPath);
-      return [];
-    }
-
-    const diagnostics = await client.syncAndWaitForDiagnostics(resolvedPath, content);
-    return diagnostics.filter((d) => d.severity !== undefined && d.severity <= maxSeverity);
-  }
-
-  /** Close a file across any active LSP clients and clear its cached diagnostics. */
-  closeFile(filePath: string): void {
-    const resolvedPath = path.resolve(filePath);
-    for (const client of this.clients.values()) {
-      client.didClose(resolvedPath);
-    }
-  }
-
-  /** Remove any missing files from open-document and diagnostic state. */
-  pruneMissingFiles(): string[] {
-    const removed: string[] = [];
-    for (const client of this.clients.values()) {
-      const prune = (client as unknown as { pruneMissingFiles?: () => string[] }).pruneMissingFiles;
-      if (typeof prune === "function") {
-        removed.push(...prune.call(client));
-      }
-    }
-    return removed;
-  }
-
-  /** Shut down all running LSP servers. */
-  async shutdownAll(): Promise<void> {
-    const shutdowns = Array.from(this.clients.values()).map((c) => c.shutdown().catch(() => {}));
-    await Promise.all(shutdowns);
-    this.clients.clear();
-    this.unavailable.clear();
-  }
-
-  /** Get status of all servers. */
-  getStatus(): ManagerStatus {
-    this.pruneMissingFiles();
-    const servers: ServerStatus[] = [];
-    for (const [_key, client] of this.clients) {
-      servers.push({
-        name: client.name,
-        status: client.status === "running" ? "running" : "error",
-        root: client.root,
-        openFiles: client.openFiles,
-      });
-    }
-    return { servers };
-  }
-
-  /** Get configured and active LSP coverage for the current project. */
-  getCoverageSummary(): CoverageSummaryEntry[] {
-    this.pruneMissingFiles();
-    const activeServers = new Map<string, { active: boolean; openFiles: number }>();
-
-    for (const server of this.getStatus().servers) {
-      const current = activeServers.get(server.name) ?? { active: false, openFiles: 0 };
-      current.active = current.active || server.status === "running";
-      current.openFiles += server.openFiles.length;
-      activeServers.set(server.name, current);
-    }
-
-    return Object.entries(this.config.servers)
-      .map(([name, server]) => {
-        const activity = activeServers.get(name);
-        return {
-          name,
-          fileTypes: server.fileTypes,
-          active: activity?.active ?? false,
-          openFiles: activity?.openFiles ?? 0,
-        } satisfies CoverageSummaryEntry;
-      })
-      .sort(
-        (a, b) =>
-          Number(b.active) - Number(a.active) ||
-          b.openFiles - a.openFiles ||
-          a.name.localeCompare(b.name),
-      );
-  }
-
-  /** Get active LSP coverage summarized by running servers with open files. */
-  getActiveCoverageSummary(): ActiveCoverageSummaryEntry[] {
-    this.pruneMissingFiles();
-    const activeServers = new Map<string, Set<string>>();
-
-    for (const server of this.getStatus().servers) {
-      if (server.status !== "running" || server.openFiles.length === 0) continue;
-
-      const openFiles = activeServers.get(server.name) ?? new Set<string>();
-      for (const file of server.openFiles) {
-        const relativeFile = displayRelativeFilePath(file);
-        if (shouldIgnoreLspPath(relativeFile)) continue;
-        openFiles.add(relativeFile);
-      }
-      activeServers.set(server.name, openFiles);
-    }
-
-    return Array.from(activeServers.entries())
-      .map(([name, openFiles]) => ({
-        name,
-        openFiles: Array.from(openFiles).sort(),
-      }))
-      .sort((a, b) => b.openFiles.length - a.openFiles.length || a.name.localeCompare(b.name));
-  }
-
-  /** Get active coverage as compact text suitable for pre-turn context. */
-  getCoverageSummaryText(maxServers: number = 2, maxFiles: number = 2): string | null {
-    return formatCoverageSummaryText(this.getActiveCoverageSummary(), maxServers, maxFiles);
-  }
-
-  /** Get active coverage filtered to files or directories relevant to the current turn. */
-  getRelevantCoverageSummaryText(
-    relevantPaths: string[],
-    maxServers: number = 2,
-    maxFiles: number = 2,
-  ): string | null {
-    const normalizedPaths = normalizeRelevantPaths(relevantPaths);
-    if (normalizedPaths.length === 0) return null;
-
-    const relevantEntries = this.getActiveCoverageSummary()
-      .map((entry) => ({
-        ...entry,
-        openFiles: entry.openFiles.filter((file) => isPathRelevant(file, normalizedPaths)),
-      }))
-      .filter((entry) => entry.openFiles.length > 0);
-
-    return formatCoverageSummaryText(relevantEntries, maxServers, maxFiles);
-  }
-
-  /** Get a diagnostic summary across all servers and files. */
-  getDiagnosticSummary(): DiagnosticSummary[] {
-    this.pruneMissingFiles();
-    const fileDiags = new Map<string, { errors: number; warnings: number }>();
-
-    for (const client of this.clients.values()) {
-      for (const entry of client.getAllDiagnostics()) {
-        collectDiagnosticSummaryCounts(fileDiags, entry);
-      }
-    }
-
-    return Array.from(fileDiags.entries()).map(([file, counts]) => ({ file, ...counts }));
-  }
-
-  /** Get outstanding diagnostics at or above the configured inline threshold. */
-  getOutstandingDiagnosticSummary(maxSeverity: number = 1): OutstandingDiagnosticSummaryEntry[] {
-    this.pruneMissingFiles();
-    const fileDiags = new Map<string, OutstandingDiagnosticSummaryEntry>();
-
-    for (const client of this.clients.values()) {
-      for (const entry of client.getAllDiagnostics()) {
-        const file = relativeFilePathFromUri(entry.uri);
-        if (shouldIgnoreLspPath(file)) continue;
-        const current = fileDiags.get(file) ?? createOutstandingDiagnosticSummary(file);
-        const next = accumulateOutstandingDiagnostics(current, entry.diagnostics, maxSeverity);
-
-        if (next.total > 0) {
-          fileDiags.set(file, next);
-        }
-      }
-    }
-
-    return Array.from(fileDiags.values()).sort(
-      (a, b) =>
-        b.errors - a.errors ||
-        b.warnings - a.warnings ||
-        b.information - a.information ||
-        b.hints - a.hints ||
-        a.file.localeCompare(b.file),
-    );
-  }
-
-  /** Get outstanding diagnostics as compact text suitable for pre-turn context. */
-  getOutstandingDiagnosticsSummaryText(
-    maxSeverity: number = 1,
-    maxFiles: number = 3,
-  ): string | null {
-    return formatOutstandingDiagnosticsSummaryText(
-      this.getOutstandingDiagnosticSummary(maxSeverity),
-      maxFiles,
-    );
-  }
-
-  /** Get outstanding diagnostics filtered to files or directories relevant to the current turn. */
-  getRelevantOutstandingDiagnosticsSummaryText(
-    relevantPaths: string[],
-    maxSeverity: number = 1,
-    maxFiles: number = 3,
-  ): string | null {
-    const normalizedPaths = normalizeRelevantPaths(relevantPaths);
-    if (normalizedPaths.length === 0) return null;
-
-    const relevantEntries = this.getOutstandingDiagnosticSummary(maxSeverity).filter((entry) =>
-      isPathRelevant(entry.file, normalizedPaths),
-    );
-
-    return formatOutstandingDiagnosticsSummaryText(relevantEntries, maxFiles);
-  }
-
-  /**
-   * Ensure a file is open in its LSP server.
-   * Used when the agent needs to read a file for the first time.
-   */
-  async ensureFileOpen(filePath: string): Promise<LspClient | null> {
-    const client = await this.getClientForFile(filePath);
-    if (!client) return null;
-
-    const resolvedPath = path.resolve(filePath);
-    try {
-      const content = fs.readFileSync(resolvedPath, "utf-8");
-      client.didOpen(resolvedPath, content);
-      return client;
-    } catch {
-      this.closeFile(resolvedPath);
-      return null;
-    }
-  }
-}

package/overrides.ts

@@ -1,95 +0,0 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { createEditTool, createReadTool, createWriteTool } from "@mariozechner/pi-coding-agent";
-import { formatDiagnostics } from "./diagnostics.ts";
-import type { LspManager } from "./manager.ts";
-import { trackRecentPath } from "./recent-paths.ts";
-
-interface LspOverrideState {
-  inlineSeverity: number;
-  getManager(): LspManager | null;
-  getRecentPaths(): string[];
-  setRecentPaths(paths: string[]): void;
-  onRecentPathsChange?(): void;
-}
-
-export function registerLspAwareToolOverrides(pi: ExtensionAPI, state: LspOverrideState): void {
-  const cwd = process.cwd();
-  const originalRead = createReadTool(cwd);
-  const originalWrite = createWriteTool(cwd);
-  const originalEdit = createEditTool(cwd);
-
-  pi.registerTool({
-    ...originalRead,
-    // biome-ignore lint/complexity/useMaxParams: pi ToolDefinition.execute signature
-    async execute(toolCallId, params, signal, onUpdate, _ctx) {
-      const result = await originalRead.execute(toolCallId, params, signal, onUpdate);
-      recordRecentPath(state, params.path);
-      await ensureFileOpen(state.getManager(), params.path);
-      return result;
-    },
-  });
-
-  pi.registerTool({
-    ...originalWrite,
-    // biome-ignore lint/complexity/useMaxParams: pi ToolDefinition.execute signature
-    async execute(toolCallId, params, signal, onUpdate, _ctx) {
-      const result = await originalWrite.execute(toolCallId, params, signal, onUpdate);
-
-      recordRecentPath(state, params.path);
-      return appendInlineDiagnostics(state.getManager(), params.path, state.inlineSeverity, result);
-    },
-  });
-
-  pi.registerTool({
-    ...originalEdit,
-    // biome-ignore lint/complexity/useMaxParams: pi ToolDefinition.execute signature
-    async execute(toolCallId, params, signal, onUpdate, _ctx) {
-      const result = await originalEdit.execute(toolCallId, params, signal, onUpdate);
-
-      recordRecentPath(state, params.path);
-      return appendInlineDiagnostics(state.getManager(), params.path, state.inlineSeverity, result);
-    },
-  });
-}
-
-async function appendInlineDiagnostics<T extends { content: unknown[]; details: unknown }>(
-  manager: LspManager | null,
-  filePath: string,
-  inlineSeverity: number,
-  result: T,
-): Promise<T> {
-  if (!manager) return result;
-
-  try {
-    const diags = await manager.syncFileAndGetDiagnostics(filePath, inlineSeverity);
-    if (diags.length === 0) return result;
-
-    const diagText = formatDiagnostics(filePath, diags);
-    const diagnosticContent = {
-      type: "text" as const,
-      text: `\n\n⚠️ LSP Diagnostics:\n${diagText}`,
-    } as T["content"][number];
-
-    return {
-      ...result,
-      content: [...result.content, diagnosticContent],
-    } as T;
-  } catch {
-    return result;
-  }
-}
-
-async function ensureFileOpen(manager: LspManager | null, filePath: string): Promise<void> {
-  if (!manager) return;
-
-  try {
-    await manager.ensureFileOpen(filePath);
-  } catch {
-    // Never block the agent on LSP errors
-  }
-}
-
-function recordRecentPath(state: LspOverrideState, filePath: string): void {
-  state.setRecentPaths(trackRecentPath(state.getRecentPaths(), filePath));
-  state.onRecentPathsChange?.();
-}

package/recent-paths.ts

@@ -1,126 +0,0 @@
-import * as path from "node:path";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { shouldIgnoreLspPath } from "./summary.ts";
-
-const LSP_STATE_ENTRY_TYPE = "lsp-state";
-
-export function updateRecentPathsFromToolEvent(
-  toolName: string,
-  input: Record<string, unknown>,
-  recentPaths: string[],
-): string[] {
-  const filePath = getFilePathFromToolEvent(toolName, input);
-  return filePath ? trackRecentPath(recentPaths, filePath) : recentPaths;
-}
-
-export function getFilePathFromToolEvent(
-  toolName: string,
-  input: Record<string, unknown>,
-): string | null {
-  const raw = getRawFilePathFromToolEvent(toolName, input);
-  return raw === null ? null : normalizeTrackedPath(raw);
-}
-
-/**
- * Like getFilePathFromToolEvent but returns the unfiltered string path from
- * the tool input. Used by runtime-guidance gating, which must accept absolute
- * paths to files outside cwd (sibling worktrees, monorepo packages) since
- * read/edit/lsp all support them and they get real LSP coverage.
- */
-export function getRawFilePathFromToolEvent(
-  toolName: string,
-  input: Record<string, unknown>,
-): string | null {
-  if (
-    (toolName === "read" || toolName === "write" || toolName === "edit") &&
-    typeof input.path === "string"
-  ) {
-    return input.path;
-  }
-
-  if (toolName === "lsp" && typeof input.file === "string") {
-    return input.file;
-  }
-
-  return null;
-}
-
-export function trackRecentPath(
-  recentPaths: string[],
-  filePath: string,
-  maxEntries: number = 6,
-): string[] {
-  const normalized = normalizeTrackedPath(filePath);
-  if (!normalized) return recentPaths;
-
-  const next = [normalized, ...recentPaths.filter((entry) => entry !== normalized)];
-  return next.slice(0, maxEntries);
-}
-
-/**
- * Convert any tool-supplied path into a stable form for tracking. In-tree
- * paths collapse to their project-relative form; out-of-tree paths preserve
- * the absolute form so sibling worktrees / monorepo packages stay in the
- * relevance set that powers `getSemanticBashBlockReason`. This mirrors
- * `displayRelativeFilePath`, so recent-paths, tracked runtime paths, and
- * diagnostic keys all share one representation. Files in dependency
- * directories (node_modules, .pnpm) are dropped so they don't crowd out real
- * source files.
- */
-export function normalizeTrackedPath(filePath: string): string | null {
-  const resolved = path.resolve(filePath);
-  if (shouldIgnoreLspPath(resolved)) return null;
-  const relative = path.relative(process.cwd(), resolved);
-  if (relative === "") return path.basename(resolved);
-  if (relative.startsWith(`..${path.sep}`) || relative === "..") {
-    return resolved;
-  }
-  return relative.replaceAll(path.sep, "/");
-}
-
-/**
- * Recover the recent-paths list from previously persisted session entries.
- * Each turn that saw new paths appended a fresh `lsp-state` entry, so the
- * latest one (`.pop()`) is the authoritative snapshot — earlier entries are
- * stale superseded states, not history we want to merge.
- */
-export function restoreRecentPaths(
-  entries: Array<{ type?: string; customType?: string; data?: unknown }>,
-): string[] {
-  const entry = entries
-    .filter(
-      (candidate) => candidate.type === "custom" && candidate.customType === LSP_STATE_ENTRY_TYPE,
-    )
-    .pop() as { data?: { recentPaths?: unknown } } | undefined;
-
-  return sanitizeRecentPaths(entry?.data?.recentPaths);
-}
-
-export function persistRecentPaths(
-  pi: ExtensionAPI,
-  recentPaths: string[],
-  persistedRecentPaths: string[],
-): string[] {
-  const sanitized = sanitizeRecentPaths(recentPaths);
-  if (samePaths(sanitized, persistedRecentPaths)) return persistedRecentPaths;
-
-  pi.appendEntry(LSP_STATE_ENTRY_TYPE, { recentPaths: sanitized });
-  return sanitized;
-}
-
-function sanitizeRecentPaths(paths: unknown, maxEntries: number = 6): string[] {
-  if (!Array.isArray(paths)) return [];
-
-  return Array.from(
-    new Set(
-      paths
-        .filter((value): value is string => typeof value === "string" && value.trim().length > 0)
-        .map(normalizeTrackedPath)
-        .filter((value): value is string => value !== null),
-    ),
-  ).slice(0, maxEntries);
-}
-
-function samePaths(a: string[], b: string[]): boolean {
-  return a.length === b.length && a.every((entry, index) => entry === b[index]);
-}