@mrclrchtr/supi-code-intelligence 1.3.1 → 1.5.0

package/node_modules/@mrclrchtr/supi-lsp/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/node_modules/@mrclrchtr/supi-lsp/src/tool/tool-specs.ts

@@ -0,0 +1,248 @@
+import { StringEnum } from "@earendil-works/pi-ai";
+import { type TSchema, Type } from "typebox";
+import type { ServerCapabilities } from "../config/types.ts";
+import type { SessionLspService } from "../session/service-registry.ts";
+import {
+  LSP_DIAGNOSTICS_TOOL,
+  LSP_DOCUMENT_SYMBOLS_TOOL,
+  LSP_LOOKUP_TOOL,
+  LSP_RECOVER_TOOL,
+  LSP_REFACTOR_TOOL,
+  LSP_WORKSPACE_SYMBOLS_TOOL,
+  type LspToolName,
+} from "./names.ts";
+import {
+  executeDiagnostics,
+  executeDocumentSymbols,
+  executeLookup,
+  executeRecover,
+  executeRefactor,
+  executeWorkspaceSymbols,
+} from "./service-actions.ts";
+
+const FileParam = Type.String({ description: "File path (relative or absolute)" });
+const LineParam = Type.Number({ description: "1-based line number", minimum: 1 });
+const CharacterParam = Type.Number({ description: "1-based column number", minimum: 1 });
+const QueryParam = Type.String({ description: "Symbol query string" });
+const NewNameParam = Type.String({ description: "New name for rename" });
+
+export const LSP_LOOKUP_KIND_NAMES = [
+  "hover",
+  "definition",
+  "references",
+  "implementation",
+] as const;
+export const LSP_REFACTOR_KIND_NAMES = ["rename", "code_actions"] as const;
+
+const LookupKindEnum = StringEnum(LSP_LOOKUP_KIND_NAMES);
+const RefactorKindEnum = StringEnum(LSP_REFACTOR_KIND_NAMES);
+
+const LookupParameters = Type.Object(
+  {
+    kind: LookupKindEnum,
+    file: FileParam,
+    line: LineParam,
+    character: CharacterParam,
+  },
+  { additionalProperties: false },
+);
+
+const DocumentSymbolsParameters = Type.Object(
+  {
+    file: FileParam,
+  },
+  { additionalProperties: false },
+);
+
+const WorkspaceSymbolsParameters = Type.Object(
+  {
+    query: QueryParam,
+  },
+  { additionalProperties: false },
+);
+
+const DiagnosticsParameters = Type.Object(
+  {
+    file: Type.Optional(FileParam),
+  },
+  { additionalProperties: false },
+);
+
+const RefactorParameters = Type.Object(
+  {
+    kind: RefactorKindEnum,
+    file: FileParam,
+    line: LineParam,
+    character: CharacterParam,
+    newName: Type.Optional(NewNameParam),
+  },
+  { additionalProperties: false },
+);
+
+const RecoverParameters = Type.Object({}, { additionalProperties: false });
+
+export interface LspToolDefinitionSpec {
+  name: LspToolName;
+  label: string;
+  description: string;
+  promptSnippet: string;
+  basePromptGuidelines: string[];
+  parameters: TSchema;
+  run: (service: SessionLspService, cwd: string, params: unknown) => Promise<string>;
+  includeCoverageGuidelines?: boolean;
+}
+
+export const LSP_TOOL_DEFINITION_SPECS = [
+  {
+    name: LSP_LOOKUP_TOOL,
+    label: "LSP Lookup",
+    description:
+      "Language Server Protocol lookup tool — semantic hover, definition, references, and implementation for supported files. Use lsp_lookup when you know the file and 1-based line/character position and need semantic drill-down rather than text search.",
+    promptSnippet:
+      "lsp_lookup — semantic hover/definition/references/implementation at a known file position",
+    basePromptGuidelines: [
+      'Use lsp_lookup with `kind: "hover"` for semantic type or symbol information at a known `file`, `line`, and `character`.',
+      'Use lsp_lookup with `kind: "definition"`, `"references"`, or `"implementation"` for semantic navigation at a known position.',
+      "Use lsp_lookup after code_intel or tree_sitter has already narrowed the target file and position.",
+    ],
+    parameters: LookupParameters,
+    run: (service, cwd, params) =>
+      executeLookup(service, cwd, params as Parameters<typeof executeLookup>[2]),
+    includeCoverageGuidelines: true,
+  },
+  {
+    name: LSP_DOCUMENT_SYMBOLS_TOOL,
+    label: "LSP Document Symbols",
+    description:
+      "Language Server Protocol document symbols tool — list semantic declarations in one supported file. Use lsp_document_symbols when you need a symbol-aware outline rather than raw text structure.",
+    promptSnippet: "lsp_document_symbols — semantic declarations for one supported file",
+    basePromptGuidelines: [
+      "Use lsp_document_symbols(file) for semantic declarations in one supported file.",
+    ],
+    parameters: DocumentSymbolsParameters,
+    run: (service, cwd, params) =>
+      executeDocumentSymbols(service, cwd, params as Parameters<typeof executeDocumentSymbols>[2]),
+  },
+  {
+    name: LSP_WORKSPACE_SYMBOLS_TOOL,
+    label: "LSP Workspace Symbols",
+    description:
+      "Language Server Protocol workspace symbols tool — semantic symbol-name lookup across the current project. Use lsp_workspace_symbols to find declarations by name before opening a specific file.",
+    promptSnippet: "lsp_workspace_symbols — semantic symbol-name lookup across the project",
+    basePromptGuidelines: [
+      "Use lsp_workspace_symbols(query) for semantic symbol-name lookup across the current project.",
+    ],
+    parameters: WorkspaceSymbolsParameters,
+    run: (service, cwd, params) =>
+      executeWorkspaceSymbols(
+        service,
+        cwd,
+        params as Parameters<typeof executeWorkspaceSymbols>[2],
+      ),
+  },
+  {
+    name: LSP_DIAGNOSTICS_TOOL,
+    label: "LSP Diagnostics",
+    description:
+      "Language Server Protocol diagnostics tool — current diagnostics for one file or a workspace summary. Use lsp_diagnostics for semantic compiler or language-server issues instead of guessing from text alone.",
+    promptSnippet: "lsp_diagnostics — current diagnostics for one file or the workspace",
+    basePromptGuidelines: [
+      "Use lsp_diagnostics(file?) when you need current diagnostics for one file or a workspace-level summary.",
+    ],
+    parameters: DiagnosticsParameters,
+    run: (service, cwd, params) =>
+      executeDiagnostics(service, cwd, params as Parameters<typeof executeDiagnostics>[2]),
+  },
+  {
+    name: LSP_REFACTOR_TOOL,
+    label: "LSP Refactor",
+    description:
+      "Language Server Protocol refactor tool — semantic rename planning and code actions at a known file position. Use lsp_refactor when you need language-server-backed edits or quick-fix suggestions.",
+    promptSnippet: "lsp_refactor — semantic rename planning and code actions at a known position",
+    basePromptGuidelines: [
+      'Use lsp_refactor with `kind: "rename"` for semantic rename planning at a known `file`, `line`, and `character`.',
+      'Use lsp_refactor with `kind: "code_actions"` for semantic fixes or refactors at a known position.',
+    ],
+    parameters: RefactorParameters,
+    run: (service, cwd, params) =>
+      executeRefactor(service, cwd, params as Parameters<typeof executeRefactor>[2]),
+  },
+  {
+    name: LSP_RECOVER_TOOL,
+    label: "LSP Recover",
+    description:
+      "Language Server Protocol recover tool — refresh diagnostics after workspace changes and stale language-server state. Use lsp_recover when new files, generated types, or config updates leave diagnostics out of sync.",
+    promptSnippet: "lsp_recover — refresh stale diagnostics after workspace changes",
+    basePromptGuidelines: [
+      "Use lsp_recover() when diagnostics look stale after workspace-level changes or generated-file updates.",
+    ],
+    parameters: RecoverParameters,
+    run: (service) => executeRecover(service),
+  },
+] as const satisfies readonly LspToolDefinitionSpec[];
+
+const LSP_TOOL_SPEC_MAP = new Map<LspToolName, LspToolDefinitionSpec>(
+  LSP_TOOL_DEFINITION_SPECS.map((spec) => [spec.name, spec]),
+);
+
+export function getLspToolDefinitionSpec(toolName: LspToolName): LspToolDefinitionSpec {
+  const spec = LSP_TOOL_SPEC_MAP.get(toolName);
+  if (!spec) {
+    throw new Error(`Unknown LSP tool: ${toolName}`);
+  }
+  return spec;
+}
+
+interface LspServerSupportedActionSpec {
+  label: string;
+  isSupported: (capabilities: ServerCapabilities | null | undefined) => boolean;
+}
+
+const LSP_SERVER_SUPPORTED_ACTION_SPECS: readonly LspServerSupportedActionSpec[] = [
+  {
+    label: "diagnostics [optional file]",
+    isSupported: () => true,
+  },
+  {
+    label: "hover(file,line,char)",
+    isSupported: (capabilities) => Boolean(capabilities?.hoverProvider),
+  },
+  {
+    label: "definition(file,line,char)",
+    isSupported: (capabilities) => Boolean(capabilities?.definitionProvider),
+  },
+  {
+    label: "references(file,line,char)",
+    isSupported: (capabilities) => Boolean(capabilities?.referencesProvider),
+  },
+  {
+    label: "implementation(file,line,char)",
+    isSupported: (capabilities) => Boolean(capabilities?.implementationProvider),
+  },
+  {
+    label: "symbols(file)",
+    isSupported: (capabilities) => Boolean(capabilities?.documentSymbolProvider),
+  },
+  {
+    label: "workspace_symbols(query)",
+    isSupported: (capabilities) => Boolean(capabilities?.workspaceSymbolProvider),
+  },
+  {
+    label: "rename(file,line,char,newName)",
+    isSupported: (capabilities) => Boolean(capabilities?.renameProvider),
+  },
+  {
+    label: "code_actions(file,line,char)",
+    isSupported: (capabilities) => Boolean(capabilities?.codeActionProvider),
+  },
+] as const;
+
+export function getSupportedLspServerActions(
+  capabilities: ServerCapabilities | null | undefined,
+): string[] {
+  if (!capabilities) return [];
+
+  return LSP_SERVER_SUPPORTED_ACTION_SPECS.filter((spec) => spec.isSupported(capabilities)).map(
+    (spec) => spec.label,
+  );
+}

package/node_modules/@mrclrchtr/supi-lsp/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/node_modules/@mrclrchtr/supi-lsp/src/utils.ts

@@ -2,30 +2,12 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-// ── URI Handling ──────────────────────────────────────────────────────
 
-/** Convert a file path to a file:// URI. */
-export function fileToUri(filePath: string): string {
-  const resolved = path.resolve(filePath);
-  if (process.platform === "win32") {
-    return `file:///${resolved.replace(/\\/g, "/")}`;
-  }
-  return `file://${resolved}`;
-}
-
-/** Convert a file:// URI to a file path. */
-export function uriToFile(uri: string): string {
-  if (!uri.startsWith("file://")) return uri;
-  let filePath = decodeURIComponent(uri.slice(7));
-  if (
-    process.platform === "win32" &&
-    filePath.startsWith("/") &&
-    /^[A-Za-z]:/.test(filePath.slice(1))
-  ) {
-    filePath = filePath.slice(1);
-  }
-  return filePath;
-}
+export {
+  fileToUri,
+  resolveToolPath as resolveSessionPath,
+  uriToFile,
+} from "@mrclrchtr/supi-core/api";
 
 // ── Language ID Detection ─────────────────────────────────────────────