@mrclrchtr/supi-lsp 1.7.0 → 1.9.0

package/node_modules/vscode-languageserver-types/package.json

@@ -0,0 +1,38 @@
+{
+	"name": "vscode-languageserver-types",
+	"description": "Types used by the Language server for node",
+	"version": "3.17.5",
+	"author": "Microsoft Corporation",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/Microsoft/vscode-languageserver-node.git",
+		"directory": "types"
+	},
+	"bugs": {
+		"url": "https://github.com/Microsoft/vscode-languageserver-node/issues"
+	},
+	"main": "./lib/umd/main.js",
+	"typings": "./lib/umd/main",
+	"exports": {
+		".": {
+			"browser": "./lib/esm/main.js",
+			"import": "./lib/esm/main.js",
+			"default": "./lib/umd/main.js"
+		}
+	},
+	"scripts": {
+		"prepublishOnly": "echo \"⛔ Can only publish from a secure pipeline ⛔\" && node ../build/npm/fail",
+		"prepack": "npm run all:publish",
+		"compile": "node ../build/bin/tsc -b ./tsconfig.json",
+		"clean": "node ../node_modules/.bin/rimraf lib",
+		"watch": "node ../build/bin/tsc -b ./tsconfig.watch.json -w",
+		"lint": "node ../node_modules/eslint/bin/eslint.js --ext ts src",
+		"test": "node ../node_modules/mocha/bin/_mocha",
+		"all": "npm run clean && npm run compile && npm run lint && npm run test",
+		"compile:esm": "node ../build/bin/tsc -b ./tsconfig.esm.publish.json && node ../build/bin/fix-esm",
+		"compile:umd": "node ../build/bin/tsc -b ./tsconfig.umd.publish.json",
+		"all:publish": "git clean -xfd . && npm install && npm run compile:esm && npm run compile:umd && npm run lint && npm run test",
+		"preversion": "npm test"
+	}
+}

package/node_modules/vscode-languageserver-types/thirdpartynotices.txt

@@ -0,0 +1,16 @@
+NOTICES AND INFORMATION
+Do Not Translate or Localize
+
+This software incorporates material from third parties.
+Microsoft makes certain open source code available at https://3rdpartysource.microsoft.com,
+or you may send a check or money order for US $5.00, including the product name,
+the open source component name, platform, and version number, to:
+
+Source Code Compliance Team
+Microsoft Corporation
+One Microsoft Way
+Redmond, WA 98052
+USA
+
+Notwithstanding any other terms, you may reverse engineer this software to the extent
+required to debug changes to any libraries licensed under the GNU Lesser General Public License.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-lsp",
-  "version": "1.7.0",
+  "version": "1.9.0",
   "description": "SuPi LSP extension — Language Server Protocol integration for pi",
   "license": "MIT",
   "repository": {
@@ -26,9 +26,11 @@
     "vscode-jsonrpc": "^8.2.1",
     "vscode-languageserver-protocol": "^3.17.5",
     "vscode-languageserver-types": "^3.17.5",
-    "@mrclrchtr/supi-core": "1.7.0"
+    "@mrclrchtr/supi-code-runtime": "1.9.0",
+    "@mrclrchtr/supi-core": "1.9.0"
   },
   "bundledDependencies": [
+    "@mrclrchtr/supi-code-runtime",
     "@mrclrchtr/supi-core",
     "vscode-jsonrpc",
     "vscode-languageserver-protocol",
@@ -56,14 +58,15 @@
   },
   "pi": {
     "extensions": [
-      "./src/extension.ts",
-      "node_modules/@mrclrchtr/supi-core/src/extension.ts"
-    ]
+      "./src/extension.ts"
+    ],
+    "image": "https://raw.githubusercontent.com/mrclrchtr/supi/main/packages/supi-lsp/assets/logo.png"
   },
   "main": "src/api.ts",
   "exports": {
     "./api": "./src/api.ts",
     "./extension": "./src/extension.ts",
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./provider/lsp-semantic-provider": "./src/provider/lsp-semantic-provider.ts"
   }
 }

package/src/config/config.ts

@@ -2,7 +2,7 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { loadSupiConfigForScope } from "@mrclrchtr/supi-core/api";
+import { loadSupiConfigForScope } from "@mrclrchtr/supi-core/config";
 import type { LspConfig, ServerConfig } from "./types.ts";
 
 // Load defaults at module level — resolve relative to this file.

package/src/handlers/diagnostic-injection.ts

@@ -0,0 +1,182 @@
+// Diagnostic injection handlers — before_agent_start and context.
+//
+// Extracted from lsp.ts to keep each orchestration concern in its own module.
+
+import type {
+  BeforeAgentStartEvent,
+  BeforeAgentStartEventResult,
+  ContextEvent,
+  ExtensionAPI,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { pruneAndReorderContextMessages, restorePromptContent } from "@mrclrchtr/supi-core/context";
+import type { Diagnostic } from "../config/types.ts";
+import {
+  diagnosticsContextFingerprint,
+  formatDiagnosticsContext,
+  MAX_DETAILED_DIAGNOSTICS,
+} from "../diagnostics/diagnostic-context.ts";
+import { formatDiagnosticsDisplayContent } from "../diagnostics/diagnostic-display.ts";
+import { assessStaleDiagnostics } from "../diagnostics/stale-diagnostics.ts";
+// Force re-open files with module-resolution errors
+import { forceResyncStaleModuleFiles } from "../manager/manager-stale-resync.ts";
+import type { OutstandingDiagnosticSummaryEntry } from "../manager/manager-types.ts";
+import {
+  ensureLspToolsActive,
+  type LspRuntimeState,
+  refreshProjectServers,
+  removeLspTools,
+} from "../session/lsp-state.ts";
+import { persistLspInactiveState } from "../session/tree-persist.ts";
+import { updateLspUi } from "../ui/ui.ts";
+import { refreshWorkspaceSentinels } from "../workspace-change.ts";
+
+/**
+ * Register handlers for before_agent_start (diagnostic injection) and context
+ * (lsp-context message pruning / prompt-content restoration).
+ */
+export function registerDiagnosticInjectionHandlers(
+  pi: ExtensionAPI,
+  state: LspRuntimeState,
+): void {
+  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: before_agent_start coordinates sentinel recovery, pruning, refresh, and diagnostic injection.
+  pi.on("before_agent_start", async (_event: BeforeAgentStartEvent, ctx: ExtensionContext) => {
+    if (!state.manager || !state.lspActive) {
+      removeLspTools(pi);
+      if (!state.manager && state.lspActive) {
+        persistLspInactiveState(pi, state);
+      }
+      return;
+    }
+
+    ensureLspToolsActive(pi);
+
+    refreshWorkspaceSentinels(state, ctx.cwd);
+
+    /**
+     * Two-pass prune/refresh pattern:
+     *
+     * 1. Prune files deleted since the last turn and send didClose.
+     * 2. Re-sync remaining open docs and wait for diagnostics to settle.
+     * 3. Prune *again* — late publishDiagnostics notifications (already
+     *    in-flight when step 1 ran) may have re-created stale entries for
+     *    files that no longer exist. `getAllDiagnostics()` also filters
+     *    by existence, so this second pass is belt-and-suspenders.
+     */
+    state.manager.pruneMissingFiles();
+    try {
+      await state.manager.refreshOpenDiagnostics();
+    } catch {
+      // Refresh failures must not prevent agent startup
+    }
+    state.manager.pruneMissingFiles();
+
+    try {
+      await forceResyncStaleModuleFiles(state.manager, ctx.cwd);
+    } catch {
+      // Best-effort: don't fail the agent turn
+    }
+
+    refreshProjectServers(state);
+    updateLspUi(ctx, state.manager, state.inlineSeverity, state.projectServers);
+
+    const diagnostics = state.manager.getOutstandingDiagnosticSummary(state.inlineSeverity);
+    const totalDiags = diagnostics.reduce((sum, d) => sum + d.total, 0);
+    const detailed =
+      totalDiags <= MAX_DETAILED_DIAGNOSTICS
+        ? state.manager.getOutstandingDiagnostics(state.inlineSeverity)
+        : undefined;
+    const staleAssessment = state.staleSuspected
+      ? assessStaleDiagnostics(state.manager.getOutstandingDiagnostics(4))
+      : { suspected: false, matchedFiles: [], warning: null };
+    state.staleSuspected = staleAssessment.suspected;
+
+    const staleWarning = staleAssessment.suspected ? staleAssessment.warning : null;
+    const content = formatDiagnosticsContext(diagnostics, 3, detailed, staleWarning);
+    const fingerprint = diagnosticsContextFingerprint(content);
+
+    if (!content) {
+      state.lastDiagnosticsFingerprint = null;
+      state.currentContextToken = null;
+      return;
+    }
+
+    if (fingerprint === state.lastDiagnosticsFingerprint) {
+      state.currentContextToken = null;
+      return;
+    }
+
+    state.lastDiagnosticsFingerprint = fingerprint;
+    state.currentContextToken = `lsp-context-${++state.contextCounter}`;
+
+    return buildDiagnosticResult(
+      diagnostics,
+      detailed,
+      state.inlineSeverity,
+      state.currentContextToken,
+      staleWarning,
+    );
+  });
+
+  pi.on("context", (event: ContextEvent) => {
+    const messages = pruneAndReorderContextMessages(
+      event.messages as Array<{
+        role?: string;
+        customType?: string;
+        content?: unknown;
+        details?: unknown;
+      }>,
+      "lsp-context",
+      state.currentContextToken,
+    );
+    const contextMessages = restorePromptContent(
+      messages,
+      "lsp-context",
+      state.currentContextToken,
+    ) as typeof event.messages;
+
+    if (
+      contextMessages.length === event.messages.length &&
+      contextMessages.every((message, index) => message === event.messages[index])
+    ) {
+      return;
+    }
+    return { messages: contextMessages };
+  });
+}
+
+/** Build the `lsp-context` custom message used to surface outstanding diagnostics. */
+// biome-ignore lint/complexity/useMaxParams: wrapper groups the prompt payload fields in one place.
+function buildDiagnosticResult(
+  diagnostics: OutstandingDiagnosticSummaryEntry[],
+  detailed:
+    | {
+        file: string;
+        diagnostics: Diagnostic[];
+      }[]
+    | undefined,
+  severity: number,
+  token: string,
+  staleWarning?: string | null,
+): BeforeAgentStartEventResult {
+  return {
+    message: {
+      customType: "lsp-context",
+      content: formatDiagnosticsDisplayContent(diagnostics, detailed),
+      display: true,
+      details: {
+        contextToken: token,
+        promptContent: formatDiagnosticsContext(diagnostics, 3, detailed, staleWarning),
+        inlineSeverity: severity,
+        ...(staleWarning ? { staleWarning } : {}),
+        diagnostics: diagnostics.map((d) => ({
+          file: d.file,
+          errors: d.errors,
+          warnings: d.warnings,
+          information: d.information,
+          hints: d.hints,
+        })),
+      },
+    },
+  };
+}

package/src/handlers/session-lifecycle.ts

@@ -0,0 +1,149 @@
+// 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

@@ -0,0 +1,38 @@
+// 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

@@ -0,0 +1,92 @@
+// 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;
+}