@mrclrchtr/supi-lsp 1.3.0 → 1.4.0

package/src/tool-actions.ts

@@ -1,430 +0,0 @@
-// LSP tool action implementations — dispatches agent tool calls to LSP clients.
-// biome-ignore-all lint/nursery/noExcessiveLinesPerFile: action dispatch remains cohesive; recovery helpers stay adjacent for readability.
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { LspClient } from "./client/client.ts";
-import { formatDiagnostics } from "./diagnostics/diagnostics.ts";
-import {
-  formatCodeActions,
-  formatDocumentSymbols,
-  formatHover,
-  formatLocations,
-  formatSearchResults,
-  formatSymbolInformation,
-  formatWorkspaceEdit,
-  formatWorkspaceSymbols,
-  normalizeLocations,
-} from "./format.ts";
-import type { LspManager } from "./manager/manager.ts";
-import { fallbackGrep } from "./search-fallback.ts";
-import type { DocumentSymbol, Range, SymbolInformation } from "./types.ts";
-import { uriToFile } from "./utils.ts";
-
-// ── Types ─────────────────────────────────────────────────────────────
-
-export type LspAction =
-  | "hover"
-  | "definition"
-  | "references"
-  | "diagnostics"
-  | "symbols"
-  | "rename"
-  | "code_actions"
-  | "workspace_symbol"
-  | "search"
-  | "symbol_hover"
-  | "recover";
-
-export interface LspToolParams {
-  action: LspAction;
-  file?: string;
-  line?: number;
-  character?: number;
-  newName?: string;
-  query?: string;
-  symbol?: string;
-}
-
-// ── Tool Description ──────────────────────────────────────────────────
-
-export const lspToolDescription = `Language Server Protocol tool — provides type-aware code intelligence.
-
-Actions:
-- hover: Get type info and docs at a position. Params: file, line, character
-- definition: Go to definition of a symbol. Params: file, line, character
-- references: Find all references to a symbol. Params: file, line, character
-- diagnostics: Get type errors and warnings. Params: file (optional — omit for all files)
-- symbols: List all symbols in a file. Params: file
-- rename: Rename a symbol across the project. Params: file, line, character, newName
-- code_actions: Get available fixes/refactors at a position. Params: file, line, character
-- workspace_symbol: Fuzzy symbol search across the project. Params: query
-- search: Search for symbols (LSP first, then text fallback). Params: query
-- symbol_hover: Hover info by symbol name (zero coordinates). Params: symbol
-- recover: Refresh cached diagnostics after a workspace change. Params: none
-
-Line and character are 1-based. File paths are relative to cwd.`;
-
-// ── Action Dispatcher ─────────────────────────────────────────────────
-
-export async function executeAction(manager: LspManager, params: LspToolParams): Promise<string> {
-  const cwd = manager.getCwd();
-  switch (params.action) {
-    case "hover":
-      return handleHover(manager, params, cwd);
-    case "definition":
-      return handleDefinition(manager, params, cwd);
-    case "references":
-      return handleReferences(manager, params, cwd);
-    case "diagnostics":
-      return handleDiagnostics(manager, params, cwd);
-    case "symbols":
-      return handleSymbols(manager, params, cwd);
-    case "rename":
-      return handleRename(manager, params, cwd);
-    case "code_actions":
-      return handleCodeActions(manager, params, cwd);
-    case "workspace_symbol":
-      return handleWorkspaceSymbol(manager, params, cwd);
-    case "search":
-      return handleSearch(manager, params, cwd);
-    case "symbol_hover":
-      return handleSymbolHover(manager, params, cwd);
-    case "recover":
-      return handleRecover(manager);
-    default:
-      return `Unknown action: ${params.action}`;
-  }
-}
-
-/**
- * Top-level error guard for unexpected throws in action handlers.
- * Each handler aims to catch its own errors, but this ensures that
- * an unforeseen runtime failure produces a descriptive string return
- * instead of an unhandled tool error that pi would surface to the agent.
- */
-export async function safeExecuteAction(
-  manager: LspManager,
-  params: LspToolParams,
-): Promise<string> {
-  try {
-    return await executeAction(manager, params);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return `LSP action failed: ${message}`;
-  }
-}
-
-// ── Validation helpers ────────────────────────────────────────────────
-
-function validateFilePosition(
-  params: LspToolParams,
-  action: string,
-): { file: string; line: number; character: number } | string {
-  if (!params.file) return `Validation error: 'file' is required for ${action} action.`;
-  if (params.line === undefined)
-    return `Validation error: 'line' is required for ${action} action.`;
-  if (params.character === undefined)
-    return `Validation error: 'character' is required for ${action} action.`;
-  if (!Number.isInteger(params.line) || params.line < 1)
-    return `Validation error: 'line' must be a positive 1-based integer for ${action} action.`;
-  if (!Number.isInteger(params.character) || params.character < 1)
-    return `Validation error: 'character' must be a positive 1-based integer for ${action} action.`;
-  return { file: params.file, line: params.line, character: params.character };
-}
-
-function validateNonEmptyString(
-  value: string | undefined,
-  name: string,
-  action: string,
-): { value: string } | string {
-  if (!value || value.trim().length === 0) {
-    return `Validation error: '${name}' is required for ${action} action.`;
-  }
-  return { value };
-}
-
-function resolveFilePath(file: string, cwd: string): string {
-  return path.resolve(cwd, file);
-}
-
-function toZeroBased(line: number, character: number): { line: number; character: number } {
-  return { line: line - 1, character: character - 1 };
-}
-
-function noServerMessage(file: string): string {
-  return `No LSP server available for this file type (${path.extname(file) || "unknown"})`;
-}
-
-// ── Higher-order helpers ──────────────────────────────────────────────
-
-/**
- * Encapsulates the common preamble shared by file-position-based action handlers:
- * validates file/line/character, resolves the path, obtains the LSP client, and
- * returns an error string if any step fails. Passes the ready client and zero-based
- * coordinates to the callback.
- */
-// biome-ignore lint/complexity/useMaxParams: Higher-order callback wrapper intentionally takes 5 params.
-async function withFileClient(
-  manager: LspManager,
-  params: LspToolParams,
-  cwd: string,
-  action: string,
-  fn: (client: LspClient, file: string, line: number, character: number) => Promise<string>,
-): Promise<string> {
-  const validation = validateFilePosition(params, action);
-  if (typeof validation === "string") return validation;
-  const { file, line, character } = validation;
-  const resolvedPath = resolveFilePath(file, cwd);
-
-  const client = await manager.ensureFileOpen(resolvedPath);
-  if (!client) return noServerMessage(resolvedPath);
-
-  return fn(client, resolvedPath, line, character);
-}
-
-// ── Action Handlers ───────────────────────────────────────────────────
-
-async function handleHover(
-  manager: LspManager,
-  params: LspToolParams,
-  cwd: string,
-): Promise<string> {
-  return withFileClient(manager, params, cwd, "hover", async (client, file, line, character) => {
-    const hover = await client.hover(file, toZeroBased(line, character));
-    if (!hover) return "No hover information available at this position.";
-    return formatHover(hover);
-  });
-}
-
-async function handleDefinition(
-  manager: LspManager,
-  params: LspToolParams,
-  cwd: string,
-): Promise<string> {
-  return withFileClient(
-    manager,
-    params,
-    cwd,
-    "definition",
-    async (client, file, line, character) => {
-      const result = await client.definition(file, toZeroBased(line, character));
-      if (!result) return "No definition found.";
-
-      const locations = normalizeLocations(result);
-      if (locations.length === 0) return "No definition found.";
-
-      return formatLocations("Definition", locations, cwd);
-    },
-  );
-}
-
-async function handleReferences(
-  manager: LspManager,
-  params: LspToolParams,
-  cwd: string,
-): Promise<string> {
-  return withFileClient(
-    manager,
-    params,
-    cwd,
-    "references",
-    async (client, file, line, character) => {
-      const locations = await client.references(file, toZeroBased(line, character));
-      if (!locations || locations.length === 0) return "No references found.";
-
-      return formatLocations("References", locations, cwd);
-    },
-  );
-}
-
-async function handleDiagnostics(
-  manager: LspManager,
-  params: LspToolParams,
-  cwd: string,
-): Promise<string> {
-  if (params.file) {
-    const resolvedPath = resolveFilePath(params.file, cwd);
-    const client = await manager.ensureFileOpen(resolvedPath);
-    if (!client) return noServerMessage(resolvedPath);
-
-    try {
-      const content = fs.readFileSync(resolvedPath, "utf-8");
-      const diags = await client.syncAndWaitForDiagnostics(resolvedPath, content);
-      return formatDiagnostics(resolvedPath, diags, cwd);
-    } catch {
-      return `Error: failed to read or query diagnostics for ${params.file}`;
-    }
-  }
-
-  const summary = manager.getDiagnosticSummary();
-  if (summary.length === 0) return "No diagnostics across any files.";
-
-  const lines = ["## Diagnostics Summary\n"];
-  for (const s of summary) {
-    lines.push(`- **${s.file}**: ${s.errors} error(s), ${s.warnings} warning(s)`);
-  }
-  return lines.join("\n");
-}
-
-async function handleSymbols(
-  manager: LspManager,
-  params: LspToolParams,
-  cwd: string,
-): Promise<string> {
-  if (!params.file) return "Validation error: 'file' is required for symbols action.";
-  const resolvedPath = resolveFilePath(params.file, cwd);
-
-  const client = await manager.ensureFileOpen(resolvedPath);
-  if (!client) return noServerMessage(resolvedPath);
-
-  const symbols = await client.documentSymbols(resolvedPath);
-  if (!symbols || symbols.length === 0) return "No symbols found.";
-
-  if ("children" in symbols[0] || "selectionRange" in symbols[0]) {
-    return formatDocumentSymbols(symbols as DocumentSymbol[], 0);
-  }
-  return formatSymbolInformation(symbols as SymbolInformation[], cwd);
-}
-
-async function handleRename(
-  manager: LspManager,
-  params: LspToolParams,
-  cwd: string,
-): Promise<string> {
-  const nameValidation = validateNonEmptyString(params.newName, "newName", "rename");
-  if (typeof nameValidation === "string") return nameValidation;
-  const newName = nameValidation.value;
-
-  return withFileClient(manager, params, cwd, "rename", async (client, file, line, character) => {
-    const edit = await client.rename(file, toZeroBased(line, character), newName);
-    if (!edit) return "Rename not available at this position.";
-
-    return formatWorkspaceEdit(edit, cwd);
-  });
-}
-
-async function handleCodeActions(
-  manager: LspManager,
-  params: LspToolParams,
-  cwd: string,
-): Promise<string> {
-  return withFileClient(
-    manager,
-    params,
-    cwd,
-    "code_actions",
-    async (client, file, line, character) => {
-      const pos = toZeroBased(line, character);
-      const range: Range = { start: pos, end: pos };
-      const diags = client.getDiagnostics(file);
-
-      const relevantDiags = diags.filter(
-        (d) => d.range.start.line <= pos.line && d.range.end.line >= pos.line,
-      );
-
-      const actions = await client.codeActions(file, range, {
-        diagnostics: relevantDiags,
-      });
-      if (!actions || actions.length === 0) return "No code actions available at this position.";
-
-      return formatCodeActions(actions);
-    },
-  );
-}
-
-async function handleWorkspaceSymbol(
-  manager: LspManager,
-  params: LspToolParams,
-  cwd: string,
-): Promise<string> {
-  const validation = validateNonEmptyString(params.query, "query", "workspace_symbol");
-  if (typeof validation === "string") return validation;
-  const query = validation.value;
-
-  const symbols = await manager.workspaceSymbol(query);
-  if (!symbols) return "Workspace symbol search not supported by this language server.";
-  if (symbols.length === 0) return `No symbols found for query "${query}".`;
-
-  return formatWorkspaceSymbols(symbols as SymbolInformation[], cwd);
-}
-
-async function handleSearch(
-  manager: LspManager,
-  params: LspToolParams,
-  cwd: string,
-): Promise<string> {
-  const validation = validateNonEmptyString(params.query, "query", "search");
-  if (typeof validation === "string") return validation;
-  const query = validation.value;
-
-  const symbols = await manager.workspaceSymbol(query);
-  if (symbols && symbols.length > 0) {
-    return formatWorkspaceSymbols(symbols as SymbolInformation[], cwd);
-  }
-  const grepMatches = fallbackGrep(cwd, query);
-  return formatSearchResults(null, grepMatches, cwd);
-}
-
-async function handleSymbolHover(
-  manager: LspManager,
-  params: LspToolParams,
-  _cwd: string,
-): Promise<string> {
-  const validation = validateNonEmptyString(params.symbol, "symbol", "symbol_hover");
-  if (typeof validation === "string") return validation;
-  const symbol = validation.value;
-
-  const symbols = await manager.workspaceSymbol(symbol);
-  if (!symbols || symbols.length === 0) {
-    return `Symbol "${symbol}" not found.`;
-  }
-
-  // Use the first match arbitrarily; LSP servers return results in their own
-  // order. The agent can use workspace_symbol or search to disambiguate.
-  const match = symbols[0];
-  const filePath = uriToFile(match.location.uri);
-  const client = await manager.ensureFileOpen(filePath);
-  if (!client) return noServerMessage(filePath);
-
-  const hover = await client.hover(filePath, match.location.range.start);
-  if (!hover) return `No hover information available for "${symbol}".`;
-
-  let result = formatHover(hover);
-  if (symbols.length > 1) {
-    result += `\n\n(${symbols.length - 1} other match${symbols.length === 2 ? "" : "es"} found — use workspace_symbol or search to disambiguate)`;
-  }
-  return result;
-}
-
-interface RecoveryAssessmentLike {
-  suspected: boolean;
-  matchedFiles: Array<{ file: string; diagnostics: unknown[] }>;
-  warning: string | null;
-}
-
-interface RecoveryResultLike {
-  refreshedClients: number;
-  restartedClients: number;
-  staleAssessment: RecoveryAssessmentLike;
-}
-
-async function handleRecover(manager: LspManager): Promise<string> {
-  const result = await manager.recoverWorkspaceDiagnostics({ restartIfStillStale: true });
-  return formatRecoveryResult(result);
-}
-
-function formatRecoveryResult(result: RecoveryResultLike): string {
-  const refreshed = pluralize(result.refreshedClients, "client");
-  const restarted = pluralize(result.restartedClients, "client");
-  const status = result.staleAssessment.suspected
-    ? "stale diagnostics still suspected"
-    : "stale diagnostics cleared";
-  const warning = result.staleAssessment.warning ? ` — ${result.staleAssessment.warning}` : "";
-
-  return `LSP recovery complete: refreshed ${refreshed}, restarted ${restarted}, ${status}${warning}.`;
-}
-
-function pluralize(count: number, word: string): string {
-  return `${count} ${word}${count === 1 ? "" : "s"}`;
-}

package/src/tree-persist.ts

@@ -1,48 +0,0 @@
-// LSP tree navigation persistence — restores tool activation state across /tree navigation.
-
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-
-/** Shape of the entry persisted via `pi.appendEntry()`. */
-export interface LspStateEntry {
-  active: boolean;
-}
-
-/** Restore LSP activation state from the current branch after /tree navigation. */
-export function registerTreePersistHandlers(pi: ExtensionAPI, state: { lspActive: boolean }): void {
-  pi.on("session_tree", async (_event, ctx) => {
-    const branch = ctx.sessionManager.getBranch();
-    let lastEntry: LspStateEntry | undefined;
-
-    for (const entry of branch) {
-      if (entry.type === "custom" && entry.customType === "lsp-active") {
-        lastEntry = entry.data as LspStateEntry | undefined;
-      }
-    }
-
-    if (lastEntry?.active) {
-      const activeTools = pi.getActiveTools();
-      if (!activeTools.includes("lsp")) {
-        pi.setActiveTools([...activeTools, "lsp"]);
-      }
-      state.lspActive = true;
-    } else {
-      const activeTools = pi.getActiveTools();
-      if (activeTools.includes("lsp")) {
-        pi.setActiveTools(activeTools.filter((t) => t !== "lsp"));
-      }
-      state.lspActive = false;
-    }
-  });
-}
-
-/** Persist that LSP is active in the session tree. */
-export function persistLspActiveState(pi: ExtensionAPI, state: { lspActive: boolean }): void {
-  state.lspActive = true;
-  pi.appendEntry<LspStateEntry>("lsp-active", { active: true });
-}
-
-/** Persist that LSP is inactive in the session tree. */
-export function persistLspInactiveState(pi: ExtensionAPI, state: { lspActive: boolean }): void {
-  state.lspActive = false;
-  pi.appendEntry<LspStateEntry>("lsp-active", { active: false });
-}

package/src/tsconfig-scope.ts

@@ -1,156 +0,0 @@
-// tsconfig-aware file scope detection.
-//
-// Determines whether a file is within the compilation scope of its nearest
-// tsconfig.json by checking `include` and `exclude` patterns. Used by the
-// diagnostic filter to suppress LSP errors on files that TypeScript itself
-// would not type-check.
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-interface TsconfigInfo {
-  dir: string;
-  include: string[] | undefined;
-  exclude: string[] | undefined;
-}
-
-const cache = new Map<string, TsconfigInfo | null>();
-
-/**
- * Check whether a file is excluded by its nearest tsconfig.json.
- *
- * @param filePath - Project-relative file path (e.g., "packages/foo/__tests__/x.test.ts")
- * @param cwd - Absolute project root directory
- * @returns `true` if the file is excluded from compilation scope
- */
-export function isFileExcludedByTsconfig(filePath: string, cwd: string): boolean {
-  const absolutePath = path.resolve(cwd, filePath);
-  const tsconfig = findNearestTsconfig(path.dirname(absolutePath), cwd);
-  if (!tsconfig) return false;
-
-  const relativeToTsconfig = path.relative(tsconfig.dir, absolutePath).replaceAll("\\", "/");
-
-  // Check exclude patterns first
-  if (tsconfig.exclude) {
-    for (const pattern of tsconfig.exclude) {
-      if (matchesPattern(relativeToTsconfig, pattern)) return true;
-    }
-  }
-
-  // If include is specified, the file must match at least one pattern
-  if (tsconfig.include) {
-    let included = false;
-    for (const pattern of tsconfig.include) {
-      if (matchesPattern(relativeToTsconfig, pattern)) {
-        included = true;
-        break;
-      }
-    }
-    if (!included) return true;
-  }
-
-  return false;
-}
-
-/**
- * Find the nearest tsconfig.json walking upward from `startDir`,
- * stopping at `rootDir`.
- */
-function findNearestTsconfig(startDir: string, rootDir: string): TsconfigInfo | null {
-  let dir = startDir;
-  while (true) {
-    const cached = cache.get(dir);
-    if (cached !== undefined) return cached;
-
-    const tsconfigPath = path.join(dir, "tsconfig.json");
-    if (fs.existsSync(tsconfigPath)) {
-      const info = parseTsconfig(dir, tsconfigPath);
-      cache.set(dir, info);
-      return info;
-    }
-
-    if (path.relative(rootDir, dir).startsWith("..") || dir === rootDir) {
-      // Don't look above the project root
-      return null;
-    }
-
-    const parent = path.dirname(dir);
-    if (parent === dir) {
-      return null;
-    }
-    dir = parent;
-  }
-}
-
-function parseTsconfig(dir: string, tsconfigPath: string): TsconfigInfo | null {
-  try {
-    const raw = fs.readFileSync(tsconfigPath, "utf-8");
-    // Strip comments without touching content inside double-quoted strings.
-    const cleaned = raw
-      .replace(/("(?:\\.|[^"\\])*")|\/\/.*$/gm, "$1")
-      .replace(/("(?:\\.|[^"\\])*")|\/[\s\S]*?\*\//g, "$1");
-    const json = JSON.parse(cleaned);
-    return {
-      dir,
-      include: json.include as string[] | undefined,
-      exclude: json.exclude as string[] | undefined,
-    };
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Lightweight pattern matching for tsconfig include/exclude patterns.
- * Handles directory names, extensions, recursive globs, and literal paths.
- */
-function matchesPattern(filePath: string, pattern: string): boolean {
-  const normalizedPattern = pattern.replaceAll("\\", "/");
-
-  // Directory-prefixed recursive glob: prefix/**/*.ext
-  if (normalizedPattern.includes("/**/")) {
-    const idx = normalizedPattern.indexOf("/**/");
-    const prefix = normalizedPattern.slice(0, idx);
-    const suffix = normalizedPattern.slice(idx + 4);
-    return (
-      filePath.startsWith(`${prefix}/`) && matchesPattern(filePath.slice(prefix.length + 1), suffix)
-    );
-  }
-
-  // Recursive glob: **/*.ext
-  if (normalizedPattern.startsWith("**/")) {
-    const suffix = normalizedPattern.slice(3); // e.g., "*.ts"
-    return matchesPattern(filePath, suffix) || filePath.includes(`/${suffix}`);
-  }
-
-  // Directory match: pattern has no glob chars and no "."
-  // e.g., "node_modules" or "__tests__"
-  if (!normalizedPattern.includes("*") && !normalizedPattern.includes(".")) {
-    return (
-      filePath === normalizedPattern ||
-      filePath.startsWith(`${normalizedPattern}/`) ||
-      filePath.includes(`/${normalizedPattern}/`)
-    );
-  }
-
-  // Simple glob: *.ext — match basename
-  if (normalizedPattern.startsWith("*.")) {
-    const ext = normalizedPattern.slice(1); // e.g., ".ts"
-    return filePath.endsWith(ext) && !filePath.includes("/", filePath.length - ext.length - 1);
-  }
-
-  // Literal path
-  if (!normalizedPattern.includes("*")) {
-    return filePath === normalizedPattern || filePath.startsWith(`${normalizedPattern}/`);
-  }
-
-  // Fallback: path contains the pattern segment
-  return filePath.includes(`/${normalizedPattern}`) || filePath === normalizedPattern;
-}
-
-/**
- * Clear the tsconfig cache. Useful for testing or after filesystem changes.
- */
-export function clearTsconfigCache(): void {
-  cache.clear();
-}