@mrclrchtr/supi-code-intelligence 3.2.0 → 4.1.0

package/src/session/workflow-control.ts

@@ -0,0 +1,35 @@
+/** Execution controls shared by Workspace code-intelligence session workflows. */
+
+/** Stable progress event emitted by a session-owned workflow. */
+export interface WorkflowProgressEvent {
+  readonly intent:
+    | "resolve"
+    | "inspect"
+    | "orientation"
+    | "graph"
+    | "find"
+    | "health"
+    | "refactor-plan"
+    | "refactor-apply";
+  readonly phase: string;
+  readonly message: string;
+}
+
+/** Per-call cancellation and progress controls. */
+export interface WorkflowControl {
+  readonly signal?: AbortSignal;
+  readonly progress?: (event: WorkflowProgressEvent) => void;
+}
+
+/** Emit one stable progress event when a sink is present. */
+export function reportProgress(
+  control: WorkflowControl | undefined,
+  event: WorkflowProgressEvent,
+): void {
+  control?.progress?.(Object.freeze(event));
+}
+
+/** Throw the platform-standard cancellation reason before starting a phase. */
+export function throwIfAborted(control: WorkflowControl | undefined): void {
+  control?.signal?.throwIfAborted();
+}

package/src/substrate/lsp/lifecycle.ts

@@ -1,66 +1,39 @@
-// LSP session lifecycle — uses LspRuntimeController from @mrclrchtr/supi-lsp/api.
-//
-// Registers session_start and session_shutdown handlers that manage
-// the LspRuntimeController lifecycle.
+// LSP lifecycle backed by the process-shared Workspace provider host.
 
 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 { acquireWorkspaceProviderHost } from "../workspace-provider-host.ts";
 import type { LspAdapterState } from "./state.ts";
 
-export function registerLspSessionLifecycle(pi: ExtensionAPI, state: LspAdapterState): void {
+/** Acquire providers once per workspace and release them after the final Pi session ends. */
+export function registerLspSessionLifecycle(
+  pi: ExtensionAPI,
+  state: LspAdapterState,
+  onStarted?: (ctx: ExtensionContext) => void | Promise<void>,
+): 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);
+    await state.providerLease?.release();
+    state.providerLease = null;
+    state.controller = null;
     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;
-    }
+    state.sentinelSnapshot = new Map();
+
+    const lease = await acquireWorkspaceProviderHost(ctx.cwd, {
+      projectTrusted: ctx.isProjectTrusted(),
+    });
+    state.providerLease = lease;
+    state.controller = lease.lspController;
+    state.lspActive = lease.lspController?.kind === "ready";
+    state.sentinelSnapshot = lease.sentinelSnapshot;
+    await onStarted?.(ctx);
   });
 
-  pi.on("session_shutdown", async (_event, _ctx: ExtensionContext) => {
-    if (state.controller) {
-      await state.controller.shutdown();
-      state.controller = null;
-    }
-    resetDiagnosticContext(state);
+  pi.on("session_shutdown", async () => {
+    await state.providerLease?.release();
+    state.providerLease = null;
+    state.controller = null;
     state.lspActive = false;
+    state.sentinelSnapshot = new Map();
     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/maintenance.ts

@@ -0,0 +1,75 @@
+/**
+ * Runtime maintenance — sentinel-sync, stale-module resync, prune, and refresh.
+ *
+ * Extracted from the former diagnostic-injection.ts. These are non-presentational
+ * maintenance operations that keep LSP state fresh for explicit code_health and
+ * semantic tool queries.
+ */
+
+import * as nodePath from "node:path";
+import type { WorkspaceLspRuntime } from "@mrclrchtr/supi-lsp/api";
+import {
+  clearTsconfigCache,
+  isLikelyStaleDiagnostic,
+  syncWorkspaceSentinelSnapshot,
+} from "@mrclrchtr/supi-lsp/api";
+
+/**
+ * Run sentinel-sync, stale-module resync, prune, and diagnostic refresh
+ * as a single maintenance pass. Call before explicit diagnostic queries
+ * (code_health with refresh:true) or semantic tool readiness checks.
+ */
+export async function refreshLspMaintenance(
+  runtime: WorkspaceLspRuntime,
+  cwd: string,
+  sentinelSnapshot: Map<string, number>,
+): Promise<Map<string, number>> {
+  // Sentinel refresh: detect lockfile/tsconfig/d.ts changes from outside
+  // write/edit/code_refactor_apply.
+  const { snapshot, changes } = syncWorkspaceSentinelSnapshot(cwd, sentinelSnapshot);
+
+  if (changes.length > 0) {
+    clearTsconfigCache();
+    runtime.noteWorkspaceChanges(changes);
+  }
+
+  // Stale-module resync: force-reopen files with "Cannot find module" errors
+  await resyncStaleModuleFiles(runtime, cwd);
+
+  // Two-pass prune/refresh for diagnostics
+  runtime.pruneMissingFiles();
+  try {
+    await runtime.refreshOpenDiagnostics();
+  } catch {
+    /* best-effort */
+  }
+  runtime.pruneMissingFiles();
+
+  return snapshot;
+}
+
+/** Re-open files with stale module-resolution errors. */
+async function resyncStaleModuleFiles(runtime: WorkspaceLspRuntime, cwd: string): Promise<void> {
+  const outstanding = runtime.getOutstandingDiagnostics(1);
+  const staleFiles: string[] = [];
+
+  for (const entry of outstanding) {
+    if (entry.diagnostics.some((d) => isLikelyStaleDiagnostic(d))) {
+      staleFiles.push(entry.file);
+    }
+  }
+
+  if (staleFiles.length === 0) return;
+
+  for (const file of staleFiles) {
+    const filePath = nodePath.resolve(cwd, file);
+    runtime.closeFile(filePath);
+    await runtime.trackFile(filePath);
+  }
+
+  try {
+    await runtime.refreshOpenDiagnostics({ quietMs: 300, maxWaitMs: 2000 });
+  } catch {
+    /* best-effort */
+  }
+}

package/src/substrate/lsp/recovery.ts

@@ -1,6 +1,8 @@
-// Workspace recovery handler — tool_result event that recovers LSP state after write/edit.
+// Workspace recovery handler — tool_result event that recovers LSP state after
+// file-mutating tool calls.
 //
-// Notifies the LSP manager about file changes so diagnostics stay fresh.
+// Notifies the workspace LSP runtime about file changes so diagnostics stay fresh
+// for explicit code_health and semantic tool queries.
 
 import * as nodePath from "node:path";
 import type {
@@ -8,40 +10,45 @@ import type {
   ExtensionContext,
   ToolResultEvent,
 } from "@earendil-works/pi-coding-agent";
+import { fileToUri } from "@mrclrchtr/supi-core/path";
 import { clearTsconfigCache } from "@mrclrchtr/supi-lsp/api";
 import type { LspAdapterState } from "./state.ts";
 
+/** Tool names whose successful results should trigger workspace change notifications. */
+const MUTATING_TOOL_NAMES = new Set(["write", "edit", "code_refactor_apply"]);
+
 export function registerWorkspaceRecoveryHandler(pi: ExtensionAPI, state: LspAdapterState): void {
+  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: handler branches per tool name; extracting helpers would add indirection
   pi.on("tool_result", async (event: ToolResultEvent, _ctx: ExtensionContext) => {
-    const manager = state.controller?.manager;
-    if (!manager || event.isError) return;
+    const runtime = state.controller?.workspaceRuntime;
+    if (!runtime || event.isError) return;
+    if (!MUTATING_TOOL_NAMES.has(event.toolName)) return;
 
-    const filePath = getFilePathFromToolResult(event);
-    if (!filePath) return;
+    const filePaths =
+      event.toolName === "code_refactor_apply"
+        ? getRefactorApplyPaths(event)
+        : [getFilePathFromToolResult(event)].filter((p): p is string => p !== null);
 
-    // 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);
+    if (filePaths.length === 0) return;
 
-    // Invalidate tsconfig cache when config files change
-    const ext = nodePath.extname(resolved).toLowerCase();
-    if (ext === ".json" || ext === ".jsonc") {
-      clearTsconfigCache();
-    }
+    const cwd = state.controller?.cwd ?? "";
+    for (const filePath of filePaths) {
+      // Normalize @-prefixed paths (pi's built-in file tool convention)
+      const normalized = filePath.startsWith("@") ? filePath.slice(1) : filePath;
+      const resolved = nodePath.resolve(cwd, normalized);
 
-    manager.clearAllPullResultIds();
-    manager.notifyWorkspaceFileChanges([{ uri: filePathToUri(resolved), type: 2 }]);
+      // Invalidate tsconfig cache when config files change
+      const ext = nodePath.extname(resolved).toLowerCase();
+      if (ext === ".json" || ext === ".jsonc") {
+        clearTsconfigCache();
+      }
 
-    state.staleSuspected = true;
-    state.lastDiagnosticsFingerprint = null;
-    state.currentContextToken = null;
-    state.lastWorkspaceChangeAt = Date.now();
+      runtime.noteWorkspaceChanges([{ uri: fileToUri(resolved), type: 2 }]);
+    }
   });
 }
 
 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;
@@ -49,7 +56,16 @@ function getFilePathFromToolResult(event: ToolResultEvent): string | null {
   return pathValue;
 }
 
-function filePathToUri(filePath: string): string {
-  const normalized = filePath.replace(/\\/g, "/");
-  return `file://${normalized.startsWith("/") ? "" : "/"}${normalized}`;
+/** Extract changed file paths emitted by a successful code_refactor_apply result. */
+function getRefactorApplyPaths(event: ToolResultEvent): string[] {
+  const details = (event as { details?: unknown }).details as
+    | { data?: { changedFiles?: unknown } }
+    | undefined;
+  const changedFiles = details?.data?.changedFiles;
+  if (!Array.isArray(changedFiles)) return [];
+  return [
+    ...new Set(
+      changedFiles.filter((file): file is string => typeof file === "string" && file.length > 0),
+    ),
+  ];
 }

package/src/substrate/lsp/settings.ts

@@ -4,8 +4,7 @@
 // are deprecated and ignored. Per-language disable via
 // `lsp.servers.<language>.enabled: false` is the only supported opt-out.
 //
-// Uses the declarative settings schema with:
-// - severity: number with labeled values
+// Registered fields:
 // - exclude: stringList
 // - disabled_servers: custom submenu that writes per-language disable config
 
@@ -23,7 +22,6 @@ import { type LspSettings, loadConfig } from "@mrclrchtr/supi-lsp/api";
 
 const LSP_DEFAULTS: LspSettings = {
   enabled: true,
-  severity: 1,
   active: [],
   exclude: [],
 };
@@ -138,13 +136,6 @@ export function registerLspSettings(pi: ExtensionAPI): void {
     section: "lsp",
     defaults: LSP_DEFAULTS,
     fields: [
-      {
-        kind: "number" as const,
-        key: "severity",
-        label: "Inline Severity",
-        description: "Minimum diagnostic severity to show inline (1=errors, 4=hints)",
-        values: ["1", "2", "3", "4"],
-      },
       {
         kind: "stringList" as const,
         key: "exclude",

package/src/substrate/lsp/state.ts

@@ -4,6 +4,7 @@
 // through LspRuntimeController from @mrclrchtr/supi-lsp/api.
 
 import type { LspRuntimeController } from "@mrclrchtr/supi-lsp/api";
+import type { WorkspaceProviderHostLease } from "../workspace-provider-host.ts";
 
 /** LSP status overlay UI state (handle + close). */
 export interface LspInspectorState {
@@ -15,32 +16,23 @@ export interface LspInspectorState {
  * In-memory state for the umbrella LSP adapter.
  *
  * Wraps the LspRuntimeController and tracks session-level state
- * for diagnostic injection, stale detection, and UI updates.
+ * for sentinel change detection and UI updates.
  */
 export interface LspAdapterState {
   controller: LspRuntimeController | null;
-  inlineSeverity: number;
+  providerLease: WorkspaceProviderHostLease | null;
   inspector: LspInspectorState;
-  lastDiagnosticsFingerprint: string | null;
-  currentContextToken: string | null;
-  contextCounter: number;
   lspActive: boolean;
-  staleSuspected: boolean;
-  lastWorkspaceChangeAt: number;
+  /** Snapshot of workspace sentinel files (package.json, tsconfig, lockfiles) for change detection. */
   sentinelSnapshot: Map<string, number>;
 }
 
 export function createLspAdapterState(): LspAdapterState {
   return {
     controller: null,
-    inlineSeverity: 1,
+    providerLease: null,
     inspector: { handle: null, close: null },
-    lastDiagnosticsFingerprint: null,
-    currentContextToken: null,
-    contextCounter: 0,
     lspActive: false,
-    staleSuspected: false,
-    lastWorkspaceChangeAt: 0,
     sentinelSnapshot: new Map(),
   };
 }

package/src/substrate/workspace-provider-host.ts

@@ -0,0 +1,129 @@
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+import { getDefaultWorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
+import { LspRuntimeController, scanWorkspaceSentinels } from "@mrclrchtr/supi-lsp/api";
+import { TreeSitterRuntimeController } from "@mrclrchtr/supi-tree-sitter/api";
+
+const HOSTS = Symbol.for("supi-code-intelligence/workspace-provider-hosts");
+const SHUTDOWN_GRACE_MS = 2_000;
+
+type HostRegistry = Map<string, WorkspaceProviderHost>;
+
+/** One acquired reference to a process-shared Workspace provider host. */
+export interface WorkspaceProviderHostLease {
+  cwd: string;
+  lspController: LspRuntimeController | null;
+  sentinelSnapshot: Map<string, number>;
+  release(): Promise<void>;
+}
+
+function registry(): HostRegistry {
+  const global = globalThis as typeof globalThis & { [HOSTS]?: HostRegistry };
+  global[HOSTS] ??= new Map();
+  return global[HOSTS];
+}
+
+function canonicalWorkspace(cwd: string): string {
+  try {
+    return realpathSync(cwd);
+  } catch {
+    return resolve(cwd);
+  }
+}
+
+function settleWithin(operation: Promise<void>): Promise<void> {
+  return Promise.race([
+    operation.catch(() => undefined),
+    new Promise<void>((resolveGrace) => {
+      const timeout = setTimeout(resolveGrace, SHUTDOWN_GRACE_MS);
+      timeout.unref?.();
+    }),
+  ]);
+}
+
+class WorkspaceProviderHost {
+  readonly cwd: string;
+  #leases = 0;
+  #lsp: LspRuntimeController | null = null;
+  #tree: TreeSitterRuntimeController | null = null;
+  #treeStarted = false;
+  #lspStarted = false;
+  #settledStart = Promise.resolve();
+  #closed = false;
+
+  constructor(cwd: string) {
+    this.cwd = cwd;
+  }
+
+  async acquire(projectTrusted: boolean): Promise<WorkspaceProviderHostLease> {
+    if (this.#closed) throw new Error("Workspace provider host is closed.");
+    // Count this pending acquirer before awaiting startup so the final active lease cannot shut it down.
+    this.#leases++;
+    this.#settledStart = this.#settledStart
+      .then(() => this.#startMissing(projectTrusted))
+      .catch(() => undefined);
+    await this.#settledStart;
+    let released = false;
+    return {
+      cwd: this.cwd,
+      lspController: projectTrusted ? this.#lsp : null,
+      sentinelSnapshot:
+        projectTrusted && this.#lsp?.kind === "ready"
+          ? scanWorkspaceSentinels(this.cwd)
+          : new Map(),
+      release: async () => {
+        if (released) return;
+        released = true;
+        this.#leases--;
+        if (this.#leases === 0) {
+          registry().delete(this.cwd);
+          await this.#shutdown();
+        }
+      },
+    };
+  }
+
+  async #startMissing(projectTrusted: boolean): Promise<void> {
+    const runtime = getDefaultWorkspaceRuntime();
+    if (!this.#treeStarted) {
+      this.#treeStarted = true;
+      this.#tree = new TreeSitterRuntimeController(this.cwd, runtime);
+      await this.#tree.start().catch(() => undefined);
+    }
+    if (!projectTrusted || this.#lspStarted) return;
+    this.#lspStarted = true;
+    this.#lsp = new LspRuntimeController(this.cwd, runtime);
+    await this.#lsp.start().catch(() => undefined);
+  }
+
+  async #shutdown(): Promise<void> {
+    if (this.#closed) return;
+    this.#closed = true;
+    await Promise.all([
+      ...(this.#lsp ? [settleWithin(this.#lsp.shutdown())] : []),
+      ...(this.#tree ? [settleWithin(this.#tree.shutdown())] : []),
+    ]);
+    this.#lsp = null;
+    this.#tree = null;
+  }
+}
+
+/** Acquire shared semantic and structural providers for one canonical workspace. */
+export async function acquireWorkspaceProviderHost(
+  cwd: string,
+  options: { projectTrusted: boolean },
+): Promise<WorkspaceProviderHostLease> {
+  const workspace = canonicalWorkspace(cwd);
+  const hosts = registry();
+  let host = hosts.get(workspace);
+  if (!host) {
+    host = new WorkspaceProviderHost(workspace);
+    hosts.set(workspace, host);
+  }
+  return host.acquire(options.projectTrusted);
+}
+
+/** Clear process-shared hosts between isolated tests. */
+export function resetWorkspaceProviderHostsForTests(): void {
+  registry().clear();
+}

package/src/tool/find/ast-kinds.ts

@@ -0,0 +1,35 @@
+/** Canonical public AST-kind vocabulary for code_find. */
+export const CODE_FIND_AST_KINDS = [
+  "definition",
+  "import",
+  "export",
+  "call",
+  "type",
+  "interface",
+  "class",
+  "method",
+  "enum",
+] as const;
+
+/** One supported code_find AST search kind. */
+export type CodeFindAstKind = (typeof CODE_FIND_AST_KINDS)[number];
+
+const CODE_FIND_AST_KIND_SET = new Set<string>(CODE_FIND_AST_KINDS);
+
+/** Return whether a direct caller supplied a supported code_find AST kind. */
+export function isCodeFindAstKind(value: unknown): value is CodeFindAstKind {
+  return typeof value === "string" && CODE_FIND_AST_KIND_SET.has(value);
+}
+
+/** Exhaustive presentation labels keyed by the canonical AST-kind vocabulary. */
+export const CODE_FIND_AST_KIND_LABELS = {
+  definition: "Definitions",
+  import: "Imports",
+  export: "Exports",
+  call: "Calls",
+  type: "Types",
+  interface: "Interfaces",
+  class: "Classes",
+  method: "Methods",
+  enum: "Enums",
+} as const satisfies Record<CodeFindAstKind, string>;