@mrclrchtr/supi-code-intelligence 6.4.0 → 7.0.0

package/node_modules/@mrclrchtr/supi-lsp/src/manager/manager-diagnostics.ts

@@ -10,17 +10,23 @@ import type { Diagnostic } from "../config/types.ts";
 import { effectiveDiagnosticSeverity } from "../diagnostics/diagnostic-severity.ts";
 import { relativeFilePathFromUri } from "../diagnostics/diagnostic-summary.ts";
 
+/** Options for one manager-owned diagnostic request. */
+interface SyncClientFileOptions {
+  readonly control?: CodeRequestControl;
+  readonly contentIsAuthoritative?: boolean;
+}
+
 /** Sync one file and return diagnostics up to the supplied severity threshold. */
 export async function syncClientFileAndGetDiagnostics(
   client: Pick<LspClient, "syncAndWaitForDiagnostics">,
   filePath: string,
   maxSeverity: number,
-  control?: CodeRequestControl,
+  options: SyncClientFileOptions = {},
 ): Promise<CodeQueryResult<Diagnostic[]>> {
   const content = readFileSync(filePath, "utf-8");
-  const result = control
-    ? await client.syncAndWaitForDiagnostics(filePath, content, control)
-    : await client.syncAndWaitForDiagnostics(filePath, content);
+  const result = await client.syncAndWaitForDiagnostics(filePath, content, options.control, {
+    contentIsAuthoritative: options.contentIsAuthoritative ?? true,
+  });
   return mapCodeQueryResult(result, (diagnostics) =>
     filterDiagnosticsBySeverity(diagnostics, maxSeverity),
   );

package/node_modules/@mrclrchtr/supi-lsp/src/manager/manager-process-crash-report.ts

@@ -5,6 +5,8 @@ import {
   type ProcessCrashRecoveryNextAction,
   type ProcessCrashRecoveryOutcome,
   type ProcessCrashRecoveryReport,
+  type StartupRetryEntry,
+  type StartupRetryReport,
 } from "../session/runtime-diagnostics.ts";
 
 /** One route result before its root is projected to a workspace-relative path. */
@@ -77,7 +79,7 @@ function nextAction(outcome: ProcessCrashRecoveryOutcome): ProcessCrashRecoveryN
       return "use-exact-file";
     case "recovery-failed":
     case "recovery-exhausted":
-      return "reload-workspace";
+      return "refresh";
     case "recovered":
       return null;
   }
@@ -104,3 +106,50 @@ function countRoutes(
 ): number {
   return routes.filter((route) => route.outcome === outcome).length;
 }
+
+/** One initial-start route result before its root is projected. */
+export interface StartupRetryRouteResult {
+  readonly name: string;
+  readonly root: string;
+  readonly outcome: StartupRetryEntry["outcome"];
+  readonly failureMessage?: string;
+}
+
+/** Build a bounded, deterministic report for initial-start retries. */
+export function buildStartupRetryReport(
+  routes: readonly StartupRetryRouteResult[],
+  cwd: string,
+): StartupRetryReport {
+  const entries = routes
+    .map(
+      (route): StartupRetryEntry => ({
+        name: route.name,
+        root: relativeRoot(cwd, route.root),
+        outcome: route.outcome,
+        ...(route.outcome === "retry-failed"
+          ? {
+              nextAction: "refresh" as const,
+              ...(route.failureMessage
+                ? { failureMessage: boundProcessCrashFailureMessage(route.failureMessage) }
+                : {}),
+            }
+          : {}),
+      }),
+    )
+    .sort(compareStartupEntries);
+  const visibleEntries = entries.slice(0, MAX_PROCESS_CRASH_RECOVERY_ENTRIES);
+  return {
+    recoveredRoutes: routes.filter((route) => route.outcome === "recovered").length,
+    failedRoutes: routes.filter((route) => route.outcome === "retry-failed").length,
+    entries: visibleEntries,
+    omittedEntries: Math.max(0, entries.length - visibleEntries.length),
+  };
+}
+
+function compareStartupEntries(first: StartupRetryEntry, second: StartupRetryEntry): number {
+  return (
+    Number(first.outcome !== "retry-failed") - Number(second.outcome !== "retry-failed") ||
+    compareStrings(first.root, second.root) ||
+    compareStrings(first.name, second.name)
+  );
+}

package/node_modules/@mrclrchtr/supi-lsp/src/manager/manager-workspace-recovery.ts

@@ -18,7 +18,9 @@ import {
 } from "../diagnostics/stale-diagnostics.ts";
 import {
   emptyProcessCrashRecoveryReport,
+  emptyStartupRetryReport,
   type ProcessCrashRecoveryReport,
+  type StartupRetryReport,
   type WorkspaceDiagnosticReport,
 } from "../session/runtime-diagnostics.ts";
 
@@ -29,6 +31,8 @@ export interface WorkspaceRecoveryResult {
   restartedClients: number;
   /** No process-crash demand is handled by this generic recovery pass. */
   processCrashRecovery: ProcessCrashRecoveryReport;
+  /** No initial-start retry is handled by this generic recovery pass. */
+  startupRetry: StartupRetryReport;
   /** Server names of the active clients targeted by this pass, for telemetry identity. */
   attemptedServers: string[];
   /** Server names of the clients restarted during this pass, for telemetry identity. */
@@ -49,8 +53,8 @@ export interface WorkspaceRecoveryResult {
 /** One client route's diagnostic evidence capability for recovery targeting. */
 export interface WorkspaceDiagnosticRoute {
   key: string;
-  /** False for push-only clients, which cannot confirm freshness by pull. */
-  supportsPull: boolean;
+  /** False for push-only clients, which have no request adapter. */
+  hasDiagnosticRequestAdapter: boolean;
   /** Files tracked by the route whose evidence is unconfirmed. */
   unconfirmedFiles: string[];
   /** Protocol-stall signal observed on the route, or null when healthy. */
@@ -165,6 +169,7 @@ export async function recoverWorkspaceDiagnostics(
       attemptedClients,
       restartedClients,
       processCrashRecovery: emptyProcessCrashRecoveryReport(),
+      startupRetry: emptyStartupRetryReport(),
       attemptedServers,
       restartedServers: restartServerNames,
       ...(restartReason ? { restartReason } : {}),
@@ -232,15 +237,14 @@ async function collectInitialEvidence(
 /**
  * Collect restart targets: push-only routes with a protocol-stall signal.
  *
- * Unconfirmed evidence alone never restarts a client: the reopen-resync
- * fallback handles unconfirmed push-only documents without discarding
- * server state (ADR 0020). Restarts require a readiness stall or repeated
- * protocol failures, and stay limited to push-only routes.
+ * Unconfirmed evidence alone never restarts a client. Restarts require a
+ * readiness stall or repeated protocol failures, and stay limited to routes
+ * without a diagnostic request adapter.
  */
 function collectRecoveryRestartTargets(host: WorkspaceRecoveryHost): RecoveryRestartTarget[] {
   const targets: RecoveryRestartTarget[] = [];
   for (const route of host.getClientDiagnosticRoutes()) {
-    if (route.supportsPull) continue;
+    if (route.hasDiagnosticRequestAdapter) continue;
     if (!route.stallSignal) continue;
     if (route.unconfirmedFiles.length === 0) continue;
     targets.push({