@mrclrchtr/supi-code-intelligence 6.4.0 → 7.0.1

package/node_modules/@mrclrchtr/supi-lsp/src/client/client-diagnostic-evidence.ts

@@ -1,3 +1,4 @@
+// biome-ignore-all lint/style/noExcessiveLinesPerFile: Diagnostic validation and evidence application stay together.
 import {
   type CodeQueryResult,
   partialCodeQuery,
@@ -8,7 +9,6 @@ import type {
   DocumentDiagnosticReport,
   PublishDiagnosticsParams,
 } from "../config/types.ts";
-import type { DiagnosticStateWait } from "./client-diagnostic-waiters.ts";
 
 /** Validate one untrusted LSP diagnostic publication before it enters the cache. */
 export function isValidPublishDiagnosticsParams(value: unknown): value is PublishDiagnosticsParams {
@@ -154,34 +154,33 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+/** Evidence source that established or observed one cached diagnostic set. */
+export type DiagnosticEvidenceSource = "pull" | "typescript" | "push";
+
 /** Stored diagnostic data and the protocol evidence that established it. */
 export interface DiagnosticCacheEntry {
   diagnostics: Diagnostic[];
   receivedAt: number;
-  source: "pull" | "push";
+  source: DiagnosticEvidenceSource;
   synchronizationId?: number;
   evidenceRevision?: number;
   version?: number;
   resultId?: string;
   /**
-   * Valid publications observed for the entry's synchronization. The first
-   * valid publication for a synchronization is tentative; a later valid
-   * publication promotes the entry to confirmed (ADR 0021). A confirmed
-   * pull entry counts as the first publication when a push continues the
-   * same synchronization, so that push keeps the confirmation. Pull
-   * entries as such carry no count and are confirmed on arrival.
+   * Number of ambient publications retained for compatibility with existing
+   * telemetry. Publication count never establishes confirmation.
    */
   publications?: number;
 }
 
 /**
- * Test whether one push entry is still tentative for its synchronization.
+ * Test whether one entry came from ambient push observation.
  *
- * A pull entry confirms on arrival; a push entry confirms only after a
- * later valid publication for the same synchronization (ADR 0021).
+ * Push publication count is not a completion contract. Every push stays
+ * tentative until a request-based evidence source replaces it.
  */
 export function isTentativePushEntry(entry: DiagnosticCacheEntry | undefined): boolean {
-  return Boolean(entry && entry.source === "push" && (entry.publications ?? 1) < 2);
+  return entry?.source === "push";
 }
 
 /** One document synchronization that needs current diagnostic evidence. */
@@ -214,23 +213,6 @@ export function isCurrentSynchronization(
   );
 }
 
-/** Test whether a fresh push confirms the supplied synchronization. */
-export function hasFreshPush(
-  store: ReadonlyMap<string, DiagnosticCacheEntry>,
-  synchronization: DiagnosticSynchronization,
-  currentEvidenceRevision?: number,
-): boolean {
-  const entry = store.get(synchronization.uri);
-  return Boolean(
-    entry?.source === "push" &&
-      !isTentativePushEntry(entry) &&
-      entry.synchronizationId === synchronization.synchronizationId &&
-      (synchronization.evidenceRevision === undefined ||
-        entry.evidenceRevision === synchronization.evidenceRevision) &&
-      (currentEvidenceRevision === undefined || entry.evidenceRevision === currentEvidenceRevision),
-  );
-}
-
 /**
  * Test whether stored evidence matches a synchronization without a
  * confirmation gate. A tentative push matches here but cannot confirm.
@@ -262,16 +244,10 @@ export function hasFreshEvidence(
   );
 }
 
-/**
- * Return the latest cache update that matches one of the synchronizations.
- *
- * Every accepted publication restarts the settle quiet period, tentative
- * publications included, so this helper does not apply the confirmation
- * gate (ADR 0021).
- */
+/** Return the latest ambient update for one of the synchronizations. */
 export function latestCurrentEvidenceReceivedAt(
   store: ReadonlyMap<string, DiagnosticCacheEntry>,
-  synchronizations: DiagnosticSynchronization[],
+  synchronizations: readonly DiagnosticSynchronization[],
   currentEvidenceRevision?: number,
 ): number {
   let latest = 0;
@@ -284,34 +260,6 @@ export function latestCurrentEvidenceReceivedAt(
   return latest;
 }
 
-interface PullRaceOptions {
-  readonly pull: Promise<boolean>;
-  readonly waitForChange: () => DiagnosticStateWait;
-  readonly freshPush: () => boolean;
-  readonly current: () => boolean;
-}
-
-/** Race a pull against fresh push evidence and lifecycle release. */
-export async function raceDiagnosticPull(
-  options: PullRaceOptions,
-): Promise<"pull" | "push" | "released"> {
-  const pull = options.pull.then((confirmed) =>
-    confirmed ? ("pull" as const) : ("released" as const),
-  );
-  while (options.current()) {
-    if (options.freshPush()) return "push";
-    const change = options.waitForChange();
-    let outcome: "changed" | "pull" | "released";
-    try {
-      outcome = await Promise.race([pull, change.promise.then(() => "changed" as const)]);
-    } finally {
-      change.cancel();
-    }
-    if (outcome !== "changed") return outcome;
-  }
-  return "released";
-}
-
 /** Return explicit partial or unavailable evidence after fresh collection fails. */
 export function incompleteDiagnosticResult(
   cachedDiagnostics: Diagnostic[] | null,
@@ -342,6 +290,7 @@ interface ApplyPullReportOptions {
   readonly synchronizationId: number | undefined;
   readonly evidenceRevision: number;
   readonly isRelatedUriTracked: (uri: string) => boolean;
+  readonly source?: Exclude<DiagnosticEvidenceSource, "push">;
 }
 
 /** Apply one valid full or linked unchanged pull report. */
@@ -365,12 +314,18 @@ export function applyPullReport(options: ApplyPullReportOptions): boolean {
     store.set(uri, {
       diagnostics: report.items,
       receivedAt: Date.now(),
-      source: "pull",
+      source: options.source ?? "pull",
       synchronizationId,
       evidenceRevision,
       resultId: report.resultId,
     });
-    applyRelatedPullReports(store, report, evidenceRevision, isRelatedUriTracked);
+    applyRelatedPullReports({
+      store,
+      report,
+      evidenceRevision,
+      isRelatedUriTracked,
+      source: options.source ?? "pull",
+    });
     return true;
   }
   if (!previous || previousResultId === undefined || typeof report.resultId !== "string") {
@@ -379,34 +334,41 @@ export function applyPullReport(options: ApplyPullReportOptions): boolean {
   store.set(uri, {
     ...previous,
     receivedAt: Date.now(),
-    source: "pull",
+    source: options.source ?? "pull",
     synchronizationId,
     evidenceRevision,
     resultId: report.resultId,
   });
-  applyRelatedPullReports(store, report, evidenceRevision, isRelatedUriTracked);
+  applyRelatedPullReports({
+    store,
+    report,
+    evidenceRevision,
+    isRelatedUriTracked,
+    source: options.source ?? "pull",
+  });
   return true;
 }
 
-function applyRelatedPullReports(
-  store: Map<string, DiagnosticCacheEntry>,
-  report: DocumentDiagnosticReport,
-  evidenceRevision: number,
-  isRelatedUriTracked: (uri: string) => boolean,
-): void {
-  for (const [relatedUri, relatedReport] of Object.entries(report.relatedDocuments ?? {})) {
+function applyRelatedPullReports(options: {
+  store: Map<string, DiagnosticCacheEntry>;
+  report: DocumentDiagnosticReport;
+  evidenceRevision: number;
+  isRelatedUriTracked: (uri: string) => boolean;
+  source: Exclude<DiagnosticEvidenceSource, "push">;
+}): void {
+  for (const [relatedUri, relatedReport] of Object.entries(options.report.relatedDocuments ?? {})) {
     if (!isValidDocumentDiagnosticReport(relatedReport, false)) continue;
     // Skip explicit unchanged reports; full reports (kind "full", "", or
     // absent) may enter the related-document store.
     if (relatedReport.kind === "unchanged") continue;
-    if (isRelatedUriTracked(relatedUri)) continue;
-    const existing = store.get(relatedUri);
-    if (existing?.evidenceRevision === evidenceRevision) continue;
-    store.set(relatedUri, {
+    if (options.isRelatedUriTracked(relatedUri)) continue;
+    const existing = options.store.get(relatedUri);
+    if (existing?.evidenceRevision === options.evidenceRevision) continue;
+    options.store.set(relatedUri, {
       diagnostics: relatedReport.items,
       receivedAt: Date.now(),
-      source: "pull",
-      evidenceRevision,
+      source: options.source,
+      evidenceRevision: options.evidenceRevision,
       resultId: relatedReport.resultId,
     });
   }

package/node_modules/@mrclrchtr/supi-lsp/src/client/client-diagnostic-host.ts

@@ -1,5 +1,4 @@
-import type { DocumentDiagnosticReport } from "../config/types.ts";
-import type { DiagnosticPullRequest } from "./client-diagnostic-request.ts";
+import type { DiagnosticRequestAdapter } from "./client-diagnostic-request.ts";
 
 /** Transport and capability operations required by diagnostic state. */
 export interface ClientDiagnosticsHost {
@@ -8,8 +7,8 @@ export interface ClientDiagnosticsHost {
   /** Absolute workspace root, for debug-telemetry identity. */
   cwd?: string;
   isOperational(): boolean;
-  supportsPullDiagnostics(): boolean;
+  /** Native pull and server-specific request evidence share this priority adapter. */
+  diagnosticRequestAdapter: DiagnosticRequestAdapter;
   usesIncrementalDocumentSync(): boolean;
   sendNotification(method: string, params: unknown): void;
-  pullDocumentDiagnostics(request: DiagnosticPullRequest): Promise<DocumentDiagnosticReport | null>;
 }

package/node_modules/@mrclrchtr/supi-lsp/src/client/client-diagnostic-publication.ts

@@ -1,19 +1,16 @@
 // Bounded push-publication telemetry for one client's diagnostic state.
 //
-// Push-only servers can publish an early result and a later semantic result
-// for one document synchronization (ADR 0021). This tracker records one
-// bounded per-synchronization publication summary per diagnostic operation
-// and one ambient event when a later publication promotes a synchronization
-// that an earlier operation already reported unconfirmed. Events carry only
-// bounded server, workspace, relative-file, synchronization identity, count,
-// and timing data. They never carry diagnostic payloads or source text.
+// Push-only servers can publish one or more results for one document
+// synchronization. This tracker records one bounded per-synchronization
+// publication summary per diagnostic operation. Events
+// carry only bounded server, workspace, relative-file, synchronization
+// identity, count, and timing data. They never carry diagnostic payloads or
+// source text. Publication counts remain telemetry only.
 
-import * as path from "node:path";
 import {
   recordDebugEvent,
   truncateDebugIdentity as truncateIdentity,
 } from "@mrclrchtr/supi-core/debug";
-import { uriToFile } from "@mrclrchtr/supi-core/path";
 import { boundCwd } from "../debug-telemetry.ts";
 
 /** Maximum tracked synchronizations before the oldest entry is evicted. */
@@ -59,8 +56,6 @@ interface SynchronizationPublicationState {
   publications: number;
   firstReceivedAt: number;
   lastReceivedAt: number;
-  /** When a finished operation first reported this synchronization unconfirmed. */
-  unconfirmedAt?: number;
 }
 
 function synchronizationKey(
@@ -75,10 +70,7 @@ function synchronizationKey(
 export class DiagnosticPublicationTracker {
   readonly #states = new Map<string, SynchronizationPublicationState>();
 
-  constructor(
-    private readonly identity: { server?: string; cwd?: string },
-    private readonly fileFor: (uri: string) => string | undefined,
-  ) {}
+  constructor(private readonly identity: { server?: string; cwd?: string }) {}
 
   /**
    * Record one accepted push publication for a synchronization.
@@ -116,9 +108,8 @@ export class DiagnosticPublicationTracker {
   /**
    * Emit one bounded per-synchronization publication summary.
    *
-   * Synchronizations with no observed push publication are omitted. A
-   * synchronization that ends unconfirmed is marked so a later promotion can
-   * emit the ambient late-republish event.
+   * Synchronizations with no observed push publication are omitted. The
+   * caller supplies the confirmation flag; publication counts do not change it.
    */
   emitSummary(options: {
     readonly operation: "refresh-open" | "sync-file";
@@ -127,7 +118,6 @@ export class DiagnosticPublicationTracker {
     readonly operationId?: string;
   }): void {
     const entries: DiagnosticPublicationSummaryEntry[] = [];
-    const now = Date.now();
     for (const synchronization of options.synchronizations) {
       const state = this.#states.get(
         synchronizationKey(
@@ -144,8 +134,6 @@ export class DiagnosticPublicationTracker {
         lastReceivedAt: state.lastReceivedAt,
         confirmed: synchronization.confirmed,
       });
-      if (!synchronization.confirmed) state.unconfirmedAt ??= now;
-      else state.unconfirmedAt = undefined;
     }
     if (entries.length === 0) return;
     recordDebugEvent({
@@ -167,51 +155,4 @@ export class DiagnosticPublicationTracker {
       },
     });
   }
-
-  /**
-   * Observe one promotion of a synchronization by a later publication.
-   *
-   * The ambient late-republish event fires only when a finished operation
-   * previously reported the synchronization unconfirmed. The mark is cleared
-   * so one promotion emits at most one event.
-   */
-  promoted(
-    uri: string,
-    synchronizationId: number,
-    evidenceRevision: number,
-    receivedAt: number = Date.now(),
-  ): void {
-    const state = this.#states.get(synchronizationKey(uri, synchronizationId, evidenceRevision));
-    const unconfirmedAt = state?.unconfirmedAt;
-    if (!state || state.publications < 2 || unconfirmedAt === undefined) return;
-    state.unconfirmedAt = undefined;
-    const file = this.fileFor(uri);
-    recordDebugEvent({
-      source: "lsp",
-      level: "debug",
-      category: "diagnostics.publication",
-      message: "LSP diagnostic late republish",
-      cwd: boundCwd(this.identity.cwd),
-      data: {
-        synchronizationId,
-        publications: state.publications,
-        receivedAt,
-        delayMs: Math.max(0, receivedAt - unconfirmedAt),
-        ...(this.identity.server !== undefined
-          ? { server: truncateIdentity(this.identity.server) }
-          : {}),
-        ...(file !== undefined ? { file: truncateIdentity(file) } : {}),
-      },
-    });
-  }
-}
-
-/** Return a workspace-relative diagnostic file path for telemetry identity. */
-export function trackerFileIdentityFor(
-  cwd: string | undefined,
-): (uri: string) => string | undefined {
-  return (uri) => {
-    if (cwd === undefined) return undefined;
-    return path.relative(cwd, path.resolve(cwd, uriToFile(uri)));
-  };
 }

package/node_modules/@mrclrchtr/supi-lsp/src/client/client-diagnostic-pull.ts

@@ -1,62 +1,49 @@
-import { CodeRequestDeadlineError } from "@mrclrchtr/supi-code-runtime/api";
-import type { DocumentDiagnosticReport } from "../config/types.ts";
 import { applyPullReport, type DiagnosticCacheEntry } from "./client-diagnostic-evidence.ts";
-import type { DiagnosticPullRequest } from "./client-diagnostic-request.ts";
+import type {
+  DiagnosticPullRequest,
+  DiagnosticRequestAdapter,
+  DiagnosticRequestExecution,
+} from "./client-diagnostic-request.ts";
 
-interface PullDiagnosticEvidenceOptions {
-  store: Map<string, DiagnosticCacheEntry>;
-  uri: string;
-  timeoutMs: number;
-  synchronizationId?: number;
-  evidenceRevision: number;
-  currentRevision(): number;
-  isCurrentSynchronization(): boolean;
-  isRelatedUriTracked(uri: string): boolean;
-  signal?: AbortSignal;
-  deadline?: number;
-  operationId?: string;
-  pull(request: DiagnosticPullRequest): Promise<DocumentDiagnosticReport | null>;
-}
-
-/** Collect one pull report only if its document and workspace generations remain current. */
-export async function pullDiagnosticEvidence(
-  options: PullDiagnosticEvidenceOptions,
-): Promise<boolean> {
-  const previous = options.store.get(options.uri);
-  const previousResultId = previous?.resultId;
-  const report = await options.pull({
-    uri: options.uri,
-    previousResultId,
-    timeoutMs: options.timeoutMs,
-    signal: options.signal,
-    deadline: options.deadline,
-    operationId: options.operationId,
-  });
-  // Final gate: a report that lands after cancellation or deadline expiry
-  // must not be applied as evidence.
-  if (options.signal?.aborted) throw options.signal.reason;
-  if (options.deadline !== undefined && Date.now() >= options.deadline) {
-    throw new CodeRequestDeadlineError();
-  }
-  if (report === null || report === undefined) {
-    throw new Error("Invalid LSP diagnostic report.");
-  }
-  if (
-    options.evidenceRevision !== options.currentRevision() ||
-    (options.synchronizationId !== undefined && !options.isCurrentSynchronization())
-  ) {
-    return false;
-  }
-  const applied = applyPullReport({
-    store: options.store,
-    uri: options.uri,
-    report,
-    previous,
-    previousResultId,
-    synchronizationId: options.synchronizationId,
-    evidenceRevision: options.evidenceRevision,
-    isRelatedUriTracked: options.isRelatedUriTracked,
+/** Start one adapter request and apply it only while its evidence is current. */
+export function startDiagnosticEvidenceFromAdapter(options: {
+  readonly adapter: DiagnosticRequestAdapter;
+  readonly request: DiagnosticPullRequest;
+  readonly store: Map<string, DiagnosticCacheEntry>;
+  readonly synchronizationId?: number;
+  readonly evidenceRevision: number;
+  readonly currentRevision: () => number;
+  readonly isCurrentSynchronization: () => boolean;
+  readonly markEvidenceCurrent?: (uri: string, synchronizationId: number | undefined) => void;
+  readonly isRelatedUriTracked: (uri: string) => boolean;
+}): DiagnosticRequestExecution<boolean> {
+  const previous = options.store.get(options.request.uri);
+  const execution = options.adapter.collect(options.request);
+  const result = execution.result.then((requestResult) => {
+    if (options.request.signal?.aborted) {
+      throw options.request.signal.reason ?? new Error("Diagnostic request cancelled.");
+    }
+    if (
+      options.evidenceRevision !== options.currentRevision() ||
+      (options.synchronizationId !== undefined && !options.isCurrentSynchronization())
+    ) {
+      return false;
+    }
+    const applied = applyPullReport({
+      store: options.store,
+      uri: options.request.uri,
+      report: requestResult.report,
+      previous,
+      previousResultId: options.request.previousResultId,
+      synchronizationId: options.synchronizationId,
+      evidenceRevision: options.evidenceRevision,
+      isRelatedUriTracked: options.isRelatedUriTracked,
+      source: requestResult.source,
+    });
+    if (!applied) throw new Error("Invalid diagnostic request report.");
+    options.markEvidenceCurrent?.(options.request.uri, options.synchronizationId);
+    return true;
   });
-  if (!applied) throw new Error("Invalid LSP diagnostic report.");
-  return true;
+  result.catch(() => {});
+  return { result, settled: execution.settled };
 }