@mrclrchtr/supi-lsp 0.1.0 → 1.1.2

package/runtime-state.ts

@@ -1,113 +0,0 @@
-// Runtime LSP guidance state — tracks qualifying source interactions and
-// computes stateful pre-turn guidance so runtime guidance stays dormant
-// until the session actually touches supported source files.
-
-import { existsSync } from "node:fs";
-import * as path from "node:path";
-import {
-  buildRuntimeLspGuidance,
-  computeTrackedDiagnosticsSummary,
-  type RuntimeGuidanceInput,
-} from "./guidance.ts";
-import type { LspManager } from "./manager.ts";
-import { getRawFilePathFromToolEvent } from "./recent-paths.ts";
-import { displayRelativeFilePath } from "./summary.ts";
-
-export const MAX_TRACKED_SOURCE_PATHS = 8;
-
-export interface LspRuntimeGuidanceState {
-  runtimeActive: boolean;
-  trackedSourcePaths: string[];
-  pendingActivation: boolean;
-  lastInjectedFingerprint: string | null;
-}
-
-export function createRuntimeGuidanceState(): LspRuntimeGuidanceState {
-  return {
-    runtimeActive: false,
-    trackedSourcePaths: [],
-    pendingActivation: false,
-    lastInjectedFingerprint: null,
-  };
-}
-
-export function resetRuntimeGuidanceState(state: LspRuntimeGuidanceState): void {
-  state.runtimeActive = false;
-  state.trackedSourcePaths = [];
-  state.pendingActivation = false;
-  state.lastInjectedFingerprint = null;
-}
-
-export function registerQualifyingSourceInteraction(
-  state: LspRuntimeGuidanceState,
-  manager: LspManager,
-  toolName: string,
-  input: Record<string, unknown>,
-): void {
-  const rawPath = getRawFilePathFromToolEvent(toolName, input);
-  if (!rawPath) return;
-  if (!manager.isSupportedSourceFile(rawPath)) return;
-
-  // displayRelativeFilePath is the same form diagnostics get keyed under, so
-  // the tracked-files list lines up with diagnostic relevance matching for
-  // both in-tree files (relative form) and out-of-tree absolute paths.
-  const trackedPath = displayRelativeFilePath(rawPath);
-
-  // pendingActivation is a one-shot signal: set only on the first qualifying
-  // interaction so the next turn can inject the "LSP ready" hint exactly once.
-  // Subsequent interactions keep tracking files but must not re-arm activation
-  // — the caller clears the flag after injecting.
-  const wasDormant = !state.runtimeActive;
-  state.runtimeActive = true;
-
-  if (wasDormant) {
-    state.pendingActivation = true;
-  }
-
-  state.trackedSourcePaths = [
-    trackedPath,
-    ...state.trackedSourcePaths.filter((entry) => entry !== trackedPath),
-  ].slice(0, MAX_TRACKED_SOURCE_PATHS);
-}
-
-/**
- * Drop tracked source paths whose underlying file is gone (deleted/renamed).
- * Without this, `pruneMissingFiles()` cleans the live LSP clients but the
- * runtime guidance would keep advertising the stale path on subsequent turns,
- * and the session couldn't return to a dormant state until other interactions
- * evicted the entry. Tracked paths are in `displayRelativeFilePath` form so
- * `path.resolve` transparently handles both in-tree relative and out-of-tree
- * absolute entries.
- */
-export function pruneMissingTrackedPaths(state: LspRuntimeGuidanceState): void {
-  if (state.trackedSourcePaths.length === 0) return;
-  const surviving = state.trackedSourcePaths.filter((entry) => existsSync(path.resolve(entry)));
-  if (surviving.length === state.trackedSourcePaths.length) return;
-  state.trackedSourcePaths = surviving;
-  if (surviving.length === 0) {
-    state.runtimeActive = false;
-    state.pendingActivation = false;
-  }
-}
-
-export function computePendingRuntimeGuidance(
-  state: LspRuntimeGuidanceState,
-  manager: LspManager,
-  inlineSeverity: number,
-): { input: RuntimeGuidanceInput; content: string | null } | null {
-  if (!state.runtimeActive) return null;
-
-  const diagnosticsSummary = computeTrackedDiagnosticsSummary(
-    manager,
-    inlineSeverity,
-    state.trackedSourcePaths,
-  );
-
-  const input: RuntimeGuidanceInput = {
-    pendingActivation: state.pendingActivation,
-    diagnosticsSummary,
-    trackedFiles: state.trackedSourcePaths,
-  };
-
-  return { input, content: buildRuntimeLspGuidance(input) };
-}

package/tool-actions.ts

@@ -1,211 +0,0 @@
-// LSP tool action implementations — dispatches agent tool calls to LSP clients.
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { formatDiagnostics } from "./diagnostics.ts";
-import {
-  formatCodeActions,
-  formatDocumentSymbols,
-  formatHover,
-  formatLocations,
-  formatSymbolInformation,
-  formatWorkspaceEdit,
-  normalizeLocations,
-} from "./format.ts";
-import type { LspManager } from "./manager.ts";
-import type { DocumentSymbol, Range, SymbolInformation } from "./types.ts";
-
-// ── Types ─────────────────────────────────────────────────────────────
-
-export type LspAction =
-  | "hover"
-  | "definition"
-  | "references"
-  | "diagnostics"
-  | "symbols"
-  | "rename"
-  | "code_actions";
-
-export interface LspToolParams {
-  action: LspAction;
-  file?: string;
-  line?: number;
-  character?: number;
-  newName?: 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
-
-Line and character are 1-based. File paths are relative to cwd.`;
-
-// ── Action Dispatcher ─────────────────────────────────────────────────
-
-export async function executeAction(manager: LspManager, params: LspToolParams): Promise<string> {
-  switch (params.action) {
-    case "hover":
-      return handleHover(manager, params);
-    case "definition":
-      return handleDefinition(manager, params);
-    case "references":
-      return handleReferences(manager, params);
-    case "diagnostics":
-      return handleDiagnostics(manager, params);
-    case "symbols":
-      return handleSymbols(manager, params);
-    case "rename":
-      return handleRename(manager, params);
-    case "code_actions":
-      return handleCodeActions(manager, params);
-    default:
-      return `Unknown action: ${params.action}`;
-  }
-}
-
-// ── Action Handlers ───────────────────────────────────────────────────
-
-async function handleHover(manager: LspManager, params: LspToolParams): Promise<string> {
-  const { file, line, character } = requireFilePosition(params);
-  const client = await manager.ensureFileOpen(file);
-  if (!client) return noServerMessage(file);
-
-  const hover = await client.hover(path.resolve(file), toZeroBased(line, character));
-  if (!hover) return "No hover information available at this position.";
-  return formatHover(hover);
-}
-
-async function handleDefinition(manager: LspManager, params: LspToolParams): Promise<string> {
-  const { file, line, character } = requireFilePosition(params);
-  const client = await manager.ensureFileOpen(file);
-  if (!client) return noServerMessage(file);
-
-  const result = await client.definition(path.resolve(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);
-}
-
-async function handleReferences(manager: LspManager, params: LspToolParams): Promise<string> {
-  const { file, line, character } = requireFilePosition(params);
-  const client = await manager.ensureFileOpen(file);
-  if (!client) return noServerMessage(file);
-
-  const locations = await client.references(path.resolve(file), toZeroBased(line, character));
-  if (!locations || locations.length === 0) return "No references found.";
-
-  return formatLocations("References", locations);
-}
-
-async function handleDiagnostics(manager: LspManager, params: LspToolParams): Promise<string> {
-  if (params.file) {
-    const resolvedPath = path.resolve(params.file);
-    const client = await manager.ensureFileOpen(params.file);
-    if (!client) return noServerMessage(params.file);
-
-    let content: string;
-    try {
-      content = fs.readFileSync(resolvedPath, "utf-8");
-    } catch {
-      return `Error: cannot read file ${params.file}`;
-    }
-
-    const diags = await client.syncAndWaitForDiagnostics(resolvedPath, content);
-    return formatDiagnostics(params.file, diags);
-  }
-
-  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): Promise<string> {
-  if (!params.file) return "Error: 'file' parameter is required for symbols action.";
-
-  const client = await manager.ensureFileOpen(params.file);
-  if (!client) return noServerMessage(params.file);
-
-  const symbols = await client.documentSymbols(path.resolve(params.file));
-  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[]);
-}
-
-async function handleRename(manager: LspManager, params: LspToolParams): Promise<string> {
-  const { file, line, character } = requireFilePosition(params);
-  if (!params.newName) return "Error: 'newName' parameter is required for rename action.";
-
-  const client = await manager.ensureFileOpen(file);
-  if (!client) return noServerMessage(file);
-
-  const edit = await client.rename(
-    path.resolve(file),
-    toZeroBased(line, character),
-    params.newName,
-  );
-  if (!edit) return "Rename not available at this position.";
-
-  return formatWorkspaceEdit(edit);
-}
-
-async function handleCodeActions(manager: LspManager, params: LspToolParams): Promise<string> {
-  const { file, line, character } = requireFilePosition(params);
-  const client = await manager.ensureFileOpen(file);
-  if (!client) return noServerMessage(file);
-
-  const pos = toZeroBased(line, character);
-  const range: Range = { start: pos, end: pos };
-  const diags = client.getDiagnostics(path.resolve(file));
-
-  const relevantDiags = diags.filter(
-    (d) => d.range.start.line <= pos.line && d.range.end.line >= pos.line,
-  );
-
-  const actions = await client.codeActions(path.resolve(file), range, {
-    diagnostics: relevantDiags,
-  });
-  if (!actions || actions.length === 0) return "No code actions available at this position.";
-
-  return formatCodeActions(actions);
-}
-
-// ── Utility ───────────────────────────────────────────────────────────
-
-function requireFilePosition(params: LspToolParams): {
-  file: string;
-  line: number;
-  character: number;
-} {
-  if (!params.file) throw new Error("'file' parameter is required.");
-  if (params.line === undefined) throw new Error("'line' parameter is required.");
-  if (params.character === undefined) throw new Error("'character' parameter is required.");
-  return { file: params.file, line: params.line, character: params.character };
-}
-
-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"})`;
-}

package/tsconfig.json

@@ -1,5 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "include": ["*.ts"],
-  "exclude": ["__tests__"]
-}

package/ui.ts

@@ -1,303 +0,0 @@
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
-import { DynamicBorder } from "@mariozechner/pi-coding-agent";
-import type { OverlayHandle } from "@mariozechner/pi-tui";
-import { Container, Spacer, Text } from "@mariozechner/pi-tui";
-import type {
-  ActiveCoverageSummaryEntry,
-  LspManager,
-  OutstandingDiagnosticSummaryEntry,
-} from "./manager.ts";
-
-export interface LspInspectorState {
-  handle: OverlayHandle | null;
-  close: (() => void) | null;
-}
-
-export function updateLspUi(
-  ctx: ExtensionContext,
-  manager: LspManager,
-  inlineSeverity: number,
-): void {
-  const activeCoverage = manager.getActiveCoverageSummary();
-  const diagnostics = manager.getOutstandingDiagnosticSummary(inlineSeverity);
-
-  ctx.ui.setStatus("lsp", buildLspStatus(ctx, activeCoverage, diagnostics));
-  ctx.ui.setWidget(
-    "lsp",
-    hasWidgetContent(activeCoverage, diagnostics)
-      ? (_tui, theme) => buildLspWidgetComponent(theme, activeCoverage, diagnostics)
-      : undefined,
-    { placement: "belowEditor" },
-  );
-}
-
-export function toggleLspStatusOverlay(
-  ctx: ExtensionContext,
-  manager: LspManager,
-  inlineSeverity: number,
-  inspector: LspInspectorState,
-): void {
-  if (inspector.handle && inspector.close) {
-    inspector.close();
-    return;
-  }
-
-  void ctx.ui
-    .custom<void>(
-      (_tui, theme, _kb, done) => {
-        inspector.close = () => done(undefined);
-        return createLspInspectorComponent(theme, manager, inlineSeverity);
-      },
-      {
-        overlay: true,
-        overlayOptions: {
-          anchor: "right-center",
-          width: 52,
-          maxHeight: "75%",
-          margin: { right: 1, top: 1, bottom: 1 },
-          nonCapturing: true,
-        },
-        onHandle: (handle) => {
-          inspector.handle = handle;
-        },
-      },
-    )
-    .finally(() => {
-      inspector.handle = null;
-      inspector.close = null;
-    });
-}
-
-function createLspInspectorComponent(
-  theme: ExtensionContext["ui"]["theme"],
-  manager: LspManager,
-  inlineSeverity: number,
-): { render: (width: number) => string[]; invalidate: () => void } {
-  return {
-    render: (width) => buildLspInspectorContainer(theme, manager, inlineSeverity).render(width),
-    invalidate: () => {},
-  };
-}
-
-function buildLspInspectorContainer(
-  theme: ExtensionContext["ui"]["theme"],
-  manager: LspManager,
-  inlineSeverity: number,
-): Container {
-  const activeCoverage = manager.getActiveCoverageSummary();
-  const diagnostics = manager.getOutstandingDiagnosticSummary(inlineSeverity);
-  const container = new Container();
-
-  container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
-  container.addChild(
-    new Text(
-      theme.fg("accent", theme.bold(" λ LSP")) + theme.fg("dim", " inspector  /lsp-status toggles"),
-      1,
-      0,
-    ),
-  );
-
-  if (isQuietInspectorState(activeCoverage, diagnostics)) {
-    container.addChild(
-      new Text(theme.fg("success", "clean") + theme.fg("dim", " • no active servers"), 1, 0),
-    );
-    container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
-    return container;
-  }
-
-  container.addChild(new Text(buildOverlaySummaryLine(theme, activeCoverage, diagnostics), 1, 0));
-  container.addChild(new Spacer(1));
-  container.addChild(
-    buildOverlaySection(theme, "Coverage", buildOverlayCoverageLines(theme, activeCoverage)),
-  );
-  container.addChild(new Spacer(1));
-  container.addChild(
-    buildOverlaySection(
-      theme,
-      diagnostics.length > 0 ? "Problems" : "Diagnostics",
-      buildOverlayDiagnosticLines(theme, diagnostics),
-    ),
-  );
-  container.addChild(new Spacer(1));
-  container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
-
-  return container;
-}
-
-function isQuietInspectorState(
-  activeCoverage: ActiveCoverageSummaryEntry[],
-  diagnostics: OutstandingDiagnosticSummaryEntry[],
-): boolean {
-  return activeCoverage.length === 0 && diagnostics.length === 0;
-}
-
-function buildLspStatus(
-  ctx: ExtensionContext,
-  activeCoverage: ActiveCoverageSummaryEntry[],
-  diagnostics: OutstandingDiagnosticSummaryEntry[],
-): string | undefined {
-  const activeServers = activeCoverage.length;
-  const openFiles = activeCoverage.reduce((sum, entry) => sum + entry.openFiles.length, 0);
-  const errors = diagnostics.reduce((sum, entry) => sum + entry.errors, 0);
-  const warnings = diagnostics.reduce((sum, entry) => sum + entry.warnings, 0);
-
-  if (activeServers === 0 && openFiles === 0 && errors === 0 && warnings === 0) {
-    return undefined;
-  }
-
-  const { theme } = ctx.ui;
-  const parts = [theme.fg("accent", "λ lsp")];
-  if (activeServers > 0) parts.push(theme.fg("dim", pluralize(activeServers, "server")));
-  if (openFiles > 0) parts.push(theme.fg("dim", pluralize(openFiles, "open file")));
-  if (errors > 0) parts.push(theme.fg("error", pluralize(errors, "error")));
-  if (warnings > 0) parts.push(theme.fg("warning", pluralize(warnings, "warning")));
-  return parts.join(theme.fg("dim", " • "));
-}
-
-function hasWidgetContent(
-  _activeCoverage: ActiveCoverageSummaryEntry[],
-  diagnostics: OutstandingDiagnosticSummaryEntry[],
-): boolean {
-  return diagnostics.length > 0;
-}
-
-function buildLspWidgetComponent(
-  theme: ExtensionContext["ui"]["theme"],
-  _activeCoverage: ActiveCoverageSummaryEntry[],
-  diagnostics: OutstandingDiagnosticSummaryEntry[],
-): Container {
-  const container = new Container();
-
-  for (const line of buildWidgetDiagnosticLines(theme, diagnostics)) {
-    container.addChild(new Text(line, 0, 0));
-  }
-
-  return container;
-}
-
-function buildWidgetDiagnosticLines(
-  theme: ExtensionContext["ui"]["theme"],
-  diagnostics: OutstandingDiagnosticSummaryEntry[],
-): string[] {
-  if (diagnostics.length === 1) {
-    const [entry] = diagnostics;
-    if (!entry) return [];
-    return [
-      `${theme.fg("error", "●")} ${entry.file} ${theme.fg("dim", `— ${formatDiagnosticCounts(entry)}`)}`,
-    ];
-  }
-
-  const totalErrors = diagnostics.reduce((sum, entry) => sum + entry.errors, 0);
-  const totalWarnings = diagnostics.reduce((sum, entry) => sum + entry.warnings, 0);
-  const counts: string[] = [];
-  if (totalErrors > 0) counts.push(theme.fg("error", pluralize(totalErrors, "error")));
-  if (totalWarnings > 0) counts.push(theme.fg("warning", pluralize(totalWarnings, "warning")));
-
-  const visibleFiles = diagnostics.slice(0, 2).map((entry) => entry.file);
-  const remaining = diagnostics.length - visibleFiles.length;
-  const suffix = remaining > 0 ? `${theme.fg("dim", ` +${remaining} more`)}` : "";
-
-  return [
-    `${theme.fg("accent", theme.bold("λ LSP diagnostics"))} ${theme.fg("dim", `— ${pluralize(diagnostics.length, "file")}`)} ${counts.join(theme.fg("dim", " • "))}`,
-    `${theme.fg("error", "↳")} ${visibleFiles.join(", ")}${suffix}`,
-  ];
-}
-
-function buildOverlaySummaryLine(
-  theme: ExtensionContext["ui"]["theme"],
-  activeCoverage: ActiveCoverageSummaryEntry[],
-  diagnostics: OutstandingDiagnosticSummaryEntry[],
-): string {
-  const activeServers = activeCoverage.length;
-  const openFiles = activeCoverage.reduce((sum, entry) => sum + entry.openFiles.length, 0);
-  const errors = diagnostics.reduce((sum, entry) => sum + entry.errors, 0);
-  const warnings = diagnostics.reduce((sum, entry) => sum + entry.warnings, 0);
-
-  const parts = [
-    theme.fg("dim", `${pluralize(activeServers, "server")} • ${pluralize(openFiles, "open file")}`),
-  ];
-  if (errors > 0) {
-    parts.push(theme.fg("error", pluralize(errors, "error")));
-  } else if (warnings > 0) {
-    parts.push(theme.fg("warning", pluralize(warnings, "warning")));
-  } else {
-    parts.push(theme.fg("success", "clean"));
-  }
-
-  return parts.join(theme.fg("dim", "   "));
-}
-
-function buildOverlaySection(
-  theme: ExtensionContext["ui"]["theme"],
-  title: string,
-  lines: string[],
-): Container {
-  const container = new Container();
-  container.addChild(new Text(theme.fg("accent", theme.bold(` ${title}`)), 1, 0));
-  for (const line of lines) {
-    container.addChild(new Text(line, 2, 0));
-  }
-  return container;
-}
-
-function buildOverlayCoverageLines(
-  theme: ExtensionContext["ui"]["theme"],
-  activeCoverage: ActiveCoverageSummaryEntry[],
-): string[] {
-  if (activeCoverage.length === 0) {
-    return [theme.fg("dim", "no active LSP servers")];
-  }
-
-  return activeCoverage.flatMap((entry) => {
-    const visibleFiles = entry.openFiles.slice(0, 2);
-    const remainingFiles = entry.openFiles.length - visibleFiles.length;
-    const fileLine = visibleFiles.length > 0 ? visibleFiles.join(", ") : "none";
-    const suffix = remainingFiles > 0 ? theme.fg("dim", ` +${remainingFiles} more`) : "";
-
-    return [
-      `${theme.fg("accent", "◆")} ${entry.name} ${theme.fg("dim", `— ${pluralize(entry.openFiles.length, "file")}`)}`,
-      `${theme.fg("dim", "↳")} ${fileLine}${suffix}`,
-    ];
-  });
-}
-
-function buildOverlayDiagnosticLines(
-  theme: ExtensionContext["ui"]["theme"],
-  diagnostics: OutstandingDiagnosticSummaryEntry[],
-): string[] {
-  if (diagnostics.length === 0) {
-    return [theme.fg("success", "✓ no outstanding diagnostics")];
-  }
-
-  const lines = diagnostics
-    .slice(0, 5)
-    .map(
-      (entry) =>
-        `${theme.fg("error", "●")} ${entry.file} ${theme.fg("dim", `— ${formatDiagnosticCounts(entry)}`)}`,
-    );
-
-  const remainingDiagnostics = diagnostics.length - Math.min(diagnostics.length, 5);
-  if (remainingDiagnostics > 0) {
-    lines.push(
-      theme.fg(
-        "dim",
-        `↳ +${remainingDiagnostics} more diagnostic file${remainingDiagnostics === 1 ? "" : "s"}`,
-      ),
-    );
-  }
-
-  return lines;
-}
-
-function formatDiagnosticCounts(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 pluralize(count: number, word: string): string {
-  return `${count} ${word}${count === 1 ? "" : "s"}`;
-}