@mrclrchtr/supi-code-intelligence 3.2.0 → 4.0.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

@@ -5,11 +5,7 @@
 
 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 { LspRuntimeController, scanWorkspaceSentinels } from "@mrclrchtr/supi-lsp/api";
 import { unregisterLspFooterContribution } from "../../ui/footer.ts";
 import type { LspAdapterState } from "./state.ts";
 
@@ -22,14 +18,16 @@ export function registerLspSessionLifecycle(pi: ExtensionAPI, state: LspAdapterS
       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;
+    // Project-local LSP configuration may define custom commands; defer
+    // until the project is trusted so an untrusted repository cannot control
+    // spawned processes.
+    if (!ctx.isProjectTrusted()) {
+      state.controller = null;
+      state.lspActive = false;
+      return;
+    }
 
     const controller = new LspRuntimeController(cwd, runtime);
     const result = await controller.start();
@@ -40,7 +38,6 @@ export function registerLspSessionLifecycle(pi: ExtensionAPI, state: LspAdapterS
       state.sentinelSnapshot = scanWorkspaceSentinels(cwd);
     } else {
       state.controller = null;
-      resetDiagnosticContext(state);
       state.lspActive = false;
     }
   });
@@ -50,17 +47,7 @@ export function registerLspSessionLifecycle(pi: ExtensionAPI, state: LspAdapterS
       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/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

@@ -15,32 +15,21 @@ 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;
   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,
     inspector: { handle: null, close: null },
-    lastDiagnosticsFingerprint: null,
-    currentContextToken: null,
-    contextCounter: 0,
     lspActive: false,
-    staleSuspected: false,
-    lastWorkspaceChangeAt: 0,
     sentinelSnapshot: new Map(),
   };
 }

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>;

package/src/tool/find/execute.ts

@@ -1,131 +1,40 @@
-/**
- * Tool executor for code_find.
- *
- * Unified ranked code search with strict mode dispatch:
- * - text (default): literal ripgrep
- * - regex: ripgrep regex
- * - ast: tree-sitter structured search
- * - semantic: LSP workspace symbols
- *
- * Thin executor: validates params via pipeline, then delegates all
- * modes to the pattern use-case.
- */
+/** Thin Pi adapter for the session-owned code_find workflow. */
 
+import type { FindMode, FindWorkflowInput } from "../../session/find-types.ts";
 import type { CodeIntelResult, CodeIntelToolExecCtx } from "../../types/index.ts";
-import { findModeKindRules } from "../infra/cross-field.ts";
 import { unavailableSearchDetails } from "../infra/error-results.ts";
-import {
-  gateSemanticReadiness,
-  resolveScopeSetParam,
-  runPipe,
-  validateParams,
-} from "../infra/pipeline.ts";
-import { emitToolProgress } from "../infra/progress.ts";
-import { renderSemanticReadinessTimeout } from "../infra/readiness-message.ts";
-import { executePattern } from "./orchestrate.ts";
+import { toWorkflowControl } from "../infra/workflow-control.ts";
+import { assembleFindWorkflowResult } from "../result/find.ts";
+import type { CodeFindAstKind } from "./ast-kinds.ts";
+import { renderFindResult } from "./render.ts";
 
 export interface CodeFindToolParams {
   query: string;
-  scope?: string | string[];
-  mode?: "text" | "regex" | "ast" | "semantic";
-  kind?:
-    | "definition"
-    | "import"
-    | "export"
-    | "call"
-    | "type"
-    | "interface"
-    | "class"
-    | "method"
-    | "enum"
-    | "test";
-  contextLines?: number;
+  scope?: string[];
+  mode: FindMode;
+  kind?: CodeFindAstKind;
   maxResults?: number;
 }
 
-interface CodeFindPipelineParams extends CodeFindToolParams {
-  _resolvedScopePaths?: string[];
-  _resolvedScopeDisplay?: string | null;
-}
-
-function scopeForDetails(scope: CodeFindToolParams["scope"]): string | null {
-  if (Array.isArray(scope)) return scope.join(", ");
-  return scope ?? null;
-}
-
 export async function executeFindTool(
   params: CodeFindToolParams,
   ctx: CodeIntelToolExecCtx,
 ): Promise<CodeIntelResult> {
-  if (!params.query || params.query.trim().length === 0) {
+  const outcome = await ctx.session.find(params as FindWorkflowInput, toWorkflowControl(ctx));
+  if (outcome.kind === "unavailable") throw new Error(outcome.reason);
+  if (outcome.kind === "invalid-input") {
     return {
-      content: "**Error:** `code_find` requires a non-empty `query` parameter.",
-      details: unavailableSearchDetails(scopeForDetails(params.scope), [
-        "Provide a non-empty `query` parameter",
-      ]),
+      content: `**Error:** ${outcome.message}`,
+      details: unavailableSearchDetails(
+        Array.isArray(params?.scope) ? params.scope.join(", ") : null,
+        ["Fix the search input and retry"],
+      ),
     };
   }
 
-  emitToolProgress(ctx.onUpdate, `code_find: searching for "${params.query}"...`);
-
-  const mode = params.mode ?? "text";
-  const needsSemanticReadiness = mode === "semantic";
-
-  const pipelineParams = params as CodeFindPipelineParams;
-
-  return runPipe(
-    pipelineParams,
-    ctx,
-    [
-      validateParams(findModeKindRules(), (msg) => ({
-        content: msg,
-        details: unavailableSearchDetails(scopeForDetails(params.scope), [
-          'Use `mode: "ast"` with `kind`, or remove `kind` for text/regex/semantic search',
-        ]),
-      })),
-      resolveScopeSetParam((reason) => ({
-        content: `**Error:** ${reason}`,
-        details: unavailableSearchDetails(scopeForDetails(params.scope), [
-          "Verify each `scope` path exists and is within the workspace",
-        ]),
-      })),
-      ...(needsSemanticReadiness
-        ? [
-            gateSemanticReadiness("code_find", {
-              onTimeout: () => ({
-                content: renderSemanticReadinessTimeout("code_find", 15_000),
-                details: unavailableSearchDetails(scopeForDetails(params.scope), [
-                  "Retry shortly or check `code_health`",
-                ]),
-              }),
-              throwOnUnavailable: true,
-            }),
-          ]
-        : []),
-    ],
-    async (p, c) => {
-      emitToolProgress(c.onUpdate, `code_find: ${mode} mode...`);
-
-      // AST mode requires structural provider
-      if (mode === "ast" && !c.session.getStructuralProvider()) {
-        throw new Error(
-          "code_find AST search is unavailable because no structural/tree-sitter provider is active for this workspace.",
-        );
-      }
-
-      return executePattern(
-        {
-          pattern: p.query,
-          paths: p._resolvedScopePaths ?? [c.cwd],
-          scopeLabel: p._resolvedScopeDisplay ?? null,
-          regex: mode === "regex",
-          kind: p.kind,
-          mode,
-          maxResults: p.maxResults ?? 8,
-          contextLines: p.contextLines ?? 1,
-        },
-        { cwd: c.cwd, provider: c.session.getProvider(), signal: c.signal },
-      );
-    },
-  );
+  const assembly = assembleFindWorkflowResult(outcome);
+  return {
+    content: renderFindResult(assembly),
+    details: { type: "search", data: assembly.details },
+  };
 }