@mrclrchtr/supi-lsp 1.16.0 → 2.0.0

package/src/handlers/session-lifecycle.ts

@@ -1,149 +0,0 @@
-// Session lifecycle handlers — session_start, session_shutdown, and agent_end.
-//
-// Extracted from lsp.ts to keep each orchestration concern in its own module.
-
-import type {
-  AgentEndEvent,
-  ExtensionAPI,
-  ExtensionContext,
-  SessionStartEvent,
-} from "@earendil-works/pi-coding-agent";
-import type { WorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
-import { loadConfig, resolveLanguageAlias } from "../config/config.ts";
-import { clearTsconfigCache } from "../config/tsconfig-scope.ts";
-import { scanWorkspaceSentinels } from "../diagnostics/workspace-sentinels.ts";
-import { LspManager } from "../manager/manager.ts";
-import {
-  disableLspState,
-  ensureLspToolsActive,
-  type LspRuntimeState,
-  refreshProjectServers,
-} from "../session/lsp-state.ts";
-import {
-  registerLspCapabilities,
-  unregisterLspCapabilities,
-} from "../session/runtime-registration.ts";
-import {
-  scanMissingServers,
-  scanProjectCapabilities,
-  startDetectedServers,
-} from "../session/scanner.ts";
-import {
-  clearSessionLspService,
-  SessionLspService,
-  setSessionLspServiceState,
-} from "../session/service-registry.ts";
-import { loadLspSettings } from "../session/settings-registration.ts";
-import { persistLspActiveState, persistLspInactiveState } from "../session/tree-persist.ts";
-import { buildLspToolPromptSurfaces } from "../tool/guidance.ts";
-import { registerLspTools } from "../tool/register-tools.ts";
-import { updateLspUi } from "../ui/ui.ts";
-
-/**
- * Register session lifecycle handlers (start, shutdown, and agent-end cleanup).
- *
- * - `session_start`: initialises the LspManager, starts detected servers, wires
- *   dynamic tool guidance, publishes runtime capabilities, and syncs UI state.
- * - `session_shutdown`: tears down the manager and clears runtime state.
- * - `agent_end`: refreshes project-server info and updates the LSP status UI.
- */
-export function registerSessionLifecycleHandlers(
-  pi: ExtensionAPI,
-  state: LspRuntimeState,
-  runtime: WorkspaceRuntime,
-): void {
-  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: session_start orchestrates setup, server detection, settings, and persistence.
-  pi.on("session_start", async (_event: SessionStartEvent, ctx: ExtensionContext) => {
-    if (state.manager) {
-      clearSessionLspService(state.manager.getCwd());
-      await state.manager.shutdownAll();
-    }
-
-    const cwd = ctx.cwd;
-    clearTsconfigCache();
-    const lspSettings = loadLspSettings(cwd);
-
-    if (!lspSettings.enabled) {
-      clearSessionLspService(cwd);
-      disableLspState(pi, state);
-      persistLspInactiveState(pi, state);
-      setSessionLspServiceState(cwd, { kind: "disabled" });
-      return;
-    }
-
-    state.inlineSeverity = lspSettings.severity;
-
-    const config = loadConfig(cwd);
-
-    // Apply server allowlist filter from supi shared config
-    if (lspSettings.active.length > 0) {
-      const allowList = new Set(lspSettings.active.map(resolveLanguageAlias));
-      for (const name of Object.keys(config.servers)) {
-        if (!allowList.has(name)) {
-          delete config.servers[name];
-        }
-      }
-    }
-
-    clearSessionLspService(cwd);
-    state.manager = new LspManager(config, cwd);
-    state.manager.setExcludePatterns(lspSettings.exclude ?? []);
-    setSessionLspServiceState(cwd, { kind: "pending" });
-    state.detectedServers = scanProjectCapabilities(config, cwd);
-    state.manager.registerDetectedServers(state.detectedServers);
-    await startDetectedServers(state.manager, state.detectedServers);
-
-    const missing = scanMissingServers(config, cwd);
-    if (missing.length > 0) {
-      const parts = missing.map((m) => `${m.name} (${m.command})`);
-      ctx.ui.notify(
-        `LSP server not found for: ${parts.join(", ")}. Install the server to enable language intelligence.`,
-        "warning",
-      );
-    }
-
-    state.sentinelSnapshot = scanWorkspaceSentinels(cwd);
-    state.lastWorkspaceChangeAt = 0;
-    state.staleSuspected = false;
-    refreshProjectServers(state);
-    state.lastDiagnosticsFingerprint = null;
-    state.currentContextToken = null;
-    state.lspActive = true;
-    const service = new SessionLspService(state.manager);
-    setSessionLspServiceState(cwd, { kind: "ready", service });
-    registerLspCapabilities(runtime, cwd, service);
-    registerLspTools(pi, buildLspToolPromptSurfaces(state.projectServers, cwd));
-    ensureLspToolsActive(pi);
-    persistLspActiveState(pi, state);
-    updateLspUi(ctx, state.manager, state.inlineSeverity, state.projectServers);
-  });
-
-  pi.on("session_shutdown", async () => {
-    clearTsconfigCache();
-    if (state.manager) {
-      const cwd = state.manager.getCwd();
-      unregisterLspCapabilities(runtime, cwd);
-      clearSessionLspService(cwd);
-      await state.manager.shutdownAll();
-      state.manager = null;
-    }
-
-    state.inspector.close?.();
-    state.detectedServers = [];
-    state.projectServers = [];
-    state.lastDiagnosticsFingerprint = null;
-    state.currentContextToken = null;
-    state.staleSuspected = false;
-    state.lastWorkspaceChangeAt = 0;
-    state.sentinelSnapshot = new Map();
-  });
-
-  pi.on("agent_end", async (_event: AgentEndEvent, ctx: ExtensionContext) => {
-    state.currentContextToken = null;
-    refreshProjectServers(state);
-
-    if (state.manager) {
-      updateLspUi(ctx, state.manager, state.inlineSeverity, state.projectServers);
-    }
-  });
-}

package/src/handlers/status-command.ts

@@ -1,38 +0,0 @@
-// LSP status command — /lsp-status overlay.
-//
-// Extracted from lsp.ts to keep each orchestration concern in its own module.
-
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { type LspRuntimeState, refreshProjectServers } from "../session/lsp-state.ts";
-import { getLspDisabledMessage, loadLspSettings } from "../session/settings-registration.ts";
-import { toggleLspStatusOverlay } from "../ui/ui.ts";
-
-/**
- * Register the /lsp-status command that opens an LSP inspector overlay.
- */
-export function registerLspStatusCommand(pi: ExtensionAPI, state: LspRuntimeState): void {
-  pi.registerCommand("lsp-status", {
-    description: "Show detected LSP servers, roots, open files, and diagnostics",
-    handler: async (_args: string, ctx: ExtensionContext) => {
-      const lspSettings = loadLspSettings(ctx.cwd);
-      if (!lspSettings.enabled) {
-        ctx.ui.notify(getLspDisabledMessage(ctx.cwd), "warning");
-        return;
-      }
-
-      if (!state.manager) {
-        ctx.ui.notify("LSP not initialized", "warning");
-        return;
-      }
-
-      refreshProjectServers(state);
-      toggleLspStatusOverlay(
-        ctx,
-        state.manager,
-        state.inlineSeverity,
-        state.inspector,
-        state.projectServers,
-      );
-    },
-  });
-}

package/src/handlers/workspace-recovery.ts

@@ -1,92 +0,0 @@
-// Workspace recovery handler — tool_result event.
-//
-// Extracted from lsp.ts to keep each orchestration concern in its own module.
-
-import type {
-  ExtensionAPI,
-  ExtensionContext,
-  ToolResultEvent,
-} from "@earendil-works/pi-coding-agent";
-import { clearTsconfigCache } from "../config/tsconfig-scope.ts";
-import { FileChangeType, type FileEvent } from "../config/types.ts";
-import {
-  isWorkspaceRecoveryTrigger,
-  syncWorkspaceSentinelSnapshot,
-} from "../diagnostics/workspace-sentinels.ts";
-import {
-  isLspAwareTool,
-  type LspRuntimeState,
-  refreshProjectServers,
-} from "../session/lsp-state.ts";
-import { updateLspUi } from "../ui/ui.ts";
-import { fileToUri, resolveSessionPath } from "../utils.ts";
-import {
-  shouldInvalidateTsconfigScopeCache,
-  softRecoverWorkspaceChanges,
-} from "../workspace-change.ts";
-
-/**
- * Register the tool_result handler that detects workspace changes from
- * write / edit tool results and recovers LSP state accordingly.
- */
-export function registerWorkspaceRecoveryHandler(pi: ExtensionAPI, state: LspRuntimeState): void {
-  pi.on("tool_result", async (event: ToolResultEvent, ctx: ExtensionContext) => {
-    if (!state.manager) return;
-
-    const recoveryTriggered = recoverWorkspaceChangesFromToolResult(state, ctx.cwd, {
-      toolName: event.toolName,
-      isError: event.isError,
-      input: (event as { input?: unknown }).input,
-    });
-
-    if (recoveryTriggered || isLspAwareTool(event.toolName)) {
-      refreshProjectServers(state);
-      updateLspUi(ctx, state.manager, state.inlineSeverity, state.projectServers);
-    }
-  });
-}
-
-/**
- * Determine whether a tool result (write/edit) should trigger workspace recovery.
- *
- * Returns true and recovers when the file is:
- *  - a sentinel file (package.json, tsconfig, lockfile, .d.ts)
- *  - a source file whose extension matches an active language server's file types
- *  - a .json / .jsonc file (tsconfig cache invalidation)
- */
-function recoverWorkspaceChangesFromToolResult(
-  state: LspRuntimeState,
-  cwd: string,
-  event: { toolName: string; isError: boolean; input?: unknown },
-): boolean {
-  if (!state.manager || event.isError) return false;
-  if (event.toolName !== "write" && event.toolName !== "edit") return false;
-  if (!event.input || typeof event.input !== "object") return false;
-
-  const pathValue = (event.input as { path?: unknown }).path;
-  if (typeof pathValue !== "string") return false;
-
-  const resolvedPath = resolveSessionPath(cwd, pathValue);
-  if (shouldInvalidateTsconfigScopeCache(resolvedPath)) {
-    clearTsconfigCache();
-  }
-  const fileEvent: FileEvent = { uri: fileToUri(resolvedPath), type: FileChangeType.Changed };
-
-  // Sentinel files (package.json, tsconfig.json, lockfiles, .d.ts)
-  if (isWorkspaceRecoveryTrigger(resolvedPath, cwd)) {
-    if (resolvedPath.endsWith(".d.ts")) {
-      return softRecoverWorkspaceChanges(state, [fileEvent]);
-    }
-
-    const { snapshot, changes } = syncWorkspaceSentinelSnapshot(cwd, state.sentinelSnapshot);
-    state.sentinelSnapshot = snapshot;
-    return softRecoverWorkspaceChanges(state, changes.length > 0 ? changes : [fileEvent]);
-  }
-
-  // Source files matching an active language server's file types
-  if (state.manager.hasServerForExtension(resolvedPath)) {
-    return softRecoverWorkspaceChanges(state, [fileEvent]);
-  }
-
-  return false;
-}

package/src/lsp.ts

@@ -1,37 +0,0 @@
-// LSP Extension for pi — wires together the expert semantic toolset and all
-// event/behaviour handlers. Handler registration is delegated to focused
-// modules so each orchestration concern lives in its own file.
-
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { getDefaultWorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
-import { registerDiagnosticInjectionHandlers } from "./handlers/diagnostic-injection.ts";
-import { registerSessionLifecycleHandlers } from "./handlers/session-lifecycle.ts";
-import { registerLspStatusCommand } from "./handlers/status-command.ts";
-import { registerWorkspaceRecoveryHandler } from "./handlers/workspace-recovery.ts";
-import { createRuntimeState } from "./session/lsp-state.ts";
-import { registerLspSettings } from "./session/settings-registration.ts";
-import { registerTreePersistHandlers } from "./session/tree-persist.ts";
-import { defaultLspToolPromptSurfaces } from "./tool/guidance.ts";
-import { registerLspAwareToolOverrides } from "./tool/overrides.ts";
-import { registerLspTools } from "./tool/register-tools.ts";
-import { registerLspMessageRenderer } from "./ui/renderer.ts";
-
-export default function lspExtension(pi: ExtensionAPI) {
-  registerLspSettings();
-  const state = createRuntimeState();
-  const runtime = getDefaultWorkspaceRuntime();
-
-  registerLspAwareToolOverrides(pi, {
-    getInlineSeverity: () => state.inlineSeverity,
-    getManager: () => state.manager,
-    isActive: () => state.lspActive,
-  });
-
-  registerLspTools(pi, defaultLspToolPromptSurfaces);
-  registerSessionLifecycleHandlers(pi, state, runtime);
-  registerDiagnosticInjectionHandlers(pi, state);
-  registerWorkspaceRecoveryHandler(pi, state);
-  registerTreePersistHandlers(pi, state);
-  registerLspStatusCommand(pi, state);
-  registerLspMessageRenderer(pi);
-}

package/src/session/lsp-state.ts

@@ -1,93 +0,0 @@
-// LSP extension runtime state and tool management helpers.
-// Extracted from lsp.ts to keep file sizes within Biome limits.
-
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { DetectedProjectServer, ProjectServerInfo } from "../config/server-config.ts";
-import type { LspManager } from "../manager/manager.ts";
-import { LSP_TOOL_NAMES } from "../tool/names.ts";
-import type { LspInspectorState } from "../ui/ui.ts";
-import { introspectCapabilities } from "./scanner.ts";
-import { clearSessionLspService } from "./service-registry.ts";
-
-export interface LspRuntimeState {
-  manager: LspManager | null;
-  inlineSeverity: number;
-  inspector: LspInspectorState;
-  detectedServers: DetectedProjectServer[];
-  projectServers: ProjectServerInfo[];
-  lastDiagnosticsFingerprint: string | null;
-  currentContextToken: string | null;
-  contextCounter: number;
-  lspActive: boolean;
-  sentinelSnapshot: Map<string, number>;
-  staleSuspected: boolean;
-  lastWorkspaceChangeAt: number;
-}
-
-export function createRuntimeState(): LspRuntimeState {
-  return {
-    manager: null,
-    inlineSeverity: 1,
-    inspector: { handle: null, close: null },
-    detectedServers: [],
-    projectServers: [],
-    lastDiagnosticsFingerprint: null,
-    currentContextToken: null,
-    contextCounter: 0,
-    lspActive: false,
-    sentinelSnapshot: new Map(),
-    staleSuspected: false,
-    lastWorkspaceChangeAt: 0,
-  };
-}
-
-export function refreshProjectServers(state: LspRuntimeState): void {
-  if (!state.manager) {
-    state.projectServers = [];
-    return;
-  }
-  state.projectServers = introspectCapabilities(state.manager, state.detectedServers);
-}
-
-export function isLspAwareTool(toolName: string): boolean {
-  return (
-    LSP_TOOL_NAMES.includes(toolName as (typeof LSP_TOOL_NAMES)[number]) ||
-    toolName === "read" ||
-    toolName === "write" ||
-    toolName === "edit"
-  );
-}
-
-export function disableLspState(pi: ExtensionAPI, state: LspRuntimeState): void {
-  if (state.manager) {
-    clearSessionLspService(state.manager.getCwd());
-  }
-  state.inspector.close?.();
-  state.manager = null;
-  state.detectedServers = [];
-  state.projectServers = [];
-  state.lastDiagnosticsFingerprint = null;
-  state.currentContextToken = null;
-  state.staleSuspected = false;
-  state.lastWorkspaceChangeAt = 0;
-  state.sentinelSnapshot = new Map();
-  state.lspActive = false;
-  removeLspTools(pi);
-}
-
-export function removeLspTools(pi: ExtensionAPI): void {
-  const activeTools = pi.getActiveTools();
-  const nextTools = activeTools.filter(
-    (toolName: string) => !LSP_TOOL_NAMES.includes(toolName as (typeof LSP_TOOL_NAMES)[number]),
-  );
-  if (nextTools.length !== activeTools.length) {
-    pi.setActiveTools(nextTools);
-  }
-}
-
-export function ensureLspToolsActive(pi: ExtensionAPI): void {
-  const activeTools = pi.getActiveTools();
-  const missing = LSP_TOOL_NAMES.filter((toolName) => !activeTools.includes(toolName));
-  if (missing.length === 0) return;
-  pi.setActiveTools([...activeTools, ...missing]);
-}