@mrclrchtr/supi-lsp 1.3.1 → 1.4.0

package/src/tool/service-actions.ts

@@ -0,0 +1,258 @@
+// Service-backed LSP tool actions used by the public expert toolset.
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { Position } from "../config/types.ts";
+import { formatDiagnostics } from "../diagnostics/diagnostics.ts";
+import {
+  formatCodeActions,
+  formatDocumentSymbols,
+  formatHover,
+  formatLocations,
+  formatSymbolInformation,
+  formatWorkspaceEdit,
+  formatWorkspaceSymbols,
+  normalizeLocations,
+} from "../format.ts";
+import type { SessionLspService } from "../session/service-registry.ts";
+import { resolveSessionPath } from "../utils.ts";
+
+export type LspLookupKind = "hover" | "definition" | "references" | "implementation";
+export type LspRefactorKind = "rename" | "code_actions";
+
+export interface LspLookupToolParams {
+  kind: LspLookupKind;
+  file: string;
+  line: number;
+  character: number;
+}
+
+export interface LspDocumentSymbolsToolParams {
+  file: string;
+}
+
+export interface LspWorkspaceSymbolsToolParams {
+  query: string;
+}
+
+export interface LspDiagnosticsToolParams {
+  file?: string;
+}
+
+export interface LspRefactorToolParams {
+  kind: LspRefactorKind;
+  file: string;
+  line: number;
+  character: number;
+  newName?: string;
+}
+
+function validatePositivePosition(line: number, character: number): string | null {
+  if (!Number.isInteger(line) || line < 1) {
+    return "Validation error: `line` must be a positive 1-based integer.";
+  }
+  if (!Number.isInteger(character) || character < 1) {
+    return "Validation error: `character` must be a positive 1-based integer.";
+  }
+  return null;
+}
+
+function toZeroBased(line: number, character: number): Position {
+  return { line: line - 1, character: character - 1 };
+}
+
+function validateFile(service: SessionLspService, cwd: string, file: string): string | null {
+  const resolvedPath = resolveSessionPath(cwd, file);
+  if (!fs.existsSync(resolvedPath)) {
+    return `File not found: \`${file}\``;
+  }
+  if (!service.isSupportedSourceFile(file)) {
+    return noServerMessage(resolvedPath);
+  }
+  return null;
+}
+
+function noServerMessage(filePath: string): string {
+  return `No LSP server available for this file type (${path.extname(filePath) || "unknown"})`;
+}
+
+function formatUnexpectedFailure(label: string, error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error);
+  return `LSP ${label} failed: ${message}`;
+}
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: semantic lookup dispatch stays clearer as a single position-based switch.
+export async function executeLookup(
+  service: SessionLspService,
+  cwd: string,
+  params: LspLookupToolParams,
+): Promise<string> {
+  try {
+    const positionError = validatePositivePosition(params.line, params.character);
+    if (positionError) return positionError;
+
+    const fileError = validateFile(service, cwd, params.file);
+    if (fileError) return fileError;
+
+    const position = toZeroBased(params.line, params.character);
+    switch (params.kind) {
+      case "hover": {
+        const hover = await service.hover(params.file, position);
+        return hover ? formatHover(hover) : "No hover information available at this position.";
+      }
+      case "definition": {
+        const result = await service.definition(params.file, position);
+        if (!result) return "No definition found.";
+        const locations = normalizeLocations(result);
+        return locations.length > 0
+          ? formatLocations("Definition", locations, cwd)
+          : "No definition found.";
+      }
+      case "references": {
+        const references = await service.references(params.file, position);
+        return references && references.length > 0
+          ? formatLocations("References", references, cwd)
+          : "No references found.";
+      }
+      case "implementation": {
+        const result = await service.implementation(params.file, position);
+        if (!result) return "No implementation found.";
+        const locations = normalizeLocations(result);
+        return locations.length > 0
+          ? formatLocations("Implementation", locations, cwd)
+          : "No implementation found.";
+      }
+    }
+  } catch (error) {
+    return formatUnexpectedFailure("lookup", error);
+  }
+}
+
+export async function executeDocumentSymbols(
+  service: SessionLspService,
+  cwd: string,
+  params: LspDocumentSymbolsToolParams,
+): Promise<string> {
+  try {
+    const fileError = validateFile(service, cwd, params.file);
+    if (fileError) return fileError;
+
+    const symbols = await service.documentSymbols(params.file);
+    if (!symbols || symbols.length === 0) return "No document symbols found.";
+
+    if ("children" in symbols[0] || "selectionRange" in symbols[0]) {
+      return formatDocumentSymbols(symbols as import("../config/types.ts").DocumentSymbol[], 0);
+    }
+    return formatSymbolInformation(
+      symbols as import("../config/types.ts").SymbolInformation[],
+      cwd,
+    );
+  } catch (error) {
+    return formatUnexpectedFailure("document symbol lookup", error);
+  }
+}
+
+export async function executeWorkspaceSymbols(
+  service: SessionLspService,
+  cwd: string,
+  params: LspWorkspaceSymbolsToolParams,
+): Promise<string> {
+  try {
+    const query = params.query.trim();
+    if (query.length === 0) {
+      return "Validation error: `query` must be a non-empty string.";
+    }
+
+    const symbols = await service.workspaceSymbol(query);
+    if (!symbols) return "Workspace symbol search is not supported by the active language servers.";
+    if (symbols.length === 0) return `No symbols found for query \`${query}\`.`;
+
+    return formatWorkspaceSymbols(symbols, cwd);
+  } catch (error) {
+    return formatUnexpectedFailure("workspace symbol lookup", error);
+  }
+}
+
+export async function executeDiagnostics(
+  service: SessionLspService,
+  cwd: string,
+  params: LspDiagnosticsToolParams,
+): Promise<string> {
+  try {
+    if (params.file) {
+      const resolvedPath = resolveSessionPath(cwd, params.file);
+      if (!fs.existsSync(resolvedPath)) {
+        return `File not found: \`${params.file}\``;
+      }
+      if (!service.isSupportedSourceFile(params.file)) {
+        return noServerMessage(resolvedPath);
+      }
+
+      const diagnostics = await service.fileDiagnostics(params.file, 4);
+      if (!diagnostics) return noServerMessage(resolvedPath);
+      return formatDiagnostics(resolvedPath, diagnostics, cwd);
+    }
+
+    const summary = service.getWorkspaceDiagnosticSummary();
+    if (summary.length === 0) return "No diagnostics across any files.";
+
+    const lines = ["## Diagnostics Summary", ""];
+    for (const entry of summary) {
+      lines.push(`- **${entry.file}**: ${entry.errors} error(s), ${entry.warnings} warning(s)`);
+    }
+    return lines.join("\n");
+  } catch (error) {
+    return formatUnexpectedFailure("diagnostics", error);
+  }
+}
+
+export async function executeRefactor(
+  service: SessionLspService,
+  cwd: string,
+  params: LspRefactorToolParams,
+): Promise<string> {
+  try {
+    const positionError = validatePositivePosition(params.line, params.character);
+    if (positionError) return positionError;
+
+    const fileError = validateFile(service, cwd, params.file);
+    if (fileError) return fileError;
+
+    const position = toZeroBased(params.line, params.character);
+
+    if (params.kind === "rename") {
+      if (!params.newName || params.newName.trim().length === 0) {
+        return "Validation error: `newName` is required for rename.";
+      }
+
+      const edit = await service.rename(params.file, position, params.newName.trim());
+      return edit ? formatWorkspaceEdit(edit, cwd) : "Rename not available at this position.";
+    }
+
+    const actions = await service.codeActions(params.file, position);
+    return actions && actions.length > 0
+      ? formatCodeActions(actions)
+      : "No code actions available at this position.";
+  } catch (error) {
+    return formatUnexpectedFailure("refactor", error);
+  }
+}
+
+export async function executeRecover(service: SessionLspService): Promise<string> {
+  try {
+    const result = await service.recoverDiagnostics({ restartIfStillStale: true });
+    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}.`;
+  } catch (error) {
+    return formatUnexpectedFailure("recovery", error);
+  }
+}
+
+function pluralize(count: number, word: string): string {
+  return `${count} ${word}${count === 1 ? "" : "s"}`;
+}

package/src/{ui.ts → ui/ui.ts}

@@ -2,10 +2,10 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { DynamicBorder } from "@earendil-works/pi-coding-agent";
 import type { OverlayHandle } from "@earendil-works/pi-tui";
 import { Container, Spacer, Text } from "@earendil-works/pi-tui";
-import type { LspManager } from "./manager/manager.ts";
-import type { OutstandingDiagnosticSummaryEntry } from "./manager/manager-types.ts";
-import type { Diagnostic, ProjectServerInfo } from "./types.ts";
-import { DiagnosticSeverity } from "./types.ts";
+import type { Diagnostic, ProjectServerInfo } from "../config/types.ts";
+import { DiagnosticSeverity } from "../config/types.ts";
+import type { LspManager } from "../manager/manager.ts";
+import type { OutstandingDiagnosticSummaryEntry } from "../manager/manager-types.ts";
 
 export interface LspInspectorState {
   handle: OverlayHandle | null;

package/src/utils.ts

@@ -27,6 +27,17 @@ export function uriToFile(uri: string): string {
   return filePath;
 }
 
+/**
+ * Resolve a tool-style file path against the active session cwd.
+ *
+ * Built-in pi file tools accept a leading `@` prefix in path arguments, so LSP
+ * helpers strip that prefix as well before resolving relative paths.
+ */
+export function resolveSessionPath(cwd: string, filePath: string): string {
+  const normalizedPath = filePath.startsWith("@") ? filePath.slice(1) : filePath;
+  return path.resolve(cwd, normalizedPath);
+}
+
 // ── Language ID Detection ─────────────────────────────────────────────
 
 const EXT_TO_LANGUAGE: Record<string, string> = {

package/src/guidance.ts

@@ -1,163 +0,0 @@
-import * as path from "node:path";
-import { splitSuppressionDiagnostics } from "./diagnostics/suppression-diagnostics.ts";
-import type { OutstandingDiagnosticSummaryEntry } from "./manager/manager-types.ts";
-import type { Diagnostic, ProjectServerInfo } from "./types.ts";
-
-export const lspPromptSnippet =
-  "Use semantic code intelligence for hover, definitions, references, symbols, rename planning, code actions, and diagnostics in supported languages.";
-
-export const lspPromptGuidelines = [
-  "Prefer the lsp tool over bash text search for supported source files when the task is semantic code navigation or diagnostics.",
-  "Use lsp for hover, definitions, references, document symbols, rename planning, code actions, and diagnostics before falling back to grep-style shell search.",
-  "Fall back to bash/read when LSP is unavailable, the file type is unsupported, or the task is plain-text search across docs, config files, or string literals.",
-  "Diagnostics are automatically delivered: inline after every write/edit tool result, and as context before each agent turn. You do not need to call the lsp tool to check them — they are already in your context.",
-  "When delivered diagnostics show errors, decide: (a) expected temporary state from a planned multi-step change — continue your sequence, then verify at the end; (b) unexpected 'Cannot find module', unresolved imports, or type mismatches — stop and fix the root cause before editing more files.",
-  "When the SAME error pattern appears across MULTIPLE files after you changed imports, dependencies, or shared types, it is a systemic root-cause issue (missing install, broken import path, wrong dependency version). Do not patch each file individually — find and fix the root cause first.",
-  "When diagnostics look stale after package.json, lockfile, tsconfig, or generated-type changes, use lsp recover before editing more files.",
-  "After changing package.json dependencies, imports, or peer dependencies, run the package manager install command (e.g., pnpm install) before concluding that module resolution errors are real code bugs.",
-];
-
-/**
- * Build per-project `promptGuidelines` for the `lsp` tool registration.
- * These guidelines are part of pi's stable system prompt after session-start
- * tool registration, avoiding per-turn `before_agent_start` prompt overrides.
- */
-export function buildProjectGuidelines(servers: ProjectServerInfo[], cwd: string): string[] {
-  const dynamic = servers.map((server) => {
-    const root = displayRoot(server.root, cwd);
-    const fileTypes = server.fileTypes.map((entry) => `.${entry}`).join(", ");
-    const actions = server.supportedActions.join(", ");
-    const status = server.status === "running" ? "active" : "unavailable";
-    const actionText = actions.length > 0 ? ` | actions: ${actions}` : "";
-    return `LSP ${status}: ${server.name} | root: ${root} | files: ${fileTypes}${actionText}`;
-  });
-
-  return [
-    ...lspPromptGuidelines.slice(0, 2),
-    "Use lsp before grep/rg/find for understanding code, finding usages, diagnostics, symbol lookup, and refactors in supported languages.",
-    ...dynamic,
-    "Use lsp actions by task: hover/definition/references/symbols for understanding code, references/workspace_symbol/search for usages, diagnostics/hover/code_actions for issues, and rename/code_actions for refactors.",
-    ...lspPromptGuidelines.slice(2),
-  ].filter(Boolean);
-}
-
-export const MAX_DETAILED_DIAGNOSTICS = 5;
-const MAX_DETAIL_LINES_PER_FILE = 3;
-
-interface DetailedDiagnostics {
-  file: string;
-  diagnostics: Diagnostic[];
-}
-
-export function formatDiagnosticsContext(
-  diagnostics: OutstandingDiagnosticSummaryEntry[],
-  maxFiles: number = 3,
-  detailed?: DetailedDiagnostics[],
-  staleWarning?: string | null,
-): string | null {
-  if (diagnostics.length === 0) return null;
-
-  const totalDiags = diagnostics.reduce((sum, d) => sum + d.total, 0);
-  const detailMap = buildDetailMap(diagnostics, totalDiags, detailed);
-
-  const lines: string[] = [];
-  if (staleWarning) lines.push(staleWarning);
-  const visible = diagnostics.slice(0, maxFiles);
-
-  for (const entry of visible) {
-    lines.push(`- ${entry.file}: ${formatCounts(entry)}`);
-    appendDetailLines(lines, detailMap?.get(entry.file));
-  }
-
-  const remaining = diagnostics.length - visible.length;
-  if (remaining > 0) {
-    lines.push(`- +${remaining} more file${remaining === 1 ? "" : "s"}`);
-  }
-
-  appendSuppressionCleanup(
-    lines,
-    visible.map((entry) => entry.file),
-    detailMap,
-  );
-
-  return [
-    '<extension-context source="supi-lsp">',
-    "Outstanding diagnostics — fix these before proceeding:",
-    ...lines,
-    "</extension-context>",
-  ].join("\n");
-}
-
-function buildDetailMap(
-  _diagnostics: OutstandingDiagnosticSummaryEntry[],
-  totalDiags: number,
-  detailed?: DetailedDiagnostics[],
-): Map<string, Diagnostic[]> | null {
-  if (totalDiags > MAX_DETAILED_DIAGNOSTICS || !detailed || detailed.length === 0) return null;
-  return new Map(detailed.map((d) => [d.file, d.diagnostics]));
-}
-
-function appendDetailLines(lines: string[], details?: Diagnostic[]): void {
-  if (!details) return;
-  for (const d of details.slice(0, MAX_DETAIL_LINES_PER_FILE)) {
-    const line = d.range.start.line + 1;
-    const char = d.range.start.character + 1;
-    const source = d.source ? ` ${d.source}` : "";
-    lines.push(`  L${line} C${char}${source}: ${d.message}`);
-  }
-  if (details.length > MAX_DETAIL_LINES_PER_FILE) {
-    const extra = details.length - MAX_DETAIL_LINES_PER_FILE;
-    lines.push(`  +${extra} more`);
-  }
-}
-
-function appendSuppressionCleanup(
-  lines: string[],
-  visibleFiles: string[],
-  detailMap: Map<string, Diagnostic[]> | null,
-): void {
-  if (!detailMap) return;
-
-  const suppressionLines: string[] = [];
-  for (const file of visibleFiles) {
-    const diagnostics = detailMap.get(file);
-    if (!diagnostics) continue;
-
-    const { suppressions } = splitSuppressionDiagnostics(diagnostics, 1);
-    if (suppressions.length === 0) continue;
-
-    suppressionLines.push(`- ${file}`);
-    appendDetailLines(suppressionLines, suppressions);
-  }
-
-  if (suppressionLines.length === 0) return;
-  lines.push("", "Stale suppression comments — clean these up:", ...suppressionLines);
-}
-
-export function diagnosticsContextFingerprint(content: string | null): string | null {
-  return content;
-}
-
-// reorderDiagnosticContextMessages, getContextToken, and findLastUserMessageIndex
-// have been extracted to supi-core/context-messages.ts.
-// Use pruneAndReorderContextMessages(messages, "lsp-context", activeToken) instead.
-
-function formatCounts(entry: OutstandingDiagnosticSummaryEntry): string {
-  const counts: string[] = [];
-  if (entry.errors > 0) counts.push(pluralize(entry.errors, "error"));
-  if (entry.warnings > 0) counts.push(pluralize(entry.warnings, "warning"));
-  if (entry.information > 0) counts.push(pluralize(entry.information, "info"));
-  if (entry.hints > 0) counts.push(pluralize(entry.hints, "hint"));
-  return counts.join(", ");
-}
-
-function displayRoot(root: string, cwd: string): string {
-  const relative = path.relative(cwd, root);
-  if (relative === "") return ".";
-  if (relative.startsWith(`..${path.sep}`) || relative === "..") return root;
-  return relative.replaceAll(path.sep, "/");
-}
-
-function pluralize(count: number, word: string): string {
-  return `${count} ${word}${count === 1 ? "" : "s"}`;
-}

package/src/search-fallback.ts

@@ -1,98 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-export interface GrepMatch {
-  file: string;
-  line: number;
-  text: string;
-}
-
-const IGNORE_DIRS = new Set([
-  "node_modules",
-  ".git",
-  "dist",
-  "build",
-  ".next",
-  "coverage",
-  "tmp",
-  ".pnpm",
-]);
-
-const SOURCE_EXTENSIONS = new Set([
-  ".ts",
-  ".tsx",
-  ".js",
-  ".jsx",
-  ".mjs",
-  ".cjs",
-  ".py",
-  ".rs",
-  ".go",
-  ".java",
-  ".kt",
-  ".swift",
-  ".rb",
-  ".c",
-  ".cpp",
-  ".h",
-  ".hpp",
-]);
-
-/** Simple recursive text search in project source files. */
-export function fallbackGrep(projectRoot: string, query: string): GrepMatch[] {
-  const results: GrepMatch[] = [];
-  walk(projectRoot, projectRoot, query, results);
-  return results;
-}
-
-function walk(dir: string, projectRoot: string, query: string, results: GrepMatch[]): void {
-  let entries: fs.Dirent[];
-  try {
-    entries = fs.readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      if (!IGNORE_DIRS.has(entry.name)) {
-        walk(path.join(dir, entry.name), projectRoot, query, results);
-      }
-      continue;
-    }
-
-    if (!entry.isFile() || !SOURCE_EXTENSIONS.has(path.extname(entry.name))) {
-      continue;
-    }
-
-    const filePath = path.join(dir, entry.name);
-    searchFile(filePath, projectRoot, query, results);
-    if (results.length >= 20) return;
-  }
-}
-
-function searchFile(
-  filePath: string,
-  projectRoot: string,
-  query: string,
-  results: GrepMatch[],
-): void {
-  let content: string;
-  try {
-    content = fs.readFileSync(filePath, "utf-8");
-  } catch {
-    return;
-  }
-
-  const lines = content.split("\n");
-  for (let i = 0; i < lines.length; i++) {
-    if (lines[i].includes(query)) {
-      results.push({
-        file: path.relative(projectRoot, filePath),
-        line: i + 1,
-        text: lines[i].trim(),
-      });
-      if (results.length >= 20) return;
-    }
-  }
-}