@mrclrchtr/supi-lsp 10.0.0 → 11.0.0

package/node_modules/@mrclrchtr/supi-code-runtime/src/file-associations.ts

@@ -0,0 +1,190 @@
+import * as path from "node:path";
+import picomatch from "picomatch";
+
+/** Language selected for a C-family source file. */
+export type CFamilyLanguage = "c" | "cpp";
+
+/** One ordered, project-relative language rule for an existing C-family file. */
+export interface CFamilyFileAssociationRule {
+  readonly pattern: string;
+  readonly language: CFamilyLanguage;
+}
+
+/** C-family suffixes that already have Tree-sitter and LSP support. */
+export const C_FAMILY_EXTENSIONS = Object.freeze([
+  ".c",
+  ".h",
+  ".cpp",
+  ".hpp",
+  ".cc",
+  ".cxx",
+  ".hxx",
+  ".c++",
+  ".h++",
+] as const);
+
+export type CFamilyExtension = (typeof C_FAMILY_EXTENSIONS)[number];
+
+const DEFAULT_C_FAMILY_LANGUAGES: Readonly<Record<CFamilyExtension, CFamilyLanguage>> =
+  Object.freeze({
+    ".c": "c",
+    ".h": "c",
+    ".cpp": "cpp",
+    ".hpp": "cpp",
+    ".cc": "cpp",
+    ".cxx": "cpp",
+    ".hxx": "cpp",
+    ".c++": "cpp",
+    ".h++": "cpp",
+  });
+
+/** Immutable C-family language selection for one workspace. */
+export interface CFamilyFileAssociationResolver {
+  /** Absolute root used to make project-relative paths. */
+  readonly workspaceRoot: string;
+  /** Validated ordered rules captured when the workspace host starts. */
+  readonly rules: readonly CFamilyFileAssociationRule[];
+  /** Select the configured language or the existing suffix default. */
+  languageForFile(filePath: string): CFamilyLanguage | undefined;
+}
+
+/** Return the current default language for one supported C-family suffix. */
+export function defaultCFamilyLanguage(extension: string): CFamilyLanguage | undefined {
+  return DEFAULT_C_FAMILY_LANGUAGES[extension.toLowerCase() as CFamilyExtension];
+}
+
+/**
+ * Validate and compile ordered C-family file associations for one workspace.
+ * Patterns are case-sensitive globs over POSIX-style, workspace-relative paths.
+ * Supported patterns use `*`, `?`, `**`, character classes, and brace alternatives.
+ * The first matching rule wins. Rules never expand the eligible suffix set.
+ *
+ * @throws If the rule list, a rule, a language, or a pattern is invalid.
+ */
+export function createCFamilyFileAssociationResolver(
+  workspaceRoot: string,
+  input: unknown = [],
+): CFamilyFileAssociationResolver {
+  const rules = validateRules(input);
+  const matchers = rules.map((rule, index) => ({
+    language: rule.language,
+    matches: compilePattern(rule.pattern, `code-intelligence.fileAssociations[${index}]`),
+  }));
+  const root = path.resolve(workspaceRoot);
+  return Object.freeze({
+    workspaceRoot: root,
+    rules,
+    languageForFile(filePath: string): CFamilyLanguage | undefined {
+      const extension = normalizeExtension(filePath);
+      const fallback = defaultCFamilyLanguage(extension);
+      if (!fallback) return undefined;
+
+      const absolutePath = path.resolve(root, filePath);
+      const relativePath = toPosixPath(path.relative(root, absolutePath));
+      if (
+        relativePath === ".." ||
+        relativePath.startsWith("../") ||
+        path.posix.isAbsolute(relativePath)
+      ) {
+        return fallback;
+      }
+      for (const rule of matchers) {
+        if (rule.matches(relativePath)) return rule.language;
+      }
+      return fallback;
+    },
+  });
+}
+
+function validateRules(input: unknown): readonly CFamilyFileAssociationRule[] {
+  if (!Array.isArray(input)) {
+    throw new Error('Invalid "code-intelligence.fileAssociations": expected an ordered array.');
+  }
+  if (input.length > 64) {
+    throw new Error('Invalid "code-intelligence.fileAssociations": use no more than 64 rules.');
+  }
+  const rules: CFamilyFileAssociationRule[] = [];
+  const seenPatterns = new Set<string>();
+  for (const [index, value] of input.entries()) {
+    const key = `code-intelligence.fileAssociations[${index}]`;
+    if (!isRecord(value) || !hasExactKeys(value, ["pattern", "language"])) {
+      throw new Error(`${key} must contain only "pattern" and "language" fields.`);
+    }
+    if (typeof value.pattern !== "string") {
+      throw new Error(`${key}.pattern must be a string.`);
+    }
+    if (value.language !== "c" && value.language !== "cpp") {
+      throw new Error(`${key}.language must be "c" or "cpp".`);
+    }
+    if (seenPatterns.has(value.pattern)) {
+      throw new Error(`${key}.pattern duplicates an earlier rule.`);
+    }
+    seenPatterns.add(value.pattern);
+    rules.push(Object.freeze({ pattern: value.pattern, language: value.language }));
+  }
+  return Object.freeze(rules);
+}
+
+function compilePattern(pattern: string, key: string): (file: string) => boolean {
+  if (
+    pattern.length === 0 ||
+    pattern.length > 512 ||
+    pattern !== pattern.trim() ||
+    pattern.includes("\\") ||
+    hasControlCharacter(pattern) ||
+    pattern.startsWith("/") ||
+    /^[A-Za-z]:/.test(pattern) ||
+    pattern.startsWith("!")
+  ) {
+    throw new Error(`${key}.pattern must be a safe workspace-relative glob using "/" separators.`);
+  }
+  const segments = pattern.split("/");
+  if (segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
+    throw new Error(`${key}.pattern contains an unsafe or unsupported path pattern.`);
+  }
+  try {
+    return picomatch(pattern, {
+      nocase: false,
+      windows: false,
+      dot: true,
+      strictBrackets: true,
+      nonegate: true,
+      noextglob: true,
+      maxLength: 512,
+    });
+  } catch (error) {
+    throw new Error(`${key}.pattern is not a valid glob: ${errorMessage(error)}`, { cause: error });
+  }
+}
+
+function hasControlCharacter(value: string): boolean {
+  for (const character of value) {
+    const code = character.charCodeAt(0);
+    if (code < 32 || code === 127) return true;
+  }
+  return false;
+}
+
+function normalizeExtension(filePath: string): string {
+  return path.posix.extname(toPosixPath(filePath)).toLowerCase();
+}
+
+function toPosixPath(value: string): string {
+  return value.replaceAll("\\", "/");
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function hasExactKeys(value: Record<string, unknown>, keys: readonly string[]): boolean {
+  const allowed = new Set(keys);
+  return (
+    keys.every((key) => Object.hasOwn(value, key)) &&
+    Object.keys(value).every((key) => allowed.has(key))
+  );
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}

package/node_modules/@mrclrchtr/supi-code-runtime/src/types.ts

@@ -80,6 +80,14 @@ export interface DocumentCodeSymbol extends CodeSymbol {
  */
 export type CodeResult<T> =
   | { kind: "success"; data: T }
+  | {
+      kind: "partial";
+      data: T;
+      file: string;
+      reason: string;
+      /** Syntax error and missing-node ranges in 0-based UTF-16 coordinates. */
+      errorRanges: SourceRange[];
+    }
   | { kind: "unsupported-language"; file: string; message: string }
   | { kind: "file-access-error"; file: string; message: string }
   | { kind: "validation-error"; message: string }
@@ -93,7 +101,10 @@ export type ConfidenceMode = "semantic" | "structural" | "heuristic" | "unavaila
 
 export interface OutlineData {
   name: string;
+  /** Common structural search category. */
   kind: string;
+  /** Source-language declaration kind, separate from common search category. */
+  nativeKind?: string;
   /** Exact 1-based start of the declaration name token, when known. */
   nameAnchor?: SymbolAnchor;
   /** Exclusive 1-based end of a verified literal name span, when known. */
@@ -156,6 +167,12 @@ export interface FileEdit {
 /** A document-state precondition established when semantic edits are normalized. */
 export type DocumentEditPrecondition =
   | { file: string; kind: "open-document-version"; version: number }
+  | {
+      file: string;
+      kind: "open-document-content";
+      version: number;
+      fingerprint: string;
+    }
   | { file: string; kind: "disk-content" };
 
 /**
@@ -257,5 +274,10 @@ export interface CalleesData {
 /** A single call-site match with name and start line. */
 export interface CallSite {
   name: string;
+  /** 1-based UTF-16 start position of the written callee expression. */
   startLine: number;
+  startCharacter: number;
+  /** Exclusive 1-based UTF-16 end position of the captured source expression. */
+  endLine: number;
+  endCharacter: number;
 }

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

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-core",
-  "version": "10.0.0",
+  "version": "11.0.0",
   "description": "Shared settings, configuration, reporting, and session infrastructure",
   "license": "MIT",
   "repository": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-lsp",
-  "version": "10.0.0",
+  "version": "11.0.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": "10.0.0",
-    "@mrclrchtr/supi-core": "10.0.0"
+    "@mrclrchtr/supi-code-runtime": "11.0.0",
+    "@mrclrchtr/supi-core": "11.0.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",

package/src/api.ts

@@ -91,6 +91,7 @@ export type {
   ProcessCrashRecoveryOutcome,
   ProcessCrashRecoveryReport,
   RecoverDiagnosticsResult,
+  RoutedMutationDocumentSnapshot,
   RoutedMutationResponse,
   SemanticReadinessResult,
   StartupRetryEntry,

package/src/client/client-diagnostic-host.ts

@@ -1,3 +1,4 @@
+import type { CFamilyFileAssociationResolver } from "@mrclrchtr/supi-code-runtime/api";
 import type { DiagnosticRequestAdapter } from "./client-diagnostic-request.ts";
 import type { NormalizedDocumentSync } from "./client-document-sync.ts";
 
@@ -7,6 +8,8 @@ export interface ClientDiagnosticsHost {
   server: string;
   /** Absolute workspace root, for debug-telemetry identity. */
   cwd?: string;
+  /** Immutable workspace association snapshot used for didOpen document IDs. */
+  fileAssociations?: CFamilyFileAssociationResolver;
   isOperational(): boolean;
   /** Native pull and server-specific request evidence share this priority adapter. */
   diagnosticRequestAdapter: DiagnosticRequestAdapter;

package/src/client/client-diagnostics.ts

@@ -51,6 +51,7 @@ import { SemanticInputRequestRetryGuard } from "./client-request-enrollment.ts";
 import {
   SemanticInputBarrier,
   type SemanticInputDocument,
+  type SemanticInputRevision,
   type SemanticInputSnapshot,
   type SemanticInputUpdate,
 } from "./client-semantic-input-barrier.ts";
@@ -156,10 +157,10 @@ export class ClientDiagnostics {
 
   /** Fail closed when a semantic request observes a changed input generation. */
   assertSemanticInputsCurrent(
-    snapshot: SemanticInputSnapshot,
+    snapshot: SemanticInputRevision,
     control?: CodeRequestControl,
     contentOverrides?: ReadonlyMap<string, string>,
-  ): Promise<void> {
+  ): Promise<SemanticInputSnapshot> {
     throwIfCodeRequestInterrupted(control);
     return this.#inputBarrier.assertCurrent(snapshot, control, contentOverrides);
   }
@@ -168,6 +169,7 @@ export class ClientDiagnostics {
     return Array.from(this.#openDocs, ([uri, document]) => ({
       uri,
       filePath: uriToFile(uri),
+      version: document.version,
       content: document.content,
       contentFingerprint: document.contentFingerprint,
     }));
@@ -293,7 +295,7 @@ export class ClientDiagnostics {
     this.#cancelDiagnosticRequest(uri);
     this.#advanceInputRevision(false, false, "enrollment");
 
-    const languageId = detectLanguageId(filePath);
+    const languageId = detectLanguageId(filePath, this.host.fileAssociations);
     this.#waiters.cancelSettle();
     // A didOpen is a synchronization: pushes the server sends after it are
     // responses to the open and can become fresh evidence (ADR 0020).
@@ -797,7 +799,7 @@ export class ClientDiagnostics {
 
   async #verifyDiagnosticInputs(options: {
     result: CodeQueryResult<Diagnostic[]>;
-    snapshot: SemanticInputSnapshot;
+    snapshot: SemanticInputRevision;
     control: CodeRequestControl | undefined;
     contentOverrides: ReadonlyMap<string, string> | undefined;
     uri: string;

package/src/client/client-request-enrollment.ts

@@ -3,30 +3,61 @@ import {
   type SemanticInputSynchronizationError,
 } from "./client-semantic-input-errors.ts";
 
-const MAX_REQUEST_ENROLLMENT_RETRIES = 1;
+const MAX_REQUEST_RETRIES = 1;
+const CONTENT_MODIFIED_ERROR_CODE = -32_801;
 
-/** A request-level enrollment retry decision owned by one request attempt. */
-export type RequestEnrollmentRetryDecision =
-  | { readonly kind: "retry" }
-  | { readonly kind: "stop"; readonly error: unknown };
+/** Reason that permits one request retry. */
+export type SemanticInputRequestRetryReason = "content-modified" | "enrollment";
+
+/** A request-level retry decision owned by one attempt. */
+export type SemanticInputRequestRetryDecision =
+  | { readonly kind: "retry"; readonly reason: SemanticInputRequestRetryReason }
+  | {
+      readonly kind: "stop";
+      readonly error: unknown;
+      readonly reason?: SemanticInputRequestRetryReason;
+    };
 
 /** Look up the current input change after a failed request revision. */
 export type SemanticInputChangeLookup = (
   revision: number,
 ) => SemanticInputSynchronizationError | undefined;
 
+/** Optional request retry policies. ContentModified retries stay off by default. */
+export interface SemanticInputRequestRetryPolicy {
+  readonly retryContentModified?: boolean;
+  /** Retain a verified revision across document enrollment and a follow-up request. */
+  readonly inputRevision?: number;
+}
+
+function isContentModifiedError(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    (error as { code?: unknown }).code === CONTENT_MODIFIED_ERROR_CODE
+  );
+}
+
 /**
- * Keep one semantic or diagnostic request's enrollment retry policy cohesive.
+ * Keep one LSP request's input retry policy in one place.
  *
- * 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.
+ * Synchronization passes have their own rejoin budget. This guard owns one
+ * shared request retry budget and a protected revision used to classify later
+ * changes. A caller can retain an earlier verified revision across enrollment.
+ * Protocol retries are disabled unless the caller opts in.
  */
 export class SemanticInputRequestRetryGuard {
   #requestRetries = 0;
-  #firstFailedRevision: number | undefined;
+  #protectedRevision: number | undefined;
+  #retryReason: SemanticInputRequestRetryReason | undefined;
 
-  constructor(private readonly currentChangeSince: SemanticInputChangeLookup) {}
+  constructor(
+    private readonly currentChangeSince: SemanticInputChangeLookup,
+    private readonly policy: SemanticInputRequestRetryPolicy = {},
+  ) {
+    this.#protectedRevision = policy.inputRevision;
+  }
 
   /** Number of request-level retries permitted for this request so far. */
   get retryCount(): number {
@@ -38,6 +69,11 @@ export class SemanticInputRequestRetryGuard {
     return this.#requestRetries > 0;
   }
 
+  /** Cause of the retry already used by this request, if any. */
+  get retryReason(): SemanticInputRequestRetryReason | undefined {
+    return this.#retryReason;
+  }
+
   /** Throw the current non-enrollment cause when it blocks a retry. */
   assertCurrent(): void {
     const blockingChange = this.#getBlockingChange();
@@ -45,31 +81,39 @@ export class SemanticInputRequestRetryGuard {
   }
 
   /** 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 };
-    }
+  decide(error: unknown, inputRevision: number | undefined): SemanticInputRequestRetryDecision {
+    const reason = this.#getRetryReason(error);
+    if (!reason) return { kind: "stop", error };
 
-    if (this.#firstFailedRevision !== undefined) {
+    if (this.#protectedRevision !== undefined) {
       const blockingChange = this.#getBlockingChange();
       if (blockingChange) return { kind: "stop", error: blockingChange };
     }
     if (inputRevision === undefined) return { kind: "stop", error };
 
-    this.#firstFailedRevision ??= inputRevision;
+    this.#protectedRevision ??= inputRevision;
     const blockingChange = this.#getBlockingChange();
     if (blockingChange) return { kind: "stop", error: blockingChange };
-    if (this.#requestRetries >= MAX_REQUEST_ENROLLMENT_RETRIES) {
-      return { kind: "stop", error };
+    if (this.#requestRetries >= MAX_REQUEST_RETRIES) {
+      return { kind: "stop", error, reason };
     }
 
     this.#requestRetries++;
-    return { kind: "retry" };
+    this.#retryReason ??= reason;
+    return { kind: "retry", reason };
+  }
+
+  #getRetryReason(error: unknown): SemanticInputRequestRetryReason | undefined {
+    if (isSemanticInputEnrollmentError(error)) return "enrollment";
+    if (this.policy.retryContentModified && isContentModifiedError(error)) {
+      return "content-modified";
+    }
+    return undefined;
   }
 
   #getBlockingChange(): SemanticInputSynchronizationError | undefined {
-    if (this.#firstFailedRevision === undefined) return undefined;
-    const currentChange = this.currentChangeSince(this.#firstFailedRevision);
+    if (this.#protectedRevision === undefined) return undefined;
+    const currentChange = this.currentChangeSince(this.#protectedRevision);
     return currentChange?.changeKind === "enrollment" ? undefined : currentChange;
   }
 }

package/src/client/client-semantic-input-barrier.ts

@@ -21,10 +21,19 @@ const DEFAULT_MAX_CONCURRENT_READS = 16;
 export interface SemanticInputDocument {
   readonly uri: string;
   readonly filePath: string;
+  readonly version: number;
   readonly content: string;
   readonly contentFingerprint: string;
 }
 
+/** One open buffer and disk fingerprint verified by an input synchronization pass. */
+export interface SemanticInputDocumentSnapshot {
+  readonly filePath: string;
+  readonly version: number;
+  readonly contentFingerprint: string;
+  readonly diskContentFingerprint: string;
+}
+
 /** One open document update selected by the barrier after a full read. */
 export interface SemanticInputUpdate {
   readonly document: SemanticInputDocument;
@@ -48,11 +57,16 @@ export interface SemanticInputBarrierOptions {
   readonly readFile?: SemanticInputFileReader;
 }
 
-/** Revision token returned by one completed input synchronization pass. */
-export interface SemanticInputSnapshot {
+/** Revision token used to check one semantic input generation. */
+export interface SemanticInputRevision {
   readonly revision: number;
 }
 
+/** Verified inputs returned by one complete synchronization pass. */
+export interface SemanticInputSnapshot extends SemanticInputRevision {
+  readonly documents: readonly SemanticInputDocumentSnapshot[];
+}
+
 interface OpenDocumentRead {
   readonly document: SemanticInputDocument;
   readonly result:
@@ -150,10 +164,10 @@ export class SemanticInputBarrier {
 
   /** Recheck the full input set after a semantic request completes. */
   async assertCurrent(
-    snapshot: SemanticInputSnapshot,
+    snapshot: SemanticInputRevision,
     control?: CodeRequestControl,
     contentOverrides?: ReadonlyMap<string, string>,
-  ): Promise<void> {
+  ): Promise<SemanticInputSnapshot> {
     if (!this.#host.isOperational()) {
       throw new Error("Semantic input synchronization is unavailable because the client stopped.");
     }
@@ -176,6 +190,7 @@ export class SemanticInputBarrier {
         )
       );
     }
+    return current;
   }
 
   /** Return the current typed input change after a revision, when present. */
@@ -305,7 +320,24 @@ export class SemanticInputBarrier {
     // resulting generation as owned by this completed pass so a late caller
     // can join it instead of starting a redundant read pass.
     pending.generation = this.#revision;
-    return { revision: this.#revision };
+    const currentDocuments = this.#host.getOpenDocuments();
+    const diskFingerprints = new Map(plan.observedDiskFingerprints);
+    return {
+      revision: this.#revision,
+      documents: currentDocuments.flatMap((document) => {
+        const diskContentFingerprint = diskFingerprints.get(document.uri);
+        return diskContentFingerprint === undefined
+          ? []
+          : [
+              {
+                filePath: document.filePath,
+                version: document.version,
+                contentFingerprint: document.contentFingerprint,
+                diskContentFingerprint,
+              },
+            ];
+      }),
+    };
   }
 
   #assertPendingCanRun(pending: PendingSynchronization): void {