@mrclrchtr/supi-code-intelligence 6.2.0 → 6.4.0

package/node_modules/@mrclrchtr/supi-lsp/node_modules/ignore/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ignore",
-  "version": "7.0.6",
+  "version": "7.0.8",
   "description": "Ignore is a manager and filter for .gitignore rules, the one used by eslint, gitbook and many others.",
   "types": "index.d.ts",
   "files": [
@@ -25,9 +25,15 @@
     "test:mjs:16": "ts-node --compilerOptions '{\"moduleResolution\": \"Node16\", \"module\": \"Node16\"}' ./test/import/simple.mjs && babel -o ./test/import/simple-mjs.js ./test/import/simple.mjs && node ./test/import/simple-mjs.js",
 
     "===================== cases =======================": "",
-    "test:cases": "npm run tap test/*.test.js -- --coverage",
+    "test:cases": "npm run tap test/*.test.js -- --coverage --100",
     "tap": "tap --reporter classic",
 
+    "=================== benchmark =====================": "",
+    "benchmark": "node benchmark",
+
+    "==================== compat =======================": "",
+    "compat": "node compat && node compat --win32",
+
     "===================== debug =======================": "",
     "test:git": "npm run tap test/git-check-ignore.test.js",
     "test:ignore": "npm run tap test/ignore.test.js",
@@ -35,13 +41,13 @@
     "test:others": "npm run tap test/others.test.js",
     "test:no-coverage": "npm run tap test/*.test.js -- --no-check-coverage",
 
-    "test": "npm run lint && npm run ts && npm run build && npm run test:cases",
+    "test": "npm run lint && npm run ts && npm run build && npm run test:cases && npm run compat",
     "test:win32": "IGNORE_TEST_WIN32=1 npm run test",
     "report": "tap --coverage-report=html"
   },
   "repository": {
     "type": "git",
-    "url": "git@github.com:kaelzhang/node-ignore.git"
+    "url": "https://github.com/kaelzhang/node-ignore.git"
   },
   "keywords": [
     "ignore",

package/node_modules/@mrclrchtr/supi-lsp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-lsp",
-  "version": "6.2.0",
+  "version": "6.4.0",
   "description": "Language Server Protocol runtime for SuPi code intelligence",
   "license": "MIT",
   "repository": {
@@ -37,8 +37,8 @@
     "vscode-jsonrpc": "^9.0.0",
     "vscode-languageserver-protocol": "^3.18.0",
     "vscode-languageserver-types": "^3.18.0",
-    "@mrclrchtr/supi-code-runtime": "6.2.0",
-    "@mrclrchtr/supi-core": "6.2.0"
+    "@mrclrchtr/supi-code-runtime": "6.4.0",
+    "@mrclrchtr/supi-core": "6.4.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",

package/node_modules/@mrclrchtr/supi-lsp/src/api.ts

@@ -1,5 +1,6 @@
 // Public API surface for the LSP session-scoped service.
 
+export { isMissingFileError } from "./client/client-file-state.ts";
 export { type LoadConfigOptions, loadConfig } from "./config/config.ts";
 export type { LspSettings } from "./config/lsp-settings.ts";
 export { loadLspSettings } from "./config/lsp-settings.ts";
@@ -41,6 +42,12 @@ export {
   type WorkspaceSentinelScanOptions,
   type WorkspaceSentinelSyncResult,
 } from "./diagnostics/workspace-sentinels.ts";
+export {
+  scanWorkspaceSources,
+  type WorkspaceSourceInventory,
+  type WorkspaceSourceInventoryReason,
+  type WorkspaceSourceScanOptions,
+} from "./diagnostics/workspace-sources.ts";
 export { raceReadinessValue, raceRequestControl } from "./session/readiness.ts";
 export type {
   LspControllerState,
@@ -51,12 +58,17 @@ export type {
 } from "./session/runtime-controller.ts";
 export { LspRuntimeController } from "./session/runtime-controller.ts";
 export type {
+  BulkTrackFileOutcome,
+  BulkTrackFilesResult,
   DiagnosticEvidenceDocument,
   DiagnosticEvidenceStatus,
   DiagnosticEvidenceSummary,
   OutstandingDiagnosticSummaryEntry,
   ProcessCrashDiagnosticDemand,
-  ProcessCrashRecoverySummary,
+  ProcessCrashRecoveryEntry,
+  ProcessCrashRecoveryNextAction,
+  ProcessCrashRecoveryOutcome,
+  ProcessCrashRecoveryReport,
   RecoverDiagnosticsResult,
   RoutedMutationResponse,
   SemanticReadinessResult,
@@ -69,12 +81,14 @@ export type {
 } from "./session/runtime-registry.ts";
 export {
   clearWorkspaceLspRuntime,
-  emptyProcessCrashRecoverySummary,
+  emptyProcessCrashRecoveryReport,
   getWorkspaceLspRuntime,
+  MAX_PROCESS_CRASH_RECOVERY_ENTRIES,
   setWorkspaceLspRuntimeState,
   waitForWorkspaceLspRuntime,
 } from "./session/runtime-registry.ts";
 export { scanMissingServers } from "./session/scanner.ts";
+export { MAX_BULK_TRACK_FILES } from "./session/workspace-lsp-runtime.ts";
 export {
   AUTOMATIC_LSP_EXCLUDED_DIRECTORIES,
   type AutomaticLspPathPolicy,

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-process-crash-report.ts

@@ -0,0 +1,106 @@
+import * as path from "node:path";
+import {
+  MAX_PROCESS_CRASH_RECOVERY_ENTRIES,
+  type ProcessCrashRecoveryEntry,
+  type ProcessCrashRecoveryNextAction,
+  type ProcessCrashRecoveryOutcome,
+  type ProcessCrashRecoveryReport,
+} from "../session/runtime-diagnostics.ts";
+
+/** One route result before its root is projected to a workspace-relative path. */
+export interface ProcessCrashRecoveryRouteResult {
+  readonly name: string;
+  readonly root: string;
+  readonly outcome: ProcessCrashRecoveryOutcome;
+  /** The caught Error.message from a failed replacement, when available. */
+  readonly failureMessage?: string;
+}
+
+/** Maximum failure detail retained in a process-crash report. */
+export const MAX_PROCESS_CRASH_FAILURE_MESSAGE_LENGTH = 512;
+
+const OUTCOME_ORDER: Record<ProcessCrashRecoveryOutcome, number> = {
+  "recovery-failed": 0,
+  "recovery-exhausted": 1,
+  "skipped-no-retained-file": 2,
+  recovered: 3,
+};
+
+/** Build the bounded, deterministic report for one process-crash demand. */
+export function buildProcessCrashRecoveryReport(
+  routes: readonly ProcessCrashRecoveryRouteResult[],
+  cwd: string,
+): ProcessCrashRecoveryReport {
+  const entries = routes.map((route) => toReportEntry(route, cwd)).sort(compareEntries);
+  const visibleEntries = entries.slice(0, MAX_PROCESS_CRASH_RECOVERY_ENTRIES);
+
+  return {
+    recoveredRoutes: countRoutes(routes, "recovered"),
+    skippedRoutes: countRoutes(routes, "skipped-no-retained-file"),
+    failedRoutes: countRoutes(routes, "recovery-failed"),
+    exhaustedRoutes: countRoutes(routes, "recovery-exhausted"),
+    entries: visibleEntries,
+    omittedEntries: Math.max(0, entries.length - visibleEntries.length),
+  };
+}
+
+/** Limit one caught Error.message without retaining other error fields. */
+export function boundProcessCrashFailureMessage(message: string): string {
+  if (message.length <= MAX_PROCESS_CRASH_FAILURE_MESSAGE_LENGTH) return message;
+  return `${message.slice(0, MAX_PROCESS_CRASH_FAILURE_MESSAGE_LENGTH - 1)}…`;
+}
+
+function toReportEntry(
+  route: ProcessCrashRecoveryRouteResult,
+  cwd: string,
+): ProcessCrashRecoveryEntry {
+  const action = nextAction(route.outcome);
+  const entry: ProcessCrashRecoveryEntry = {
+    name: route.name,
+    root: relativeRoot(cwd, route.root),
+    outcome: route.outcome,
+    ...(action ? { nextAction: action } : {}),
+    ...(route.outcome === "recovery-failed" && route.failureMessage
+      ? { failureMessage: boundProcessCrashFailureMessage(route.failureMessage) }
+      : {}),
+  };
+  return entry;
+}
+
+function relativeRoot(cwd: string, root: string): string {
+  return (path.relative(path.resolve(cwd), path.resolve(cwd, root)) || ".").replaceAll("\\", "/");
+}
+
+function nextAction(outcome: ProcessCrashRecoveryOutcome): ProcessCrashRecoveryNextAction | null {
+  switch (outcome) {
+    case "skipped-no-retained-file":
+      return "use-exact-file";
+    case "recovery-failed":
+    case "recovery-exhausted":
+      return "reload-workspace";
+    case "recovered":
+      return null;
+  }
+}
+
+function compareEntries(
+  first: ProcessCrashRecoveryEntry,
+  second: ProcessCrashRecoveryEntry,
+): number {
+  return (
+    OUTCOME_ORDER[first.outcome] - OUTCOME_ORDER[second.outcome] ||
+    compareStrings(first.root, second.root) ||
+    compareStrings(first.name, second.name)
+  );
+}
+
+function compareStrings(first: string, second: string): number {
+  return first < second ? -1 : first > second ? 1 : 0;
+}
+
+function countRoutes(
+  routes: readonly ProcessCrashRecoveryRouteResult[],
+  outcome: ProcessCrashRecoveryOutcome,
+): number {
+  return routes.filter((route) => route.outcome === outcome).length;
+}

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

@@ -17,8 +17,8 @@ import {
   type StaleDiagnosticAssessment,
 } from "../diagnostics/stale-diagnostics.ts";
 import {
-  emptyProcessCrashRecoverySummary,
-  type ProcessCrashRecoverySummary,
+  emptyProcessCrashRecoveryReport,
+  type ProcessCrashRecoveryReport,
   type WorkspaceDiagnosticReport,
 } from "../session/runtime-diagnostics.ts";
 
@@ -28,7 +28,7 @@ export interface WorkspaceRecoveryResult {
   /** Clients restarted by stale-diagnostic recovery, not process-crash recovery. */
   restartedClients: number;
   /** No process-crash demand is handled by this generic recovery pass. */
-  processCrashRecovery: ProcessCrashRecoverySummary;
+  processCrashRecovery: ProcessCrashRecoveryReport;
   /** 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. */
@@ -164,7 +164,7 @@ export async function recoverWorkspaceDiagnostics(
     return {
       attemptedClients,
       restartedClients,
-      processCrashRecovery: emptyProcessCrashRecoverySummary(),
+      processCrashRecovery: emptyProcessCrashRecoveryReport(),
       attemptedServers,
       restartedServers: restartServerNames,
       ...(restartReason ? { restartReason } : {}),