@mrclrchtr/supi-code-intelligence 6.3.0 → 7.0.0

package/node_modules/@mrclrchtr/supi-lsp/src/client/client-document-state.ts

@@ -56,8 +56,8 @@ export function hasCurrentDiagnosticEvidence(
 /**
  * Test whether cached diagnostics confirm the current document state.
  *
- * A current tentative push matches the document state but cannot support a
- * clean-result or cache-reuse claim until a republish confirms it (ADR 0021).
+ * A current push matches the document state but cannot support a clean-result
+ * or cache-reuse claim until request evidence replaces it.
  */
 export function hasConfirmedDiagnosticEvidence(
   document: OpenDocumentState | undefined,

package/node_modules/@mrclrchtr/supi-lsp/src/client/client-document-sync.ts

@@ -1,5 +1,5 @@
 import { readFileSync } from "node:fs";
-import type { TextDocumentItem, VersionedTextDocumentIdentifier } from "../config/types.ts";
+import type { VersionedTextDocumentIdentifier } from "../config/types.ts";
 import type { DiagnosticSynchronization } from "./client-diagnostic-evidence.ts";
 import type { DiagnosticWaitRegistry } from "./client-diagnostic-waiters.ts";
 import { fingerprintDocumentContent, type OpenDocumentState } from "./client-document-state.ts";
@@ -47,13 +47,20 @@ function contentChanges(
   return [{ text: content }];
 }
 
-/** Advance and publish one explicit document synchronization. */
-export function synchronizeDocument(options: SynchronizeDocumentOptions): void {
+/** Retain one document synchronization while advancing its evidence revision. */
+function retainDocumentSynchronization(
+  options: Pick<SynchronizeDocumentOptions, "uri" | "document" | "evidenceRevision" | "waiters">,
+): void {
   options.waiters.releaseFile(options.uri);
   options.waiters.cancelSettle();
+  options.document.evidenceRevision = options.evidenceRevision;
+}
+
+/** Advance and publish one explicit document synchronization. */
+export function synchronizeDocument(options: SynchronizeDocumentOptions): void {
+  retainDocumentSynchronization(options);
   options.document.version = options.version;
   options.document.synchronizationId = options.synchronizationId;
-  options.document.evidenceRevision = options.evidenceRevision;
   const changes = contentChanges(
     options.document.content,
     options.content,
@@ -83,44 +90,6 @@ export function clearTrackedDocumentState(
   waiters.cancelSettle();
 }
 
-/** Close and reopen one open document while preserving cache and version history. */
-export function reopenDocument(options: {
-  uri: string;
-  content: string;
-  document: OpenDocumentState;
-  languageId: string;
-  nextVersion(): number;
-  nextSynchronizationId(): number;
-  evidenceRevision: number;
-  waiters: DiagnosticWaitRegistry;
-  sendNotification: NotificationSender;
-  markUnversionedSyncMoment?(): void;
-}): void {
-  // Mirror didClose release semantics: pending waiters for this URI observe
-  // the protocol close, and the settle generation is cancelled so concurrent
-  // settles re-arm against the reopened state.
-  options.waiters.releaseFile(options.uri);
-  options.waiters.cancelSettle();
-  options.markUnversionedSyncMoment?.();
-  options.sendNotification("textDocument/didClose", {
-    textDocument: { uri: options.uri },
-  });
-  const version = options.nextVersion();
-  options.document.version = version;
-  options.document.synchronizationId = options.nextSynchronizationId();
-  options.document.evidenceRevision = options.evidenceRevision;
-  options.document.content = options.content;
-  options.document.contentFingerprint = fingerprintDocumentContent(options.content);
-  options.sendNotification("textDocument/didOpen", {
-    textDocument: {
-      uri: options.uri,
-      languageId: options.languageId,
-      version,
-      text: options.content,
-    } satisfies TextDocumentItem,
-  });
-}
-
 /** Synchronize one open document, or open it when the route is not tracked yet. */
 export function synchronizeTrackedDocument(options: {
   uri: string;
@@ -161,6 +130,10 @@ interface ResynchronizeDocumentsOptions {
   nextVersion(uri: string): number;
   nextSynchronizationId(): number;
   evidenceRevision: number;
+  /** Invalidate route evidence before the first changed document is applied. */
+  noteInputContentChange(): number;
+  /** Record the verified disk content in the shared semantic barrier. */
+  observeDiskContent(uri: string, content: string): void;
   incrementalSync: boolean;
   sendNotification: NotificationSender;
   uriToFile(uri: string): string;
@@ -188,32 +161,49 @@ export interface ResynchronizeDocumentsResult {
 export function resynchronizeOpenDocuments(
   options: ResynchronizeDocumentsOptions,
 ): ResynchronizeDocumentsResult {
-  const synchronizations: DiagnosticSynchronization[] = [];
+  const synchronizedUris = new Set<string>();
   const resynchronizedUris = new Set<string>();
   const removedFiles: string[] = [];
   const failedFiles: string[] = [];
+  let synchronizationRevision = options.evidenceRevision;
+  let inputChangeNoted = false;
   for (const [uri, document] of options.openDocuments) {
     const filePath = options.uriToFile(uri);
     try {
       options.markUnversionedSyncMoment(uri);
-      synchronizeDocument({
-        uri,
-        content: options.preloadedContent?.get(uri) ?? readFileSync(filePath, "utf-8"),
-        document,
-        version: options.nextVersion(uri),
-        synchronizationId: options.nextSynchronizationId(),
-        evidenceRevision: options.evidenceRevision,
-        incrementalSync: options.incrementalSync,
-        waiters: options.waiters,
-        sendNotification: options.sendNotification,
-      });
+      const content = options.preloadedContent?.get(uri) ?? readFileSync(filePath, "utf-8");
+      const contentChanged = fingerprintDocumentContent(content) !== document.contentFingerprint;
+      if (contentChanged) {
+        if (!inputChangeNoted) {
+          synchronizationRevision = options.noteInputContentChange();
+          inputChangeNoted = true;
+        }
+        synchronizeDocument({
+          uri,
+          content,
+          document,
+          version: options.nextVersion(uri),
+          synchronizationId: options.nextSynchronizationId(),
+          evidenceRevision: synchronizationRevision,
+          incrementalSync: options.incrementalSync,
+          waiters: options.waiters,
+          sendNotification: options.sendNotification,
+        });
+      } else {
+        // A failed read can select an unchanged open document for recovery.
+        // Keep its protocol identity stable, but make the current evidence
+        // generation eligible for a fresh request or push observation.
+        retainDocumentSynchronization({
+          uri,
+          document,
+          evidenceRevision: synchronizationRevision,
+          waiters: options.waiters,
+        });
+      }
+      options.observeDiskContent(uri, content);
       options.clearFailedFile(uri);
-      resynchronizedUris.add(uri);
-      synchronizations.push({
-        uri,
-        synchronizationId: document.synchronizationId,
-        evidenceRevision: document.evidenceRevision,
-      });
+      synchronizedUris.add(uri);
+      if (contentChanged) resynchronizedUris.add(uri);
     } catch {
       if (getDiagnosticFileState(filePath) === "removed") {
         options.clearFile(uri);
@@ -227,5 +217,15 @@ export function resynchronizeOpenDocuments(
       // Keep the document open when a transient read fails.
     }
   }
+  const synchronizations: DiagnosticSynchronization[] = [];
+  for (const uri of synchronizedUris) {
+    const document = options.openDocuments.get(uri);
+    if (!document) continue;
+    synchronizations.push({
+      uri,
+      synchronizationId: document.synchronizationId,
+      evidenceRevision: document.evidenceRevision,
+    });
+  }
   return { synchronizations, resynchronizedUris, removedFiles, failedFiles };
 }

package/node_modules/@mrclrchtr/supi-lsp/src/client/client-request-enrollment.ts

@@ -0,0 +1,75 @@
+import {
+  isSemanticInputEnrollmentError,
+  type SemanticInputSynchronizationError,
+} from "./client-semantic-input-errors.ts";
+
+const MAX_REQUEST_ENROLLMENT_RETRIES = 1;
+
+/** A request-level enrollment retry decision owned by one request attempt. */
+export type RequestEnrollmentRetryDecision =
+  | { readonly kind: "retry" }
+  | { readonly kind: "stop"; readonly error: unknown };
+
+/** Look up the current input change after a failed request revision. */
+export type SemanticInputChangeLookup = (
+  revision: number,
+) => SemanticInputSynchronizationError | undefined;
+
+/**
+ * Keep one semantic or diagnostic request's enrollment retry policy cohesive.
+ *
+ * Synchronization passes have their own rejoin budget. This guard only owns
+ * the request-level budget and the first failed revision used to classify
+ * later changes.
+ */
+export class SemanticInputRequestRetryGuard {
+  #requestRetries = 0;
+  #firstFailedRevision: number | undefined;
+
+  constructor(private readonly currentChangeSince: SemanticInputChangeLookup) {}
+
+  /** Number of request-level retries permitted for this request so far. */
+  get retryCount(): number {
+    return this.#requestRetries;
+  }
+
+  /** Whether this request already used its one request-level retry. */
+  get hasRetried(): boolean {
+    return this.#requestRetries > 0;
+  }
+
+  /** Throw the current non-enrollment cause when it blocks a retry. */
+  assertCurrent(): void {
+    const blockingChange = this.#getBlockingChange();
+    if (blockingChange) throw blockingChange;
+  }
+
+  /** Classify one failed attempt and decide whether it may be retried. */
+  decide(error: unknown, inputRevision: number | undefined): RequestEnrollmentRetryDecision {
+    if (!isSemanticInputEnrollmentError(error)) {
+      return { kind: "stop", error };
+    }
+
+    if (this.#firstFailedRevision !== undefined) {
+      const blockingChange = this.#getBlockingChange();
+      if (blockingChange) return { kind: "stop", error: blockingChange };
+    }
+    if (inputRevision === undefined) return { kind: "stop", error };
+
+    this.#firstFailedRevision ??= inputRevision;
+    const blockingChange = this.#getBlockingChange();
+    if (blockingChange) return { kind: "stop", error: blockingChange };
+    if (this.#requestRetries >= MAX_REQUEST_ENROLLMENT_RETRIES) {
+      return { kind: "stop", error };
+    }
+
+    this.#requestRetries++;
+    return { kind: "retry" };
+  }
+
+  #getBlockingChange(): SemanticInputSynchronizationError | undefined {
+    if (this.#firstFailedRevision === undefined) return undefined;
+    const currentChange = this.currentChangeSince(this.#firstFailedRevision);
+    return currentChange?.changeKind === "enrollment" ? undefined : currentChange;
+  }
+}