@mrclrchtr/supi-code-intelligence 6.3.0 → 7.0.0

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

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { fileToUri, uriToFile } from "@mrclrchtr/supi-core/path";
+import { fileToUri } from "@mrclrchtr/supi-core/path";
 import { FileChangeType, type FileEvent } from "../config/types.ts";
 import {
   type AutomaticLspPathPolicy,
@@ -11,12 +11,6 @@ import {
 const ROOT_LOCKFILES = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lockb"];
 
 export interface WorkspaceSentinelScanOptions {
-  /**
-   * Also track every regular source file (not just sentinels). The workspace
-   * refresh path uses this to discover files created since the last refresh;
-   * the diff then reports them as `sourceChanges` so the caller can pull them.
-   */
-  includeSourceFiles?: boolean;
   /** Runtime-owned automatic path policy. */
   policy?: AutomaticLspPathPolicy;
 }
@@ -36,7 +30,7 @@ export function scanWorkspaceSentinels(
     for (const entry of entries) {
       if (!entry.isFile() && !entry.isSymbolicLink()) continue;
       const filePath = path.join(directory, entry.name);
-      if (!options.includeSourceFiles && !isWorkspaceSentinelPath(filePath, resolvedCwd)) continue;
+      if (!isWorkspaceSentinelPath(filePath, resolvedCwd)) continue;
       try {
         snapshot.set(filePath, fs.statSync(filePath).mtimeMs);
       } catch {
@@ -78,38 +72,16 @@ export function diffWorkspaceSentinelSnapshot(
 export interface WorkspaceSentinelSyncResult {
   snapshot: Map<string, number>;
   changes: FileEvent[];
-  sourceChanges: FileEvent[];
 }
 
-/**
- * Refresh a previous snapshot and return the new snapshot plus change events.
- *
- * When `includeSourceFiles` is set, the returned `changes` list keeps
- * sentinel-file events only; source-file events are returned separately in
- * `sourceChanges` so the caller can act on them without interpreting every
- * regular file edit as a config-level workspace change.
- */
+/** Refresh a previous sentinel snapshot and return its change events. */
 export function syncWorkspaceSentinelSnapshot(
   cwd: string,
   previous: Map<string, number>,
   options: WorkspaceSentinelScanOptions = {},
 ): WorkspaceSentinelSyncResult {
   const snapshot = scanWorkspaceSentinels(cwd, options);
-  const changes = diffWorkspaceSentinelSnapshot(previous, snapshot);
-  if (!options.includeSourceFiles) return { snapshot, changes, sourceChanges: [] };
-
-  const sourceChanges = changes.filter((change) => {
-    const filePath = uriToFile(change.uri);
-    return !isWorkspaceSentinelPath(filePath, cwd);
-  });
-  return {
-    snapshot,
-    changes: changes.filter((change) => {
-      const filePath = uriToFile(change.uri);
-      return isWorkspaceSentinelPath(filePath, cwd);
-    }),
-    sourceChanges,
-  };
+  return { snapshot, changes: diffWorkspaceSentinelSnapshot(previous, snapshot) };
 }
 
 function isWorkspaceSentinelPath(filePath: string, root: string): boolean {

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

@@ -0,0 +1,108 @@
+import { type Dirent, promises as fs } from "node:fs";
+import * as path from "node:path";
+import {
+  type CodeRequestControl,
+  isCodeRequestInterruption,
+  throwIfCodeRequestInterrupted,
+} from "@mrclrchtr/supi-code-runtime/api";
+import { raceRequestControl } from "../session/readiness.ts";
+import type { AutomaticLspPathPolicy } from "../workspace-path-policy.ts";
+
+const MAX_SOURCE_INVENTORY_FILES = 50_000;
+
+export type WorkspaceSourceInventoryReason = "file-limit" | "filesystem-error";
+
+/** Complete or safety-limited automatic source inventory. */
+export interface WorkspaceSourceInventory {
+  readonly status: "complete" | "limited";
+  /** The reason is null only when the inventory is complete. */
+  readonly reason: WorkspaceSourceInventoryReason | null;
+  /** Number of configured-extension files observed before the scan stopped. */
+  readonly observedFileCount: number;
+  /** Paths are present only as a usable complete inventory. */
+  readonly files: readonly string[];
+}
+
+/** Inputs for one automatic source inventory. */
+export interface WorkspaceSourceScanOptions {
+  readonly fileTypes: readonly string[];
+  readonly policy: AutomaticLspPathPolicy;
+  readonly control?: CodeRequestControl;
+}
+
+/**
+ * Scan one workspace for automatic source paths.
+ *
+ * The scan uses the runtime path policy and configured LSP extensions. A
+ * limited result is not a source baseline and must not be diffed. Caller
+ * interruption is rethrown so a health call does not retain partial state.
+ */
+export async function scanWorkspaceSources(
+  cwd: string,
+  options: WorkspaceSourceScanOptions,
+): Promise<WorkspaceSourceInventory> {
+  const extensionSet = new Set(
+    options.fileTypes.map((fileType) => fileType.replace(/^\./, "").toLowerCase()),
+  );
+  const files: string[] = [];
+  let observedFileCount = 0;
+  let reason: WorkspaceSourceInventoryReason | null = null;
+
+  const readEntries = async (directory: string): Promise<Dirent[] | null> => {
+    try {
+      return await raceRequestControl(
+        fs.readdir(directory, { withFileTypes: true }) as Promise<Dirent[]>,
+        options.control,
+      );
+    } catch (error) {
+      if (isCodeRequestInterruption(error, options.control)) throw error;
+      reason = "filesystem-error";
+      return null;
+    }
+  };
+
+  const visitEntry = async (directory: string, entry: Dirent): Promise<void> => {
+    const filePath = path.join(directory, entry.name);
+    const kind = entry.isDirectory() ? "directory" : "file";
+    if (!options.policy.isEligible(filePath, kind)) return;
+
+    if (entry.isDirectory()) {
+      await walk(filePath);
+      return;
+    }
+    if (!entry.isFile() && !entry.isSymbolicLink()) return;
+    if (!extensionSet.has(path.extname(entry.name).slice(1).toLowerCase())) return;
+
+    observedFileCount++;
+    if (observedFileCount > MAX_SOURCE_INVENTORY_FILES) {
+      reason = "file-limit";
+      return;
+    }
+    files.push(filePath);
+  };
+
+  const walk = async (directory: string): Promise<void> => {
+    if (reason !== null) return;
+    throwIfCodeRequestInterrupted(options.control);
+    if (!options.policy.isEligible(directory, "directory")) return;
+
+    const entries = await readEntries(directory);
+    if (!entries) return;
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      throwIfCodeRequestInterrupted(options.control);
+      await visitEntry(directory, entry);
+      if (reason !== null) return;
+    }
+  };
+
+  await walk(path.resolve(cwd));
+  throwIfCodeRequestInterrupted(options.control);
+
+  return {
+    status: reason === null ? "complete" : "limited",
+    reason,
+    observedFileCount,
+    files: reason === null ? files.sort((a, b) => a.localeCompare(b)) : [],
+  };
+}

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({