@mrclrchtr/supi-lsp 1.16.0 → 2.0.0

package/src/session/settings-registration.ts

@@ -1,296 +0,0 @@
-// LSP settings registration for the supi settings registry.
-
-import { CONFIG_DIR_NAME, getSettingsListTheme } from "@earendil-works/pi-coding-agent";
-import type { SettingItem } from "@earendil-works/pi-tui";
-import { Container, Key, matchesKey, SettingsList, Text } from "@earendil-works/pi-tui";
-import {
-  loadSupiConfig,
-  loadSupiConfigForScope,
-  registerConfigSettings,
-} from "@mrclrchtr/supi-core/config";
-import { loadConfig } from "../config/config.ts";
-
-// ── Types ────────────────────────────────────────────────────
-
-export interface LspSettings {
-  enabled: boolean;
-  severity: number;
-  active: string[];
-  exclude: string[];
-}
-
-const LSP_DEFAULTS: LspSettings = {
-  enabled: true,
-  severity: 1,
-  active: [],
-  exclude: [],
-};
-
-// ── Config helpers ───────────────────────────────────────────
-
-export function loadLspSettings(cwd: string, homeDir?: string): LspSettings {
-  return loadSupiConfig("lsp", cwd, LSP_DEFAULTS, { homeDir });
-}
-
-/**
- * Return a user-facing message that indicates which config scope disabled LSP.
- */
-export function getLspDisabledMessage(cwd: string, homeDir?: string): string {
-  const global = loadSupiConfigForScope("lsp", cwd, LSP_DEFAULTS, { scope: "global", homeDir });
-  const project = loadSupiConfigForScope("lsp", cwd, LSP_DEFAULTS, { scope: "project", homeDir });
-
-  if (project.enabled === false) {
-    return `LSP is disabled in project settings (${CONFIG_DIR_NAME}/supi/config.json)`;
-  }
-  if (global.enabled === false) {
-    return `LSP is disabled in global settings (~/${CONFIG_DIR_NAME}/agent/supi/config.json)`;
-  }
-  return "LSP is disabled in settings";
-}
-
-function severityLabel(severity: number): string {
-  switch (severity) {
-    case 1:
-      return "errors";
-    case 2:
-      return "warnings";
-    case 3:
-      return "info";
-    case 4:
-      return "hints";
-    default:
-      return "errors";
-  }
-}
-
-// ── Settings registration ────────────────────────────────────
-
-export function registerLspSettings(): void {
-  registerConfigSettings({
-    id: "lsp",
-    label: "LSP",
-    section: "lsp",
-    defaults: LSP_DEFAULTS,
-    buildItems: (settings, scope, cwd) => buildLspSettingItems(settings, scope, cwd),
-    // biome-ignore lint/complexity/useMaxParams: ConfigSettingsOptions interface callback
-    persistChange: (_scope, _cwd, settingId, value, helpers) => {
-      handlePersistChange(settingId, value, helpers);
-    },
-  });
-}
-
-function handlePersistChange(
-  settingId: string,
-  value: string,
-  helpers: { set: (key: string, value: unknown) => void; unset: (key: string) => void },
-): void {
-  switch (settingId) {
-    case "enabled":
-      helpers.set("enabled", value === "on");
-      break;
-    case "severity": {
-      const num = Number.parseInt(value.split(" ")[0] ?? "1", 10);
-      helpers.set("severity", Number.isNaN(num) ? 1 : num);
-      break;
-    }
-    case "active": {
-      const active = value
-        .split(",")
-        .map((s) => s.trim())
-        .filter((s) => s.length > 0);
-      if (active.length > 0) {
-        helpers.set("active", active);
-      } else {
-        helpers.unset("active");
-      }
-      break;
-    }
-    case "exclude": {
-      const patterns = value
-        .split(",")
-        .map((s) => s.trim())
-        .filter((s) => s.length > 0);
-      if (patterns.length > 0) {
-        helpers.set("exclude", patterns);
-      } else {
-        helpers.unset("exclude");
-      }
-      break;
-    }
-  }
-}
-
-function buildLspSettingItems(
-  settings: LspSettings,
-  scope: "project" | "global",
-  cwd: string,
-): SettingItem[] {
-  return [
-    {
-      id: "enabled",
-      label: "Enable LSP",
-      description: "Enable or disable all LSP functionality",
-      currentValue: settings.enabled ? "on" : "off",
-      values: ["on", "off"],
-    },
-    {
-      id: "severity",
-      label: "Inline Severity",
-      description: "Minimum diagnostic severity to show inline (1=errors, 4=hints)",
-      currentValue: `${settings.severity} (${severityLabel(settings.severity)})`,
-      values: ["1 (errors)", "2 (warnings)", "3 (info)", "4 (hints)"],
-    },
-    {
-      id: "active",
-      label: "Active Servers",
-      description: "Press Enter to configure which language servers are active",
-      currentValue: settings.active.length > 0 ? settings.active.join(", ") : "all",
-      submenu: (_currentValue, done) => createServerSubmenu(scope, cwd, settings, done),
-    },
-    {
-      id: "exclude",
-      label: "Exclude Patterns",
-      description:
-        "Gitignore patterns to suppress LSP diagnostics. Edit .pi/supi/config.json → lsp.exclude (or ~/.pi/agent/supi/config.json for global). Patterns like __tests__/ exclude a directory, *.test.ts wildcards match at any depth, /dist anchors to root.",
-      currentValue: settings.exclude.length > 0 ? settings.exclude.join(", ") : "none",
-      submenu: (_currentValue, done) => createExcludeSubmenu(scope, cwd, settings, done),
-    },
-  ];
-}
-
-// ── Server submenu ───────────────────────────────────────────
-
-function createServerSubmenu(
-  _scope: "project" | "global",
-  cwd: string,
-  settings: LspSettings,
-  done: (selectedValue?: string) => void,
-): {
-  render: (width: number) => string[];
-  invalidate: () => void;
-  handleInput: (data: string) => boolean;
-} {
-  const config = loadConfig(cwd);
-  const allServers = Object.keys(config.servers);
-  const allEnabled = settings.active.length === 0;
-  const enabledServers = new Set(settings.active);
-
-  const items: SettingItem[] = allServers.map((name) => ({
-    id: name,
-    label: name,
-    currentValue: allEnabled || enabledServers.has(name) ? "enabled" : "disabled",
-    values: ["enabled", "disabled"],
-  }));
-
-  let dirty = false;
-
-  const container = new Container();
-  const header = new Text("Active Servers — all enabled by default", 0, 0);
-  container.addChild(header);
-
-  const settingsList = new SettingsList(
-    items,
-    Math.min(items.length + 2, 15),
-    getSettingsListTheme(),
-    (id, newValue) => {
-      const idx = items.findIndex((i) => i.id === id);
-      if (idx >= 0 && items[idx].currentValue !== newValue) {
-        dirty = true;
-        items[idx].currentValue = newValue;
-      }
-    },
-    () => {
-      // Escape on inner SettingsList — no-op, handled by submenu wrapper
-    },
-    { enableSearch: true },
-  );
-
-  container.addChild(settingsList);
-
-  return {
-    render: (width: number) => container.render(width),
-    invalidate: () => container.invalidate(),
-    handleInput: (data: string) => {
-      if (matchesKey(data, Key.escape)) {
-        if (!dirty) {
-          done();
-          return true;
-        }
-        const enabled = items.filter((i) => i.currentValue === "enabled").map((i) => i.id);
-        done(enabled.join(", ") || undefined);
-        return true;
-      }
-      settingsList.handleInput?.(data);
-      return true;
-    },
-  };
-}
-
-// ── Exclude patterns submenu ─────────────────────────────────
-
-function createExcludeSubmenu(
-  _scope: "project" | "global",
-  _cwd: string,
-  settings: LspSettings,
-  done: (selectedValue?: string) => void,
-): {
-  render: (width: number) => string[];
-  invalidate: () => void;
-  handleInput: (data: string) => boolean;
-} {
-  const items: SettingItem[] = settings.exclude.map((pattern) => ({
-    id: pattern,
-    label: pattern,
-    currentValue: "enabled",
-    values: ["enabled", "disabled"],
-  }));
-
-  let dirty = false;
-
-  const container = new Container();
-  const header = new Text("Exclude Patterns — toggle off to remove", 0, 0);
-  container.addChild(header);
-
-  const footer = new Text(
-    `Add new patterns in ${CONFIG_DIR_NAME}/supi/config.json under lsp.exclude`,
-    0,
-    0,
-  );
-  container.addChild(footer);
-
-  const settingsList = new SettingsList(
-    items,
-    Math.min(items.length + 3, 15),
-    getSettingsListTheme(),
-    (id, newValue) => {
-      const idx = items.findIndex((i) => i.id === id);
-      if (idx >= 0 && items[idx].currentValue !== newValue) {
-        dirty = true;
-        items[idx].currentValue = newValue;
-      }
-    },
-    () => {
-      // Escape on inner SettingsList — no-op, handled by submenu wrapper
-    },
-  );
-
-  container.addChild(settingsList);
-
-  return {
-    render: (width: number) => container.render(width),
-    invalidate: () => container.invalidate(),
-    handleInput: (data: string) => {
-      if (matchesKey(data, Key.escape)) {
-        if (!dirty) {
-          done();
-          return true;
-        }
-        const enabled = items.filter((i) => i.currentValue === "enabled").map((i) => i.id);
-        done(enabled.join(", ") || undefined);
-        return true;
-      }
-      settingsList.handleInput?.(data);
-      return true;
-    },
-  };
-}

package/src/session/tree-persist.ts

@@ -1,75 +0,0 @@
-// LSP tree navigation persistence — restores tool activation state across /tree navigation.
-
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { LspManager } from "../manager/manager.ts";
-import { LSP_TOOL_NAMES } from "../tool/names.ts";
-import { SessionLspService, setSessionLspServiceState } from "./service-registry.ts";
-
-/** 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; manager?: LspManager | null },
-): void {
-  pi.on("session_tree", async (_event, ctx) => {
-    const branch = ctx.sessionManager.getBranch();
-    const isActive = findLastLspState(branch)?.active === true;
-
-    syncBranchToolActivation(pi, isActive);
-    syncBranchServiceState(state.manager, isActive);
-    state.lspActive = isActive;
-  });
-}
-
-function findLastLspState(branch: Array<{ type: string; customType?: string; data?: unknown }>) {
-  let lastEntry: LspStateEntry | undefined;
-  for (const entry of branch) {
-    if (entry.type === "custom" && entry.customType === "lsp-active") {
-      lastEntry = entry.data as LspStateEntry | undefined;
-    }
-  }
-  return lastEntry;
-}
-
-function syncBranchToolActivation(pi: ExtensionAPI, isActive: boolean): void {
-  const activeTools = pi.getActiveTools();
-  if (isActive) {
-    const missing = LSP_TOOL_NAMES.filter((toolName) => !activeTools.includes(toolName));
-    if (missing.length > 0) {
-      pi.setActiveTools([...activeTools, ...missing]);
-    }
-    return;
-  }
-
-  const nextTools = activeTools.filter(
-    (toolName) => !LSP_TOOL_NAMES.includes(toolName as (typeof LSP_TOOL_NAMES)[number]),
-  );
-  if (nextTools.length !== activeTools.length) {
-    pi.setActiveTools(nextTools);
-  }
-}
-
-function syncBranchServiceState(manager: LspManager | null | undefined, isActive: boolean): void {
-  if (!manager) return;
-
-  setSessionLspServiceState(manager.getCwd(), {
-    kind: isActive ? "ready" : "inactive",
-    service: new SessionLspService(manager),
-  });
-}
-
-/** 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/tool/guidance.ts

@@ -1,69 +0,0 @@
-// Prompt guidance and tool descriptions for the expert LSP toolset.
-
-import * as path from "node:path";
-import type { ProjectServerInfo } from "../config/server-config.ts";
-import { LSP_HOVER_TOOL, type LspToolName } from "./names.ts";
-import { LSP_TOOL_DEFINITION_SPECS } from "./tool-specs.ts";
-
-export interface LspToolPromptSurface {
-  description: string;
-  promptSnippet: string;
-  promptGuidelines: string[];
-}
-
-export type LspToolPromptSurfaceMap = Record<LspToolName, LspToolPromptSurface>;
-
-export const defaultLspToolPromptSurfaces = buildLspToolPromptSurfaces([], ".");
-
-export function buildLspToolPromptSurfaces(
-  servers: ProjectServerInfo[],
-  cwd: string,
-): LspToolPromptSurfaceMap {
-  const coverageGuidelines = buildCoverageGuidelines(servers, cwd);
-
-  return Object.fromEntries(
-    LSP_TOOL_DEFINITION_SPECS.map((spec) => [
-      spec.name,
-      {
-        description: spec.description,
-        promptSnippet: spec.promptSnippet,
-        promptGuidelines:
-          spec.name === LSP_HOVER_TOOL && coverageGuidelines.length > 0
-            ? [...spec.basePromptGuidelines, ...coverageGuidelines]
-            : [...spec.basePromptGuidelines],
-      } satisfies LspToolPromptSurface,
-    ]),
-  ) as LspToolPromptSurfaceMap;
-}
-
-function buildCoverageGuidelines(servers: ProjectServerInfo[], cwd: string): string[] {
-  const active = servers
-    .filter((server) => server.status === "running")
-    .map((server) => {
-      const root = displayRoot(server.root, cwd);
-      const fileTypes = server.fileTypes.map((entry) => `.${entry}`).join(",");
-      const actions = server.supportedActions.join(",");
-      const actionText = actions.length > 0 ? ` | actions:${actions}` : "";
-      return `lsp server coverage: ${server.name} | root:${root} | files:${fileTypes}${actionText}`;
-    });
-
-  const unavailable = servers
-    .filter((server) => server.status !== "running")
-    .map((server) => server.name);
-
-  const dynamic = [...active];
-  if (unavailable.length > 0) {
-    dynamic.push(
-      `lsp server unavailable: ${unavailable.join(",")} — install or enable for more coverage`,
-    );
-  }
-
-  return dynamic;
-}
-
-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, "/");
-}

package/src/tool/names.ts

@@ -1,27 +0,0 @@
-// Stable LSP tool names shared across registration, guidance, and runtime state.
-
-export const LSP_HOVER_TOOL = "lsp_hover";
-export const LSP_DEFINITION_TOOL = "lsp_definition";
-export const LSP_REFERENCES_TOOL = "lsp_references";
-export const LSP_IMPLEMENTATION_TOOL = "lsp_implementation";
-export const LSP_DOCUMENT_SYMBOLS_TOOL = "lsp_document_symbols";
-export const LSP_WORKSPACE_SYMBOLS_TOOL = "lsp_workspace_symbols";
-export const LSP_DIAGNOSTICS_TOOL = "lsp_diagnostics";
-export const LSP_RENAME_TOOL = "lsp_rename";
-export const LSP_CODE_ACTIONS_TOOL = "lsp_code_actions";
-export const LSP_RECOVER_TOOL = "lsp_recover";
-
-export const LSP_TOOL_NAMES = [
-  LSP_HOVER_TOOL,
-  LSP_DEFINITION_TOOL,
-  LSP_REFERENCES_TOOL,
-  LSP_IMPLEMENTATION_TOOL,
-  LSP_DOCUMENT_SYMBOLS_TOOL,
-  LSP_WORKSPACE_SYMBOLS_TOOL,
-  LSP_DIAGNOSTICS_TOOL,
-  LSP_RENAME_TOOL,
-  LSP_CODE_ACTIONS_TOOL,
-  LSP_RECOVER_TOOL,
-] as const;
-
-export type LspToolName = (typeof LSP_TOOL_NAMES)[number];

package/src/tool/overrides.ts

@@ -1,204 +0,0 @@
-import type {
-  AgentToolUpdateCallback,
-  EditToolInput,
-  ExtensionAPI,
-  ExtensionContext,
-  ReadToolInput,
-  WriteToolInput,
-} from "@earendil-works/pi-coding-agent";
-import { createEditTool, createReadTool, createWriteTool } from "@earendil-works/pi-coding-agent";
-import type { Diagnostic } from "../config/types.ts";
-import { augmentDiagnostics } from "../diagnostics/diagnostic-augmentation.ts";
-import { formatGroupedDiagnostics } from "../diagnostics/diagnostics.ts";
-import { splitSuppressionDiagnostics } from "../diagnostics/suppression-diagnostics.ts";
-import type { LspManager } from "../manager/manager.ts";
-import { resolveSessionPath } from "../utils.ts";
-
-interface LspOverrideState {
-  getInlineSeverity(): number;
-  getManager(): LspManager | null;
-  isActive(): boolean;
-}
-
-export function registerLspAwareToolOverrides(pi: ExtensionAPI, state: LspOverrideState): void {
-  const readMeta = createReadTool(process.cwd());
-  const writeMeta = createWriteTool(process.cwd());
-  const editMeta = createEditTool(process.cwd());
-
-  pi.registerTool({
-    ...readMeta,
-    // biome-ignore lint/complexity/useMaxParams: pi ToolDefinition.execute signature
-    async execute(
-      toolCallId: string,
-      params: ReadToolInput,
-      signal: AbortSignal | undefined,
-      onUpdate: AgentToolUpdateCallback | undefined,
-      ctx: ExtensionContext,
-    ) {
-      const originalRead = createReadTool(ctx.cwd);
-      const result = await originalRead.execute(toolCallId, params, signal, onUpdate);
-      if (!state.isActive()) return result;
-      await ensureFileOpen(state.getManager(), ctx.cwd, params.path);
-      return result;
-    },
-  });
-
-  pi.registerTool({
-    ...writeMeta,
-    // biome-ignore lint/complexity/useMaxParams: pi ToolDefinition.execute signature
-    async execute(
-      toolCallId: string,
-      params: WriteToolInput,
-      signal: AbortSignal | undefined,
-      onUpdate: AgentToolUpdateCallback | undefined,
-      ctx: ExtensionContext,
-    ) {
-      const originalWrite = createWriteTool(ctx.cwd);
-      const result = await originalWrite.execute(toolCallId, params, signal, onUpdate);
-      if (!state.isActive()) return result;
-      return appendInlineDiagnostics({
-        manager: state.getManager(),
-        filePath: params.path,
-        inlineSeverity: state.getInlineSeverity(),
-        cwd: ctx.cwd,
-        result,
-      });
-    },
-  });
-
-  pi.registerTool({
-    ...editMeta,
-    // biome-ignore lint/complexity/useMaxParams: pi ToolDefinition.execute signature
-    async execute(
-      toolCallId: string,
-      params: EditToolInput,
-      signal: AbortSignal | undefined,
-      onUpdate: AgentToolUpdateCallback | undefined,
-      ctx: ExtensionContext,
-    ) {
-      const originalEdit = createEditTool(ctx.cwd);
-      const result = await originalEdit.execute(toolCallId, params, signal, onUpdate);
-      if (!state.isActive()) return result;
-      return appendInlineDiagnostics({
-        manager: state.getManager(),
-        filePath: params.path,
-        inlineSeverity: state.getInlineSeverity(),
-        cwd: ctx.cwd,
-        result,
-      });
-    },
-  });
-}
-
-interface AppendInlineDiagnosticsOptions<T extends { content: unknown[]; details: unknown }> {
-  manager: LspManager | null;
-  filePath: string;
-  inlineSeverity: number;
-  cwd: string;
-  result: T;
-}
-
-async function appendInlineDiagnostics<T extends { content: unknown[]; details: unknown }>(
-  options: AppendInlineDiagnosticsOptions<T>,
-): Promise<T> {
-  if (!options.manager) return options.result;
-
-  try {
-    const resolvedFilePath = resolveSessionPath(options.cwd, options.filePath);
-    const effectiveSeverity = Math.max(options.inlineSeverity, 2);
-    const entries = await options.manager.syncFileAndGetCascadingDiagnostics(
-      resolvedFilePath,
-      effectiveSeverity,
-    );
-    if (entries.length === 0) return options.result;
-
-    const primaryDiagnostics =
-      entries.find((entry) => entry.file === resolvedFilePath)?.diagnostics ?? [];
-    const augmentation = await augmentDiagnostics(
-      resolvedFilePath,
-      splitSuppressionDiagnostics(primaryDiagnostics, options.inlineSeverity).regular,
-      options.manager,
-      options.cwd,
-    );
-    const diagText = buildInlineDiagnosticsMessage(
-      entries,
-      options.cwd,
-      options.inlineSeverity,
-      augmentation ?? undefined,
-    );
-    if (!diagText) return options.result;
-
-    const diagnosticContent = {
-      type: "text" as const,
-      text: `\n\n${diagText}`,
-    } as T["content"][number];
-
-    return {
-      ...options.result,
-      content: [...options.result.content, diagnosticContent],
-    } as T;
-  } catch {
-    return options.result;
-  }
-}
-
-export function buildInlineDiagnosticsMessage(
-  entries: Array<{ file: string; diagnostics: Diagnostic[] }>,
-  cwd: string,
-  inlineSeverity: number = 1,
-  augmentation?: string,
-): string | null {
-  const regularEntries: Array<{ file: string; diagnostics: Diagnostic[] }> = [];
-  const suppressionEntries: Array<{ file: string; diagnostics: Diagnostic[] }> = [];
-
-  for (const entry of entries) {
-    const { regular, suppressions } = splitSuppressionDiagnostics(
-      entry.diagnostics,
-      inlineSeverity,
-    );
-    if (regular.length > 0) {
-      regularEntries.push({ file: entry.file, diagnostics: regular });
-    }
-    if (suppressions.length > 0) {
-      suppressionEntries.push({ file: entry.file, diagnostics: suppressions });
-    }
-  }
-
-  if (regularEntries.length === 0 && suppressionEntries.length === 0) {
-    return null;
-  }
-
-  const sections = ["⚠️ LSP Diagnostics — review before continuing:"];
-
-  if (regularEntries.length > 0) {
-    sections.push(formatGroupedDiagnostics(regularEntries, cwd));
-    if (augmentation) {
-      sections.push(augmentation);
-    }
-  }
-
-  if (suppressionEntries.length > 0) {
-    sections.push(
-      `🗑️ Stale suppressions — cleanup available:\n${formatGroupedDiagnostics(suppressionEntries, cwd)}`,
-    );
-  }
-
-  sections.push(
-    "If these errors are unexpected or appear across multiple files, fix the root cause before editing more files.",
-  );
-  return sections.join("\n\n");
-}
-
-async function ensureFileOpen(
-  manager: LspManager | null,
-  cwd: string,
-  filePath: string,
-): Promise<void> {
-  if (!manager) return;
-
-  try {
-    await manager.ensureFileOpen(resolveSessionPath(cwd, filePath));
-  } catch {
-    // Never block the agent on LSP errors
-  }
-}