@mrclrchtr/supi-tree-sitter 10.0.0 → 11.0.0

package/src/worker/process-host.mjs

@@ -11,44 +11,63 @@ if (
   throw new Error("Structural Worker process received invalid startup data");
 }
 
-const worker = new Worker(new URL("./bootstrap.mjs", import.meta.url), {
-  execArgv: [],
-  workerData: { cwd, generation },
-});
 const cancellationFlags = new Map();
+let worker = null;
 let closing = false;
 let workerExited = false;
 
-worker.on("message", (message) => {
-  if (message.kind === "terminal") cancellationFlags.delete(message.requestId);
-  send({ channel: "supi-tree-sitter-worker", message });
-});
-worker.on("error", (error) => {
-  send(
-    {
-      channel: "supi-tree-sitter-worker",
-      message: { kind: "worker-error", message: error.message },
-    },
-    () => stopWorker(1),
-  );
-});
-worker.on("exit", (code) => {
-  workerExited = true;
-  cancellationFlags.clear();
-  process.exitCode = code === 0 ? 1 : code;
-  disconnect();
-});
-
 process.on("message", (value) => {
   if (!isParentChannel(value)) {
     stopWorker(1);
     return;
   }
+  if (!worker) {
+    if (!isInitialization(value.message)) {
+      stopWorker(1);
+      return;
+    }
+    startWorker(value.message);
+    return;
+  }
+  if (value.message.kind === "initialize") {
+    stopWorker(1);
+    return;
+  }
   forwardToWorker(value.message);
 });
 process.on("disconnect", () => stopWorker());
 if (!process.connected) stopWorker();
 
+function startWorker(initialization) {
+  worker = new Worker(new URL("./bootstrap.mjs", import.meta.url), {
+    execArgv: [],
+    workerData: {
+      cwd,
+      generation,
+      fileAssociations: initialization.fileAssociations,
+    },
+  });
+  worker.on("message", (message) => {
+    if (message.kind === "terminal") cancellationFlags.delete(message.requestId);
+    send({ channel: "supi-tree-sitter-worker", message });
+  });
+  worker.on("error", (error) => {
+    send(
+      {
+        channel: "supi-tree-sitter-worker",
+        message: { kind: "worker-error", message: error.message },
+      },
+      () => stopWorker(1),
+    );
+  });
+  worker.on("exit", (code) => {
+    workerExited = true;
+    cancellationFlags.clear();
+    process.exitCode = code === 0 ? 1 : code;
+    disconnect();
+  });
+}
+
 function forwardToWorker(message) {
   if (!message || typeof message !== "object") {
     throw new Error("Structural Worker process received an invalid message");
@@ -70,6 +89,20 @@ function forwardToWorker(message) {
   worker.postMessage(message);
 }
 
+function isInitialization(value) {
+  return (
+    value !== null &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    Object.keys(value).length === 5 &&
+    value.kind === "initialize" &&
+    value.version === 1 &&
+    value.generation === generation &&
+    value.cwd === cwd &&
+    Array.isArray(value.fileAssociations)
+  );
+}
+
 function isParentChannel(value) {
   return (
     value !== null &&
@@ -105,5 +138,9 @@ function stopWorker(exitCode) {
   closing = true;
   if (exitCode !== undefined) process.exitCode = exitCode;
   cancellationFlags.clear();
+  if (!worker) {
+    disconnect();
+    return;
+  }
   void worker.terminate().finally(disconnect);
 }

package/src/worker/runtime.ts

@@ -2,6 +2,7 @@
 // Tree-sitter runtime — parser management, parse, and query services.
 
 import * as path from "node:path";
+import type { CFamilyFileAssociationResolver } from "@mrclrchtr/supi-code-runtime/api";
 import { resolveToolPath } from "@mrclrchtr/supi-core/path";
 import type { Language, Parser, Tree } from "web-tree-sitter";
 import { detectGrammar, resolveGrammarWasmPath } from "../language.ts";
@@ -12,6 +13,11 @@ import {
   type StructuralTimingEvent,
   startStructuralTiming,
 } from "../session/structural-timing.ts";
+import {
+  collectSyntaxErrorRanges,
+  hasSyntaxErrors,
+  withSyntaxCompleteness,
+} from "../syntax-errors.ts";
 import type { GrammarId, QueryCapture, TreeSitterResult } from "../types.ts";
 import {
   ParsedFileReadError,
@@ -39,6 +45,7 @@ interface ParserEntry {
 const QUERY_PARSED_FILE = Symbol("query-parsed-file");
 
 interface ParsedQueryInput {
+  readonly file: string;
   readonly grammarId: GrammarId;
   readonly tree: Tree;
   readonly source: string;
@@ -66,8 +73,14 @@ export class TreeSitterRuntime {
   constructor(
     private cwd: string,
     private onTiming?: (event: StructuralTimingEvent) => void,
+    private readonly fileAssociations?: CFamilyFileAssociationResolver,
   ) {}
 
+  /** Resolve one file's grammar under this runtime's immutable association snapshot. */
+  getGrammarForFile(filePath: string): GrammarId | undefined {
+    return detectGrammar(filePath, this.fileAssociations);
+  }
+
   /** Ensure web-tree-sitter Parser is initialized. */
   private async ensureParserInit(): Promise<typeof import("web-tree-sitter")> {
     this.assertActive();
@@ -152,15 +165,21 @@ export class TreeSitterRuntime {
     filePath: string,
     control?: StructuralRequestControl,
   ): Promise<
-    TreeSitterResult<{
-      tree: Tree;
-      source: string;
-      resolvedPath: string;
-      grammarId: GrammarId;
-    }>
+    | {
+        kind: "success";
+        data: {
+          tree: Tree;
+          source: string;
+          resolvedPath: string;
+          grammarId: GrammarId;
+          hasSyntaxErrors: boolean;
+          errorRanges: ReturnType<typeof collectSyntaxErrorRanges>;
+        };
+      }
+    | Exclude<TreeSitterResult<never>, { kind: "success" | "partial" }>
   > {
     const resolvedPath = resolveToolPath(this.cwd, filePath);
-    const grammarId = detectGrammar(filePath);
+    const grammarId = detectGrammar(filePath, this.fileAssociations);
     if (!grammarId) {
       return {
         kind: "unsupported-language",
@@ -230,6 +249,8 @@ export class TreeSitterRuntime {
           source: parsed.source,
           resolvedPath: parsed.resolvedPath,
           grammarId: parsed.grammarId,
+          hasSyntaxErrors: hasSyntaxErrors(parsed.tree.rootNode),
+          errorRanges: collectSyntaxErrorRanges(parsed.tree.rootNode, parsed.source),
         },
       };
     } catch (err: unknown) {
@@ -281,7 +302,14 @@ export class TreeSitterRuntime {
 
     const { grammarId, tree, source } = parseResult.data;
     try {
-      return await this[QUERY_PARSED_FILE]({ grammarId, tree, source, queryString, control });
+      return await this[QUERY_PARSED_FILE]({
+        file: filePath,
+        grammarId,
+        tree,
+        source,
+        queryString,
+        control,
+      });
     } finally {
       tree.delete();
     }
@@ -289,7 +317,7 @@ export class TreeSitterRuntime {
 
   /** Execute a query against one caller-owned parsed tree without parsing again. */
   async [QUERY_PARSED_FILE](input: ParsedQueryInput): Promise<TreeSitterResult<QueryCapture[]>> {
-    const { grammarId, tree, source, queryString, control } = input;
+    const { file, grammarId, tree, source, queryString, control } = input;
     const validation = validateQueryString(queryString);
     if (validation) return validation;
 
@@ -344,7 +372,13 @@ export class TreeSitterRuntime {
         cache: execution.cache,
         finalPhase: "query-execution",
       });
-      return { kind: "success", data: execution.data };
+      return withSyntaxCompleteness({
+        data: execution.data,
+        file,
+        root: tree.rootNode,
+        source,
+        grammarId,
+      });
     } catch (err: unknown) {
       if (isStructuralRequestInterruption(err, control)) {
         finishStructuralTiming(timer, {

package/src/worker/service.ts

@@ -1,6 +1,6 @@
-import { detectGrammar } from "../language.ts";
 import { supportsGrammarOperation } from "../operation-support.ts";
 import type { StructuralWorkerOperation } from "../session/structural-worker-protocol.ts";
+import { withSyntaxCompleteness } from "../syntax-errors.ts";
 import { extractCallSites } from "../tool/call-sites.ts";
 import { lookupCalleesAt } from "../tool/callees.ts";
 import { extractExports } from "../tool/exports.ts";
@@ -68,16 +68,19 @@ export class StructuralWorkerService {
     file: string,
     control: StructuralRequestControl,
   ): Promise<TreeSitterResult<unknown>> {
-    const unsupported = unsupportedOperation(file, "outline");
+    const unsupported = unsupportedOperation(this.runtime, file, "outline");
     if (unsupported) return unsupported;
     const result = await this.runtime.parseFile(file, control);
     if (result.kind !== "success") return result;
     try {
       throwIfStructuralRequestInterrupted(control);
-      return {
-        kind: "success",
-        data: extractOutline(result.data.tree.rootNode, result.data.source),
-      };
+      return withSyntaxCompleteness({
+        data: extractOutline(result.data.tree.rootNode, result.data.source, result.data.grammarId),
+        file,
+        root: result.data.tree.rootNode,
+        source: result.data.source,
+        grammarId: result.data.grammarId,
+      });
     } finally {
       result.data.tree.delete();
     }
@@ -87,7 +90,7 @@ export class StructuralWorkerService {
     file: string,
     control: StructuralRequestControl,
   ): Promise<TreeSitterResult<unknown>> {
-    const unsupported = unsupportedOperation(file, "imports");
+    const unsupported = unsupportedOperation(this.runtime, file, "imports");
     return unsupported ?? extractImports(this.runtime, file, control);
   }
 
@@ -95,16 +98,17 @@ export class StructuralWorkerService {
     file: string,
     control: StructuralRequestControl,
   ): Promise<TreeSitterResult<unknown>> {
-    const unsupported = unsupportedOperation(file, "exports");
+    const unsupported = unsupportedOperation(this.runtime, file, "exports");
     return unsupported ?? extractExports(this.runtime, file, control);
   }
 }
 
 function unsupportedOperation(
+  runtime: TreeSitterRuntime,
   file: string,
   operation: "outline" | "imports" | "exports",
 ): TreeSitterResult<never> | null {
-  const grammarId = detectGrammar(file);
+  const grammarId = runtime.getGrammarForFile(file);
   if (!grammarId || supportsGrammarOperation(grammarId, operation)) return null;
   return {
     kind: "unsupported-language",

package/src/worker/worker-main.ts

@@ -1,5 +1,9 @@
 import type { MessagePort } from "node:worker_threads";
-import { isCodeRequestDeadlineError } from "@mrclrchtr/supi-code-runtime/api";
+import {
+  type CFamilyFileAssociationRule,
+  createCFamilyFileAssociationResolver,
+  isCodeRequestDeadlineError,
+} from "@mrclrchtr/supi-code-runtime/api";
 import type { StructuralTimingEvent } from "../session/structural-timing.ts";
 import { assertStructuralProtocolMessageSize } from "../session/structural-worker-message-size.ts";
 import {
@@ -18,6 +22,7 @@ import { StructuralWorkerService } from "./service.ts";
 interface WorkerBootstrapData {
   readonly cwd: string;
   readonly generation: number;
+  readonly fileAssociations?: readonly CFamilyFileAssociationRule[];
 }
 
 interface ActiveWorkerRequest {
@@ -36,7 +41,15 @@ export async function runStructuralWorker(
   parentPort: MessagePort,
   workerData: WorkerBootstrapData,
 ): Promise<void> {
-  const runtime = new TreeSitterRuntime(workerData.cwd, (event) => forwardObservation(event));
+  const associationResolver = createCFamilyFileAssociationResolver(
+    workerData.cwd,
+    workerData.fileAssociations ?? [],
+  );
+  const runtime = new TreeSitterRuntime(
+    workerData.cwd,
+    (event) => forwardObservation(event),
+    associationResolver,
+  );
   const service = new StructuralWorkerService(runtime);
   let active: ActiveWorkerRequest | null = null;