@mrclrchtr/supi-code-intelligence 6.1.0 → 6.2.0

package/src/session/refactor-workflow.ts

@@ -26,13 +26,14 @@ import {
   isPlanFresh,
   type RefactorPlan,
 } from "./refactor-plans.ts";
-import type {
-  PublicSourceRange,
-  RefactorApplyWorkflowInput,
-  RefactorApplyWorkflowOutcome,
-  RefactorOperationInput,
-  RefactorPlanWorkflowInput,
-  RefactorPlanWorkflowOutcome,
+import {
+  PUBLIC_REFACTOR_OPERATION_NAMES,
+  type PublicSourceRange,
+  type RefactorApplyWorkflowInput,
+  type RefactorApplyWorkflowOutcome,
+  type RefactorOperationInput,
+  type RefactorPlanWorkflowInput,
+  type RefactorPlanWorkflowOutcome,
 } from "./refactor-types.ts";
 import { resolveTargetWorkflow, type TargetWorkflowDeps } from "./target-workflow.ts";
 import { reportProgress, throwIfAborted, type WorkflowControl } from "./workflow-control.ts";
@@ -208,13 +209,11 @@ function parseOperation(input: RefactorOperationInput):
   | {
       kind: "ok";
       operation: RefactorOperation;
-      newName: string;
+      newName?: string;
       range?: PublicSourceRange;
     }
   | { kind: "invalid-input"; message: string } {
-  const keys = ["rename_symbol", "extract_function", "extract_variable"].filter(
-    (key) => key in input,
-  );
+  const keys = PUBLIC_REFACTOR_OPERATION_NAMES.filter((key) => key in input);
   if (keys.length !== 1) {
     return { kind: "invalid-input", message: "Select exactly one refactor operation." };
   }
@@ -233,11 +232,17 @@ function parseOperation(input: RefactorOperationInput):
       range: input.extract_function.range,
     };
   }
+  if ("extract_variable" in input) {
+    return {
+      kind: "ok",
+      operation: "extract_variable",
+      newName: input.extract_variable.newName,
+      range: input.extract_variable.range,
+    };
+  }
   return {
     kind: "ok",
-    operation: "extract_variable",
-    newName: input.extract_variable.newName,
-    range: input.extract_variable.range,
+    operation: "update_imports" in input ? "update_imports" : "delete_dead_code",
   };
 }
 
@@ -265,13 +270,13 @@ async function planWithProvider(
     file: string;
     position: { line: number; character: number };
     range?: SourceRange;
-    newName: string;
+    newName?: string;
   },
   control?: WorkflowControl,
 ): Promise<RefactorResult> {
   if (!provider) return { kind: "unavailable", reason: "No semantic provider is active." };
   if (provider.refactor) return provider.refactor(request, control);
-  if (request.operation === "rename_symbol" && provider.rename) {
+  if (request.operation === "rename_symbol" && request.newName !== undefined && provider.rename) {
     return provider.rename(request.file, request.position, request.newName, control);
   }
   return {

package/src/substrate/lsp/lifecycle.ts

@@ -45,7 +45,6 @@ export function registerLspSessionLifecycle(
     await state.providerLease?.release();
     state.providerLease = null;
     state.controller = null;
-    state.lspActive = false;
     state.sentinelSnapshot = new Map();
 
     const lease = await acquireWorkspaceProviderHost(ctx.cwd, {
@@ -53,7 +52,6 @@ export function registerLspSessionLifecycle(
     });
     state.providerLease = lease;
     state.controller = lease.lspController;
-    state.lspActive = lease.lspController?.kind === "ready";
     state.sentinelSnapshot = lease.sentinelSnapshot;
     await onStarted?.(ctx);
     startLifecycleSubscription();
@@ -64,7 +62,6 @@ export function registerLspSessionLifecycle(
     await state.providerLease?.release();
     state.providerLease = null;
     state.controller = null;
-    state.lspActive = false;
     state.sentinelSnapshot = new Map();
     dispatchStateChange();
   });

package/src/substrate/lsp/maintenance.ts

@@ -24,7 +24,6 @@ import {
   isLikelyStaleDiagnostic,
   isProjectConfigFileName,
   raceRequestControl,
-  syncWorkspaceSentinelSnapshot,
   type WorkspaceLspRuntime,
 } from "@mrclrchtr/supi-lsp/api";
 import { mergeDiagnosticEvidence } from "../../diagnostics/evidence.ts";
@@ -56,7 +55,7 @@ export async function refreshLspMaintenance(
   sentinelSnapshot: Map<string, number>,
   options: LspMaintenanceOptions = {},
 ): Promise<WorkspaceLspMaintenanceResult> {
-  const { snapshot } = await synchronizeSentinels(runtime, cwd, sentinelSnapshot, options);
+  const { snapshot } = await synchronizeSentinels(runtime, sentinelSnapshot, options);
   let diagnosticEvidence = emptyEvidence();
   let failureReason: string | undefined;
 
@@ -115,7 +114,7 @@ export async function refreshFileLspMaintenance(options: {
   const { runtime, cwd, sentinelSnapshot, filePath, control } = options;
   // A cancelled caller stops before any maintenance work starts.
   throwIfCodeRequestInterrupted(control);
-  const { snapshot } = await synchronizeSentinels(runtime, cwd, sentinelSnapshot);
+  const { snapshot } = await synchronizeSentinels(runtime, sentinelSnapshot);
   const target = nodePath.resolve(filePath);
   const stale = confirmedOutstandingDiagnostics(runtime, cwd).some(
     (entry) =>
@@ -149,12 +148,11 @@ export async function refreshFileLspMaintenance(options: {
  */
 async function synchronizeSentinels(
   runtime: WorkspaceLspRuntime,
-  cwd: string,
   sentinelSnapshot: Map<string, number>,
   options: LspMaintenanceOptions = {},
 ) {
   const primed = sentinelSnapshot.size > 0;
-  const state = syncWorkspaceSentinelSnapshot(cwd, sentinelSnapshot, {
+  const state = runtime.syncWorkspaceSentinelSnapshot(sentinelSnapshot, {
     includeSourceFiles: true,
   });
 
@@ -193,6 +191,7 @@ async function trackCreatedSourceFiles(
     if (change.type !== FileChangeType.Created) continue;
     const filePath = uriToFile(change.uri);
     if (scope && !isWithinOrEqual(scope, filePath)) continue;
+    if (!runtime.isSupportedSourceFile(filePath)) continue;
     // Best-effort: a file no client can serve stays untracked and is
     // simply absent from evidence until a later explicit request.
     await runtime.trackFile(filePath);

package/src/substrate/lsp/settings.ts

@@ -1,8 +1,7 @@
 // LSP settings registration for the code-intelligence umbrella extension.
 //
-// Always-on LSP policy: the global `lsp.enabled` and `lsp.active` keys
-// are deprecated and ignored. Per-language disable via
-// `lsp.servers.<language>.enabled: false` is the only supported opt-out.
+// Per-language disable via `lsp.servers.<language>.enabled: false` is the
+// supported opt-out.
 //
 // Registered fields:
 // - exclude: stringList
@@ -21,11 +20,9 @@ import {
 } from "@mrclrchtr/supi-core/settings";
 import { type LspSettings, loadConfig } from "@mrclrchtr/supi-lsp/api";
 
-const LSP_DEFAULTS: LspSettings = {
-  enabled: true,
-  active: [],
-  exclude: [],
-};
+const LSP_DEFAULTS = {
+  exclude: [] as string[],
+} satisfies LspSettings;
 
 /** Discover configured servers from the defaults + effective LSP config. */
 function getConfiguredServers(cwd: string): string[] {
@@ -153,7 +150,7 @@ export function registerLspSettings(pi: ExtensionAPI): void {
           kind: "stringList" as const,
           key: "exclude",
           label: "Exclude Patterns",
-          description: "Gitignore patterns to suppress LSP diagnostics (comma-separated)",
+          description: "Gitignore patterns for automatic LSP workspace work (comma-separated)",
         },
         {
           kind: "custom" as const,

package/src/substrate/lsp/state.ts

@@ -22,7 +22,6 @@ export interface LspAdapterState {
   controller: LspRuntimeController | null;
   providerLease: WorkspaceProviderHostLease | null;
   inspector: LspInspectorState;
-  lspActive: boolean;
   /** Snapshot of workspace sentinel files (package.json, tsconfig, lockfiles) for change detection. */
   sentinelSnapshot: Map<string, number>;
   /** Fired for runtime lifecycle changes that require a footer render. */
@@ -34,7 +33,6 @@ export function createLspAdapterState(): LspAdapterState {
     controller: null,
     providerLease: null,
     inspector: { handle: null, close: null },
-    lspActive: false,
     sentinelSnapshot: new Map(),
     stateChanges: new EventTarget(),
   };

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

@@ -1,7 +1,7 @@
 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 { LspRuntimeController } from "@mrclrchtr/supi-lsp/api";
 import { TreeSitterRuntimeController } from "@mrclrchtr/supi-tree-sitter/api";
 
 const HOSTS = Symbol.for("supi-code-intelligence/workspace-provider-hosts");
@@ -77,7 +77,7 @@ class WorkspaceProviderHost {
       lspController: projectTrusted ? this.#lsp : null,
       sentinelSnapshot:
         projectTrusted && this.#lsp?.kind === "ready"
-          ? scanWorkspaceSentinels(this.cwd)
+          ? (this.#lsp.workspaceRuntime?.scanWorkspaceSentinels() ?? new Map())
           : new Map(),
       release: async () => {
         if (released) return;

package/src/tool/code_health/file-scope-markdown.ts

@@ -0,0 +1,43 @@
+import type { HealthDiagnosticObservation } from "../../session/health-types.ts";
+
+/** Render the tsconfig coverage result for a single-file health request. */
+export function renderFileScopeStatus(
+  lines: string[],
+  observation: Extract<
+    HealthDiagnosticObservation,
+    { kind: "completed" | "partial" | "unavailable" }
+  >,
+  cwd: string,
+): void {
+  if (observation.scope.kind !== "file" || !observation.scopeStatus) return;
+
+  const decision = observation.scopeStatus;
+  switch (decision.status) {
+    case "included":
+      lines.push(
+        `**Tsconfig**: covered by ${formatConfigPath(decision.configPath, cwd)} — part of workspace diagnostics.`,
+      );
+      return;
+    case "excluded":
+      lines.push(
+        `**Tsconfig**: NOT covered by ${formatConfigPath(decision.configPath, cwd)} — not part of workspace diagnostics.`,
+      );
+      return;
+    case "no-config":
+      lines.push("**Tsconfig**: no tsconfig.json or jsconfig.json found — nothing filtered.");
+      return;
+    case "out-of-tree":
+      lines.push("**Tsconfig**: outside the project root — not part of workspace diagnostics.");
+  }
+}
+
+/** Format a config path relative to the current workspace. */
+function formatConfigPath(configPath: string | null, cwd: string): string {
+  if (!configPath) return "no config";
+  return `\`${makeRelative(cwd, configPath)}\``;
+}
+
+/** Format a workspace path without exposing an absolute root. */
+export function makeRelative(cwd: string, file: string): string {
+  return file.startsWith(cwd) ? file.slice(cwd.length + 1) : file;
+}

package/src/tool/code_health/markdown.ts

@@ -11,9 +11,15 @@ import {
   formatProjectServerRouteSummary,
   formatProjectServerStatusReason,
 } from "../../analysis/health/server-status.ts";
+import { makeRelative, renderFileScopeStatus } from "./file-scope-markdown.ts";
+import {
+  formatProcessCrashRecovery,
+  formatRefreshElapsed,
+  formatStaleDiagnosticRestarts as formatStaleDiagnosticRestartsText,
+  isFileReadinessPending,
+} from "./refresh-outcome.ts";
 import type {
   HealthData,
-  HealthDiagnosticObservation,
   HealthDiagnosticScope,
   HealthRefreshAttempt,
   HealthResultAssembly,
@@ -48,19 +54,25 @@ function renderRefreshStatus(
   if (!hasDiagnostics) return;
 
   switch (data.refresh.kind) {
-    case "completed":
+    case "completed": {
+      const fileReadinessPending = isFileReadinessPending(data.refresh, data.semanticState);
       lines.push(
-        `**${refreshAttemptLabel(data.refresh)}**: ${asSentence(completedRefreshText(data.refresh))}`,
+        `**${refreshAttemptLabel(data.refresh)}**: ${asSentence(completedRefreshText(data.refresh, fileReadinessPending))}`,
       );
       lines.push(`**Stale assessment**: ${asSentence(staleAssessmentText(data.refresh))}`);
       lines.push("");
       return;
+    }
     case "failed": {
       const evidence = data.refresh.diagnosticEvidence
         ? `; ${formatDiagnosticEvidence(data.refresh.diagnosticEvidence)}`
         : "";
+      const processCrashRecovery = data.refresh.processCrashRecovery
+        ? formatProcessCrashRecovery(data.refresh.processCrashRecovery)
+        : null;
+      const staleRestart = formatStaleDiagnosticRestarts(data.refresh);
       lines.push(
-        `**${refreshAttemptLabel(data.refresh)}**: failed — ${data.refresh.reason}${evidence}`,
+        `**${refreshAttemptLabel(data.refresh)}**: failed — ${data.refresh.reason}${staleRestart ? `; ${staleRestart}` : ""}${processCrashRecovery ? `; ${processCrashRecovery}` : ""}${evidence}`,
       );
       lines.push("");
       return;
@@ -84,14 +96,27 @@ function renderRefreshStatus(
 
 function completedRefreshText(
   attempt: Extract<HealthRefreshAttempt, { kind: "completed" }>,
+  fileReadinessPending = attempt.fileReadiness === "pending",
 ): string {
-  const base =
-    attempt.attemptedActiveClients === 0 && attempt.restartedClients === 0
+  const processCrashRecovery = formatProcessCrashRecovery(attempt.processCrashRecovery);
+  const noOp =
+    !fileReadinessPending &&
+    attempt.attemptedActiveClients === 0 &&
+    attempt.restartedClients === 0 &&
+    processCrashRecovery === null;
+  const base = fileReadinessPending
+    ? "readiness pending — LSP may still be warming; retry shortly"
+    : noOp
       ? "completed no-op — no active clients were targeted"
-      : `completed — ${attempt.attemptedActiveClients} active client${plural(attempt.attemptedActiveClients)} targeted, ${attempt.restartedClients} restarted`;
+      : `completed — ${attempt.attemptedActiveClients} active client${plural(attempt.attemptedActiveClients)} targeted`;
+  const staleRestart = noOp ? null : formatStaleDiagnosticRestarts(attempt);
+  const outcome = [staleRestart, processCrashRecovery].filter(
+    (value): value is string => value !== null,
+  );
+  const withOutcome = outcome.length > 0 ? `${base}; ${outcome.join("; ")}` : base;
   return attempt.operationScope === "workspace-runtime"
-    ? `${base}; ${formatDiagnosticEvidence(attempt.diagnosticEvidence)}`
-    : base;
+    ? `${withOutcome}; ${formatDiagnosticEvidence(attempt.diagnosticEvidence)}`
+    : withOutcome;
 }
 
 function refreshAttemptLabel(attempt: Pick<HealthRefreshAttempt, "operationScope">): string {
@@ -117,7 +142,7 @@ function renderLastAttempt(lines: string[], attempt: HealthRefreshAttempt, cwd:
   const outcome = refreshAttemptOutcome(attempt);
   const label = refreshAttemptLabel(attempt);
   lines.push(
-    `**Previous ${label.toLowerCase()}**: ${asSentence(outcome)} Started ${formatElapsed(Date.now() - attempt.attemptedAt)}; requested ${formatDiagnosticScope(attempt.requestedDiagnosticScope, cwd)}; operation scope: ${refreshOperationScopeText(attempt)}.`,
+    `**Previous ${label.toLowerCase()}**: ${asSentence(outcome)} Started ${formatRefreshElapsed(Date.now() - attempt.attemptedAt)}; requested ${formatDiagnosticScope(attempt.requestedDiagnosticScope, cwd)}; operation scope: ${refreshOperationScopeText(attempt)}.`,
   );
 }
 
@@ -125,24 +150,35 @@ function renderRetainedAttempt(lines: string[], attempt: HealthRefreshAttempt, c
   const label =
     attempt.operationScope === "file-runtime" ? "File LSP maintenance" : "Diagnostic refresh";
   lines.push(
-    `**${label}**: not requested for this call. Previous attempt ${asSentence(refreshAttemptOutcome(attempt))} Started ${formatElapsed(Date.now() - attempt.attemptedAt)}; requested ${formatDiagnosticScope(attempt.requestedDiagnosticScope, cwd)}; operation scope: ${refreshOperationScopeText(attempt)}.`,
+    `**${label}**: not requested for this call. Previous attempt ${asSentence(refreshAttemptOutcome(attempt))} Started ${formatRefreshElapsed(Date.now() - attempt.attemptedAt)}; requested ${formatDiagnosticScope(attempt.requestedDiagnosticScope, cwd)}; operation scope: ${refreshOperationScopeText(attempt)}.`,
   );
 }
 
 function refreshAttemptOutcome(attempt: HealthRefreshAttempt): string {
-  return attempt.kind === "completed"
-    ? completedRefreshText(attempt)
-    : `failed — ${attempt.reason}${attempt.diagnosticEvidence ? `; ${formatDiagnosticEvidence(attempt.diagnosticEvidence)}` : ""}`;
+  if (attempt.kind === "completed") return completedRefreshText(attempt);
+  const processCrashRecovery = attempt.processCrashRecovery
+    ? formatProcessCrashRecovery(attempt.processCrashRecovery)
+    : null;
+  const staleRestart = formatStaleDiagnosticRestarts(attempt);
+  const evidence = attempt.diagnosticEvidence
+    ? `; ${formatDiagnosticEvidence(attempt.diagnosticEvidence)}`
+    : "";
+  return `failed — ${attempt.reason}${staleRestart ? `; ${staleRestart}` : ""}${processCrashRecovery ? `; ${processCrashRecovery}` : ""}${evidence}`;
 }
 
 function refreshOperationScopeText(attempt: HealthRefreshAttempt): string {
   return attempt.operationScope === "file-runtime" ? "file runtime" : "workspace runtime";
 }
 
-function formatElapsed(milliseconds: number): string {
-  const seconds = Math.max(0, Math.round(milliseconds / 1_000));
-  if (seconds < 60) return `${seconds}s ago`;
-  return `${Math.round(seconds / 60)}m ago`;
+function formatStaleDiagnosticRestarts(attempt: {
+  kind?: HealthRefreshAttempt["kind"];
+  operationScope: HealthRefreshAttempt["operationScope"];
+  restartedClients?: number;
+}): string | null {
+  if (attempt.operationScope !== "workspace-runtime" || attempt.restartedClients === undefined) {
+    return null;
+  }
+  return formatStaleDiagnosticRestartsText(attempt.restartedClients);
 }
 
 function renderCapabilityWarningsSection(
@@ -193,49 +229,6 @@ function renderDiagnosticsSection(lines: string[], data: HealthData, cwd: string
   lines.push("");
 }
 
-/**
- * Render the tsconfig coverage verdict for a single-file health request.
- *
- * Written in plain vocabulary (no basis terms) so a reader without tsconfig
- * background can act on it: the sentence names the deciding config and states
- * whether the file's errors are part of workspace diagnostics. The structured
- * decision basis stays in the diagnostics.scope debug event.
- */
-function renderFileScopeStatus(
-  lines: string[],
-  observation: Extract<
-    HealthDiagnosticObservation,
-    { kind: "completed" | "partial" | "unavailable" }
-  >,
-  cwd: string,
-): void {
-  if (observation.scope.kind !== "file" || !observation.scopeStatus) return;
-
-  const decision = observation.scopeStatus;
-  switch (decision.status) {
-    case "included":
-      lines.push(
-        `**Tsconfig**: covered by ${formatConfigPath(decision.configPath, cwd)} — part of workspace diagnostics.`,
-      );
-      return;
-    case "excluded":
-      lines.push(
-        `**Tsconfig**: NOT covered by ${formatConfigPath(decision.configPath, cwd)} — not part of workspace diagnostics.`,
-      );
-      return;
-    case "no-config":
-      lines.push("**Tsconfig**: no tsconfig.json or jsconfig.json found — nothing filtered.");
-      return;
-    case "out-of-tree":
-      lines.push("**Tsconfig**: outside the project root — not part of workspace diagnostics.");
-  }
-}
-
-function formatConfigPath(configPath: string | null, cwd: string): string {
-  if (!configPath) return "no config";
-  return `\`${makeRelative(cwd, configPath)}\``;
-}
-
 function formatDiagnosticEvidence(evidence: {
   requested: number;
   confirmed: number;
@@ -250,7 +243,14 @@ function renderDiagnosticObservation(lines: string[], data: HealthData, cwd: str
   const observation = data.diagnostics;
   if (observation.kind === "not-requested") return;
   if (observation.kind === "unavailable") {
-    lines.push(`Diagnostics unavailable — ${asSentence(observation.reason)}`);
+    if (
+      observation.scope.kind === "file" &&
+      isFileReadinessPending(currentRefreshAttempt(data), data.semanticState)
+    ) {
+      lines.push("Diagnostics pending — LSP may still be warming; retry shortly.");
+    } else {
+      lines.push(`Diagnostics unavailable — ${asSentence(observation.reason)}`);
+    }
     return;
   }
   if (observation.kind === "partial") {
@@ -269,6 +269,10 @@ function renderDiagnosticObservation(lines: string[], data: HealthData, cwd: str
   renderDiagnosticEntries(lines, data, cwd);
 }
 
+function currentRefreshAttempt(data: HealthData): HealthRefreshAttempt | null {
+  return data.refresh.kind === "completed" || data.refresh.kind === "failed" ? data.refresh : null;
+}
+
 function asSentence(text: string): string {
   return /[.!?]$/.test(text) ? text : `${text}.`;
 }
@@ -371,7 +375,3 @@ function formatDiagnosticScope(scope: HealthDiagnosticScope, cwd: string): strin
 function plural(count: number): string {
   return count === 1 ? "" : "s";
 }
-
-function makeRelative(cwd: string, file: string): string {
-  return file.startsWith(cwd) ? file.slice(cwd.length + 1) : file;
-}

package/src/tool/code_health/refresh-outcome.ts

@@ -0,0 +1,46 @@
+import type { ProcessCrashRecoverySummary } from "@mrclrchtr/supi-lsp/api";
+import type { SemanticHealthState } from "../../session/health-types.ts";
+
+/** Report whether a file health result is waiting for semantic readiness. */
+export function isFileReadinessPending(
+  attempt: { operationScope?: string; fileReadiness?: string } | null | undefined,
+  semanticState: SemanticHealthState | null | undefined,
+): boolean {
+  if (attempt?.operationScope !== undefined) {
+    return (
+      attempt.operationScope === "file-runtime" &&
+      (attempt.fileReadiness === "pending" ||
+        (attempt.fileReadiness === undefined && semanticState?.kind === "pending"))
+    );
+  }
+  return semanticState?.kind === "pending";
+}
+
+/** Format the outcome of stale-diagnostic client restarts. */
+export function formatStaleDiagnosticRestarts(restartedClients: number): string {
+  return `stale diagnostic restarts: ${restartedClients} client${plural(restartedClients)} restarted`;
+}
+
+/** Format a non-empty process-crash route recovery outcome. */
+export function formatProcessCrashRecovery(
+  summary: ProcessCrashRecoverySummary | null | undefined,
+): string | null {
+  if (
+    !summary ||
+    (summary.attemptedRoutes === 0 && summary.recoveredRoutes === 0 && summary.failedRoutes === 0)
+  ) {
+    return null;
+  }
+  return `process-crash recovery: ${summary.recoveredRoutes} route${plural(summary.recoveredRoutes)} recovered (${summary.attemptedRoutes} attempted, ${summary.failedRoutes} failed)`;
+}
+
+/** Format the age of a retained refresh attempt for a status line. */
+export function formatRefreshElapsed(milliseconds: number): string {
+  const seconds = Math.max(0, Math.round(milliseconds / 1_000));
+  if (seconds < 60) return `${seconds}s ago`;
+  return `${Math.round(seconds / 60)}m ago`;
+}
+
+function plural(count: number): string {
+  return count === 1 ? "" : "s";
+}