@mrclrchtr/supi-code-intelligence 1.16.1 → 2.0.1

package/src/substrate/lsp/diagnostic-injection.ts

@@ -0,0 +1,218 @@
+// Diagnostic injection handlers — before_agent_start and context for lsp-context messages.
+//
+// Ported from supi-lsp's diagnostic-injection.ts.
+
+import * as nodePath from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+  clearTsconfigCache,
+  isLikelyStaleDiagnostic,
+  syncWorkspaceSentinelSnapshot,
+} from "@mrclrchtr/supi-lsp/api";
+import type { LspAdapterState } from "./state.ts";
+import { diagnosticMessageString } from "./utils.ts";
+
+// LSP_TOOL_NAMES removed — lsp_* tools are no longer registered (TNDM-A9AQF4)
+const LSP_TOOL_NAMES: readonly string[] = [];
+
+export function registerDiagnosticInjectionHandlers(
+  pi: ExtensionAPI,
+  state: LspAdapterState,
+): void {
+  pi.on("before_agent_start", async (_event, _ctx: ExtensionContext) => {
+    const manager = state.controller?.manager;
+    if (!manager || !state.lspActive) {
+      const activeTools = pi.getActiveTools();
+      const nextTools = activeTools.filter(
+        (t: string) => !LSP_TOOL_NAMES.includes(t as (typeof LSP_TOOL_NAMES)[number]),
+      );
+      if (nextTools.length !== activeTools.length) {
+        pi.setActiveTools(nextTools);
+      }
+      return;
+    }
+
+    const missing = LSP_TOOL_NAMES.filter((name) => !pi.getActiveTools().includes(name));
+    if (missing.length > 0) {
+      pi.setActiveTools([...pi.getActiveTools(), ...missing]);
+    }
+
+    // Sentinel refresh: detect lockfile/tsconfig/d.ts changes from outside write/edit
+    applySentinelChanges(state, manager);
+
+    // Stale-module resync: force-reopen files with "Cannot find module" errors
+    await resyncStaleModuleFiles(state);
+
+    // Two-pass prune/refresh for diagnostics
+    manager.pruneMissingFiles();
+    try {
+      await manager.refreshOpenDiagnostics();
+    } catch {
+      /* best-effort */
+    }
+    manager.pruneMissingFiles();
+
+    const diagnostics = manager.getOutstandingDiagnosticSummary(state.inlineSeverity);
+    if (!diagnostics || diagnostics.length === 0) {
+      state.lastDiagnosticsFingerprint = null;
+      state.currentContextToken = null;
+      return;
+    }
+
+    state.currentContextToken = `lsp-context-${++state.contextCounter}`;
+
+    const detailedDiagnostics = manager
+      .getOutstandingDiagnostics(state.inlineSeverity)
+      .map((entry) => ({
+        file: entry.file,
+        diagnostics: entry.diagnostics.map((d) => ({
+          range: d.range,
+          message: diagnosticMessageString(d),
+        })),
+      }));
+
+    return {
+      message: {
+        customType: "lsp-context",
+        content: buildInjectionContent(diagnostics, detailedDiagnostics),
+        display: true,
+        details: {
+          contextToken: state.currentContextToken,
+          promptContent: buildInjectionContent(diagnostics),
+          inlineSeverity: state.inlineSeverity,
+          diagnostics: diagnostics.map(
+            (d: {
+              file: string;
+              errors: number;
+              warnings: number;
+              information: number;
+              hints: number;
+            }) => ({
+              file: d.file,
+              errors: d.errors,
+              warnings: d.warnings,
+              information: d.information,
+              hints: d.hints,
+            }),
+          ),
+        },
+      },
+    };
+  });
+
+  pi.on("context", (event, _ctx) => {
+    const messages = event.messages as unknown as Array<Record<string, unknown>>;
+    const token = state.currentContextToken;
+
+    const pruned = messages.filter((m) => {
+      if (m.customType !== "lsp-context") return true;
+      if (!token) return false;
+      const details = m.details as { contextToken?: string } | undefined;
+      return details?.contextToken === token;
+    });
+
+    if (pruned.length === event.messages.length) return;
+    return { messages: pruned as unknown as typeof event.messages };
+  });
+}
+
+/** Diff sentinel snapshot and notify manager of changes. */
+// biome-ignore lint/suspicious/noExplicitAny: callback accepts FileEvent[] which satisfies the structural type
+function applySentinelChanges(state: LspAdapterState, manager: any): void {
+  const controller = state.controller;
+  if (!controller) return;
+
+  const { snapshot, changes } = syncWorkspaceSentinelSnapshot(
+    controller.cwd,
+    state.sentinelSnapshot,
+  );
+  state.sentinelSnapshot = snapshot;
+
+  if (changes.length === 0) return;
+
+  clearTsconfigCache();
+  manager.clearAllPullResultIds();
+  manager.notifyWorkspaceFileChanges(changes);
+
+  state.staleSuspected = true;
+  state.lastDiagnosticsFingerprint = null;
+  state.currentContextToken = null;
+  state.lastWorkspaceChangeAt = Date.now();
+}
+
+/** Re-open files with stale module-resolution errors. */
+async function resyncStaleModuleFiles(state: LspAdapterState): Promise<void> {
+  const manager = state.controller?.manager;
+  if (!manager) return;
+
+  const outstanding = manager.getOutstandingDiagnostics(1);
+  const staleFiles: string[] = [];
+
+  for (const entry of outstanding) {
+    // biome-ignore lint/suspicious/noExplicitAny: isLikelyStaleDiagnostic accepts Diagnostic, which the manager provides
+    if (entry.diagnostics.some((d) => isLikelyStaleDiagnostic(d as any))) {
+      staleFiles.push(entry.file);
+    }
+  }
+
+  if (staleFiles.length === 0) return;
+
+  const cwd = state.controller?.cwd ?? "";
+  for (const file of staleFiles) {
+    const filePath = nodePath.resolve(cwd, file);
+    manager.closeFile(filePath);
+    await manager.ensureFileOpen(filePath);
+  }
+
+  try {
+    await manager.refreshOpenDiagnostics({ quietMs: 300, maxWaitMs: 2000 });
+  } catch {
+    /* best-effort */
+  }
+}
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: diagnostic formatting logic
+function buildInjectionContent(
+  diagnostics: Array<{ file: string; errors: number; warnings: number }>,
+  detailed?: Array<{
+    file: string;
+    diagnostics: Array<{ message: string; range: { start: { line: number } } }>;
+  }>,
+): string {
+  if (!diagnostics || diagnostics.length === 0) return "";
+
+  const parts: string[] = [
+    '<extension-context source="supi-code-intelligence">',
+    "Outstanding LSP diagnostics:",
+  ];
+
+  for (const diag of diagnostics.slice(0, 15)) {
+    const pieces: string[] = [];
+    if (diag.errors > 0) pieces.push(`${diag.errors} error${diag.errors > 1 ? "s" : ""}`);
+    if (diag.warnings > 0) pieces.push(`${diag.warnings} warning${diag.warnings > 1 ? "s" : ""}`);
+    parts.push(`- ${diag.file}: ${pieces.join(", ")}`);
+  }
+
+  if (diagnostics.length > 15) {
+    parts.push(`... and ${diagnostics.length - 15} more files`);
+  }
+
+  if (detailed) {
+    for (const entry of detailed.slice(0, 5)) {
+      for (const d of entry.diagnostics.slice(0, 5)) {
+        parts.push(`  ${d.range.start.line + 1}: ${d.message}`);
+      }
+    }
+  }
+
+  parts.push("</extension-context>");
+
+  const totalErrors = diagnostics.reduce((s: number, d: { errors: number }) => s + d.errors, 0);
+  if (totalErrors > 0) {
+    parts.push("");
+    parts.push(`Found ${totalErrors} errors across the workspace.`);
+    parts.push("Use code_health to inspect issues.");
+  }
+
+  return parts.join("\n");
+}

package/src/substrate/lsp/lifecycle.ts

@@ -0,0 +1,66 @@
+// LSP session lifecycle — uses LspRuntimeController from @mrclrchtr/supi-lsp/api.
+//
+// Registers session_start and session_shutdown handlers that manage
+// the LspRuntimeController lifecycle.
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getDefaultWorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
+import {
+  LspRuntimeController,
+  loadLspSettings,
+  scanWorkspaceSentinels,
+} from "@mrclrchtr/supi-lsp/api";
+import { unregisterLspFooterContribution } from "../../ui/footer.ts";
+import type { LspAdapterState } from "./state.ts";
+
+export function registerLspSessionLifecycle(pi: ExtensionAPI, state: LspAdapterState): void {
+  pi.on("session_start", async (_event, ctx: ExtensionContext) => {
+    const cwd = ctx.cwd;
+    const runtime = getDefaultWorkspaceRuntime();
+
+    if (state.controller) {
+      await state.controller.shutdown();
+      state.controller = null;
+    }
+    resetDiagnosticContext(state);
+    state.lspActive = false;
+
+    const lspSettings = loadLspSettings(cwd);
+    // Always-on policy: `lsp.enabled` is deprecated and ignored. Keep reading
+    // settings for severity/exclude data, but let LspRuntimeController decide
+    // startup and per-language disables.
+    state.inlineSeverity = lspSettings.severity;
+
+    const controller = new LspRuntimeController(cwd, runtime);
+    const result = await controller.start();
+
+    if (result.kind === "ready") {
+      state.controller = controller;
+      state.lspActive = true;
+      state.sentinelSnapshot = scanWorkspaceSentinels(cwd);
+    } else {
+      state.controller = null;
+      resetDiagnosticContext(state);
+      state.lspActive = false;
+    }
+  });
+
+  pi.on("session_shutdown", async (_event, _ctx: ExtensionContext) => {
+    if (state.controller) {
+      await state.controller.shutdown();
+      state.controller = null;
+    }
+    resetDiagnosticContext(state);
+    state.lspActive = false;
+    unregisterLspFooterContribution();
+  });
+}
+
+/** Clear diagnostic context fields that could leak across sessions. */
+function resetDiagnosticContext(state: LspAdapterState): void {
+  state.currentContextToken = null;
+  state.lastDiagnosticsFingerprint = null;
+  state.staleSuspected = false;
+  state.lastWorkspaceChangeAt = 0;
+  state.contextCounter = 0;
+}

package/src/substrate/lsp/overrides.ts

@@ -0,0 +1,132 @@
+// LSP-aware tool overrides — ports read/write/edit overrides from supi-lsp.
+//
+// Opens files on read, appends inline diagnostics after write/edit.
+// biome-ignore-all lint/complexity/useMaxParams: pi ToolDefinition.execute signature requires 5 params.
+
+import * as nodePath from "node:path";
+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 { LspAdapterState } from "./state.ts";
+import { diagnosticMessageString } from "./utils.ts";
+
+export function registerLspAwareToolOverrides(pi: ExtensionAPI, state: LspAdapterState): void {
+  const readMeta = createReadTool(process.cwd());
+  const writeMeta = createWriteTool(process.cwd());
+  const editMeta = createEditTool(process.cwd());
+
+  pi.registerTool({
+    ...readMeta,
+    execute: makeReadExecutor(state),
+  });
+
+  pi.registerTool({
+    ...writeMeta,
+    execute: makeWriteExecutor(state),
+  });
+
+  pi.registerTool({
+    ...editMeta,
+    execute: makeEditExecutor(state),
+  });
+}
+
+function makeReadExecutor(state: LspAdapterState) {
+  return async (
+    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.lspActive || !state.controller?.manager) return result;
+    try {
+      await state.controller.manager.ensureFileOpen(resolveSessionPath(ctx.cwd, params.path));
+    } catch {
+      /* never block the agent */
+    }
+    return result;
+  };
+}
+
+function makeWriteExecutor(state: LspAdapterState) {
+  return async (
+    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.lspActive) return result;
+    return appendInlineDiagnostics(state, ctx.cwd, params.path, result);
+  };
+}
+
+function makeEditExecutor(state: LspAdapterState) {
+  return async (
+    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.lspActive) return result;
+    return appendInlineDiagnostics(state, ctx.cwd, params.path, result);
+  };
+}
+
+async function appendInlineDiagnostics<T extends { content: unknown[]; details: unknown }>(
+  state: LspAdapterState,
+  cwd: string,
+  filePath: string,
+  result: T,
+): Promise<T> {
+  const manager = state.controller?.manager;
+  if (!manager) return result;
+
+  try {
+    const resolved = resolveSessionPath(cwd, filePath);
+    const effectiveSeverity = Math.max(state.inlineSeverity, 2);
+    const entries = await manager.syncFileAndGetCascadingDiagnostics(resolved, effectiveSeverity);
+    if (entries.length === 0) return result;
+
+    // biome-ignore format: manual formatting for readability
+    const lines = [
+      "\n\n⚠️ LSP Diagnostics — review before continuing:",
+      ...entries.flatMap((entry) =>
+        entry.diagnostics.map(
+          (d) =>
+            `  ${entry.file}:${d.range.start.line + 1}: ${diagnosticMessageString(d)}`,
+        ),
+      ),
+      "If these errors are unexpected or appear across multiple files, fix the root cause before editing more.",
+    ];
+
+    const diagnosticContent = {
+      type: "text" as const,
+      text: lines.join("\n"),
+    } as T["content"][number];
+
+    return { ...result, content: [...result.content, diagnosticContent] } as T;
+  } catch {
+    return result;
+  }
+}
+
+function resolveSessionPath(cwd: string, filePath: string): string {
+  if (nodePath.isAbsolute(filePath)) return filePath;
+  if (filePath.startsWith("@")) return nodePath.resolve(cwd, filePath.slice(1));
+  return nodePath.resolve(cwd, filePath);
+}

package/src/substrate/lsp/recovery.ts

@@ -0,0 +1,55 @@
+// Workspace recovery handler — tool_result event that recovers LSP state after write/edit.
+//
+// Notifies the LSP manager about file changes so diagnostics stay fresh.
+
+import * as nodePath from "node:path";
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+  ToolResultEvent,
+} from "@earendil-works/pi-coding-agent";
+import { clearTsconfigCache } from "@mrclrchtr/supi-lsp/api";
+import type { LspAdapterState } from "./state.ts";
+
+export function registerWorkspaceRecoveryHandler(pi: ExtensionAPI, state: LspAdapterState): void {
+  pi.on("tool_result", async (event: ToolResultEvent, _ctx: ExtensionContext) => {
+    const manager = state.controller?.manager;
+    if (!manager || event.isError) return;
+
+    const filePath = getFilePathFromToolResult(event);
+    if (!filePath) return;
+
+    // Normalize @-prefixed paths (pi's built-in file tool convention)
+    const normalized = filePath.startsWith("@") ? filePath.slice(1) : filePath;
+    const resolved = nodePath.resolve(state.controller?.cwd ?? "", normalized);
+
+    // Invalidate tsconfig cache when config files change
+    const ext = nodePath.extname(resolved).toLowerCase();
+    if (ext === ".json" || ext === ".jsonc") {
+      clearTsconfigCache();
+    }
+
+    manager.clearAllPullResultIds();
+    manager.notifyWorkspaceFileChanges([{ uri: filePathToUri(resolved), type: 2 }]);
+
+    state.staleSuspected = true;
+    state.lastDiagnosticsFingerprint = null;
+    state.currentContextToken = null;
+    state.lastWorkspaceChangeAt = Date.now();
+  });
+}
+
+function getFilePathFromToolResult(event: ToolResultEvent): string | null {
+  if (event.isError) return null;
+  if (event.toolName !== "write" && event.toolName !== "edit") return null;
+  const input = (event as { input?: Record<string, unknown> }).input;
+  if (!input || typeof input !== "object") return null;
+  const pathValue = input.path;
+  if (typeof pathValue !== "string" || !pathValue) return null;
+  return pathValue;
+}
+
+function filePathToUri(filePath: string): string {
+  const normalized = filePath.replace(/\\/g, "/");
+  return `file://${normalized.startsWith("/") ? "" : "/"}${normalized}`;
+}