@mrclrchtr/supi-code-intelligence 4.9.0 → 5.0.0

package/node_modules/@mrclrchtr/supi-tree-sitter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-tree-sitter",
-  "version": "4.9.0",
+  "version": "5.0.0",
   "description": "Structural AST analysis for SuPi code intelligence",
   "license": "MIT",
   "repository": {
@@ -27,19 +27,22 @@
   "type": "module",
   "files": [
     "src/**/*.ts",
+    "src/**/*.mjs",
     "src/**/*.json",
     "resources",
     "scripts/*.mjs",
     "!__tests__"
   ],
   "dependencies": {
+    "jiti": "^2.7.0",
     "web-tree-sitter": "^0.26.8",
-    "@mrclrchtr/supi-code-runtime": "4.9.0",
-    "@mrclrchtr/supi-core": "4.9.0"
+    "@mrclrchtr/supi-code-runtime": "5.0.0",
+    "@mrclrchtr/supi-core": "5.0.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",
     "@mrclrchtr/supi-core",
+    "jiti",
     "web-tree-sitter"
   ],
   "main": "src/api.ts",
@@ -49,6 +52,7 @@
     "./provider/tree-sitter-provider": "./src/provider/tree-sitter-provider.ts"
   },
   "scripts": {
+    "bench:structural": "vitest bench __tests__/benchmark/structural-baseline.bench.ts --run",
     "vendor:wasm": "node scripts/vendor-wasm.mjs",
     "check:wasm": "node scripts/vendor-wasm.mjs --check",
     "generate:kotlin-wasm": "node scripts/generate-kotlin-wasm.mjs",

package/node_modules/@mrclrchtr/supi-tree-sitter/resources/grammars/kotlin/tree-sitter-kotlin.wasm.json

@@ -6,7 +6,7 @@
     "releaseAsset": "https://github.com/fwcd/tree-sitter-kotlin/releases/download/0.3.8/tree-sitter-kotlin.wasm"
   },
   "generatedWith": {
-    "treeSitterCli": "0.26.11"
+    "treeSitterCli": "0.26.12"
   },
   "sha256": "e08447e36ad5d86f39f91f13defce0636aea1490b8d65dafde6fa72649422061"
 }

package/node_modules/@mrclrchtr/supi-tree-sitter/resources/grammars/sql/tree-sitter-sql.wasm.json

@@ -5,7 +5,7 @@
     "repository": "https://github.com/derekstride/tree-sitter-sql"
   },
   "generatedWith": {
-    "treeSitterCli": "0.26.11"
+    "treeSitterCli": "0.26.12"
   },
   "sha256": "9b93a15dc3eade66df4347731f2687b939daf987c8382660d6118e863604ab09",
   "trust": {

package/node_modules/@mrclrchtr/supi-tree-sitter/src/api.ts

@@ -14,7 +14,6 @@ export {
 } from "./language.ts";
 export type { StructuralSearchOperation } from "./operation-support.ts";
 export { getStructuralSearchSupportedExtensions } from "./operation-support.ts";
-export { TreeSitterRuntime } from "./session/runtime.ts";
 export type {
   TsControllerState,
   TsStartResult,
@@ -23,14 +22,6 @@ export { TreeSitterRuntimeController } from "./session/runtime-controller.ts";
 export { getSessionTreeSitterService } from "./session/service-registry.ts";
 export { createTreeSitterSession } from "./session/session.ts";
 
-// Structural extraction services (consumed by supi-code-intelligence tool execution)
-export { extractCallSites } from "./tool/call-sites.ts";
-export { lookupCalleesAt } from "./tool/callees.ts";
-export { extractExports } from "./tool/exports.ts";
-export { extractImports } from "./tool/imports.ts";
-export { lookupNodeAt } from "./tool/node-at.ts";
-export { collectOutline } from "./tool/outline.ts";
-
 // Shared types
 export type {
   CalleesAtResult,

package/node_modules/@mrclrchtr/supi-tree-sitter/src/index.ts

@@ -15,7 +15,6 @@ export type { StructuralSearchOperation } from "./operation-support.ts";
 export { getStructuralSearchSupportedExtensions } from "./operation-support.ts";
 // Provider implementation
 export { createTreeSitterProvider } from "./provider/tree-sitter-provider.ts";
-export { TreeSitterRuntime } from "./session/runtime.ts";
 export type {
   TsControllerState,
   TsStartResult,
@@ -23,13 +22,6 @@ export type {
 export { TreeSitterRuntimeController } from "./session/runtime-controller.ts";
 export { getSessionTreeSitterService } from "./session/service-registry.ts";
 export { createTreeSitterSession } from "./session/session.ts";
-// Structural extraction services (consumed by supi-code-intelligence tool execution)
-export { extractCallSites } from "./tool/call-sites.ts";
-export { lookupCalleesAt } from "./tool/callees.ts";
-export { extractExports } from "./tool/exports.ts";
-export { extractImports } from "./tool/imports.ts";
-export { lookupNodeAt } from "./tool/node-at.ts";
-export { collectOutline } from "./tool/outline.ts";
 // Shared types
 export type {
   CalleesAtResult,

package/node_modules/@mrclrchtr/supi-tree-sitter/src/provider/tree-sitter-provider.ts

@@ -29,33 +29,37 @@ import type {
  */
 export function createTreeSitterProvider(service: TreeSitterService): StructuralProvider {
   return {
-    async calleesAt(file, line, character, depth?) {
-      const result = await service.calleesAt(file, line, character, depth);
+    async calleesAt(file, line, character, depthOrOptions?) {
+      const result = await service.calleesAt(file, line, character, depthOrOptions);
       return mapTreeSitterResult(result, mapCalleesAtResult);
     },
 
-    async exports(file) {
-      const result = await service.exports(file);
+    async exports(file, control?) {
+      const result = control ? await service.exports(file, control) : await service.exports(file);
       return mapTreeSitterResult(result, mapExportRecords);
     },
 
-    async outline(file) {
-      const result = await service.outline(file);
+    async outline(file, control?) {
+      const result = control ? await service.outline(file, control) : await service.outline(file);
       return mapTreeSitterResult(result, mapOutlineItems);
     },
 
-    async imports(file) {
-      const result = await service.imports(file);
+    async imports(file, control?) {
+      const result = control ? await service.imports(file, control) : await service.imports(file);
       return mapTreeSitterResult(result, mapImportRecords);
     },
 
-    async nodeAt(file, line, character) {
-      const result = await service.nodeAt(file, line, character);
+    async nodeAt(file, line, character, control?) {
+      const result = control
+        ? await service.nodeAt(file, line, character, control)
+        : await service.nodeAt(file, line, character);
       return mapTreeSitterResult(result, mapNodeAtResult);
     },
 
-    async callSites(file) {
-      const result = await service.callSites(file);
+    async callSites(file, control?) {
+      const result = control
+        ? await service.callSites(file, control)
+        : await service.callSites(file);
       return mapTreeSitterResult(result, mapCallSites);
     },
   };

package/node_modules/@mrclrchtr/supi-tree-sitter/src/session/runtime-controller.ts

@@ -1,22 +1,14 @@
-// Tree-sitter session runtime controller — pi-independent lifecycle for structural analysis.
-//
-// This controller owns runtime creation/disposal for one cwd:
-//   - Creates and disposes the TreeSitterRuntime
-//   - Creates TreeSitterService from the runtime
-//   - Publishes SessionTreeSitterService state through the existing registry
-//   - Exposes ready/unavailable lifecycle for umbrella adapter consumption
+// Tree-sitter lifecycle controller — owns one Structural Worker for one cwd.
 
+import { fileURLToPath } from "node:url";
 import type { WorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
-import type { SessionTreeSitterService, TreeSitterService } from "../types.ts";
-import { TreeSitterRuntime } from "./runtime.ts";
+import type { SessionTreeSitterService, TreeSitterService, TreeSitterSession } from "../types.ts";
 import {
   registerTreeSitterCapabilities,
   unregisterTreeSitterCapabilities,
 } from "./runtime-registration.ts";
 import { clearSessionTreeSitterService, setSessionTreeSitterService } from "./service-registry.ts";
-import { createTreeSitterService } from "./session.ts";
-
-// ── Types ─────────────────────────────────────────────────────────────
+import { createTreeSitterSession } from "./session.ts";
 
 /** Starting state before or after shutdown. */
 export type TsControllerState = TsControllerInitial | TsControllerReady | TsControllerUnavailable;
@@ -27,7 +19,7 @@ interface TsControllerInitial {
 
 interface TsControllerReady {
   kind: "ready";
-  runtime: TreeSitterRuntime;
+  session: TreeSitterSession;
   service: TreeSitterService;
 }
 
@@ -39,119 +31,105 @@ interface TsControllerUnavailable {
 /** Result type from {@link TreeSitterRuntimeController.start}. */
 export type TsStartResult = { kind: "ready" } | { kind: "unavailable"; reason: string };
 
-// ── Controller ────────────────────────────────────────────────────────
-
-/**
- * Pi-independent Tree-sitter session lifecycle controller.
- *
- * Use this in the umbrella extension (supi-code-intelligence) instead of
- * reaching into substrate extension internals.
- *
- * @example
- * ```ts
- * const controller = new TreeSitterRuntimeController(cwd);
- * const result = await controller.start();
- * if (result.kind === "ready") {
- *   // use controller.service, controller.runtime
- * }
- * // later
- * await controller.shutdown();
- * ```
- */
+/** Pi-independent lifecycle for one shared workspace Structural Worker. */
 export class TreeSitterRuntimeController {
   readonly #cwd: string;
-  #state: TsControllerState;
+  #state: TsControllerState = { kind: "initial" };
   #runtime: WorkspaceRuntime | null;
+  #pendingSession: TreeSitterSession | null = null;
+  #generation = 0;
+  #transition = Promise.resolve();
 
   constructor(cwd: string, runtime?: WorkspaceRuntime) {
     this.#cwd = cwd;
-    this.#state = { kind: "initial" };
     this.#runtime = runtime ?? null;
   }
 
-  /** The workspace cwd this controller was created for. */
   get cwd(): string {
     return this.#cwd;
   }
 
-  /** Current controller state. */
   get kind(): TsControllerState["kind"] {
     return this.#state.kind;
   }
 
-  /** The TreeSitterService (structural operations), available when state is "ready". */
   get service(): SessionTreeSitterService | null {
     return this.#state.kind === "ready" ? this.#state.service : null;
   }
 
-  /** The TreeSitterRuntime, available when state is "ready". */
-  get runtime(): TreeSitterRuntime | null {
-    return this.#state.kind === "ready" ? this.#state.runtime : null;
-  }
-
-  /** Attach a WorkspaceRuntime for capability registration. */
   setRuntime(runtime: WorkspaceRuntime): void {
     this.#runtime = runtime;
   }
 
-  /**
-   * Start the Tree-sitter session.
-   *
-   * Creates the runtime, wires the service, and publishes state
-   * into the shared registries. Validates that WASM initialization
-   * succeeds, returning `unavailable` if it fails.
-   */
-  async start(): Promise<TsStartResult> {
-    // Restart safety: dispose any existing runtime
-    if (this.#state.kind === "ready") {
-      this.#state.runtime.dispose();
-      if (this.#runtime) unregisterTreeSitterCapabilities(this.#runtime, this.#cwd);
-      clearSessionTreeSitterService(this.#cwd);
-    }
+  /** Start and validate one Structural Worker before capability publication. */
+  start(): Promise<TsStartResult> {
+    const generation = ++this.#generation;
+    let result: TsStartResult = supersededStart();
+    const transition = this.#transition.then(async () => {
+      if (generation !== this.#generation) return;
+      result = await this.#startGeneration(generation);
+    });
+    this.#transition = transition.catch(() => undefined);
+    return transition.then(() => result);
+  }
 
+  /** Stop publication, terminate owned Workers, and await their exit. */
+  async shutdown(): Promise<void> {
+    const generation = ++this.#generation;
+    const sessions = this.#takeOwnedSessions();
+    await Promise.all([...sessions].map((session) => session.dispose()));
+    if (generation === this.#generation) this.#state = { kind: "initial" };
+  }
+
+  async #startGeneration(generation: number): Promise<TsStartResult> {
+    const previous = this.#takeOwnedSessions();
+    await Promise.all([...previous].map((session) => session.dispose()));
+    if (generation !== this.#generation) return supersededStart();
     this.#state = { kind: "unavailable", reason: "Initializing Tree-sitter" };
 
+    const session = createTreeSitterSession(this.#cwd);
+    this.#pendingSession = session;
     try {
-      const treeSitterRuntime = new TreeSitterRuntime(this.#cwd);
-
-      // Probe WASM initialization by loading the JavaScript grammar
-      // (always vendored). This catches missing web-tree-sitter or
-      // corrupted WASM early rather than deferring to first tool use.
-      await treeSitterRuntime.ensureGrammarParser("javascript");
-
-      const service = createTreeSitterService(treeSitterRuntime);
-      setSessionTreeSitterService(this.#cwd, service);
-
-      if (this.#runtime) {
-        registerTreeSitterCapabilities(this.#runtime, this.#cwd, service);
+      const probe = await session.canParse(fileURLToPath(import.meta.url));
+      if (probe.kind !== "success") throw new Error(probe.message);
+      if (generation !== this.#generation || this.#pendingSession !== session) {
+        return supersededStart();
       }
-
-      this.#state = { kind: "ready", runtime: treeSitterRuntime, service };
+      setSessionTreeSitterService(this.#cwd, session);
+      if (this.#runtime) registerTreeSitterCapabilities(this.#runtime, this.#cwd, session);
+      this.#pendingSession = null;
+      this.#state = { kind: "ready", session, service: session };
       return { kind: "ready" };
-    } catch (error: unknown) {
+    } catch (error) {
+      if (generation !== this.#generation || this.#pendingSession !== session) {
+        return supersededStart();
+      }
+      await session.dispose();
+      this.#pendingSession = null;
       const reason = error instanceof Error ? error.message : String(error);
+      await this.#clearPublishedSession();
       this.#state = { kind: "unavailable", reason };
-      clearSessionTreeSitterService(this.#cwd);
       return { kind: "unavailable", reason };
     }
   }
 
-  /**
-   * Shut down the Tree-sitter session.
-   *
-   * Disposes the runtime and clears all published state.
-   */
-  async shutdown(): Promise<void> {
-    if (this.#runtime && this.#cwd) {
-      unregisterTreeSitterCapabilities(this.#runtime, this.#cwd);
-    }
+  async #clearPublishedSession(): Promise<void> {
+    const sessions = this.#takeOwnedSessions();
+    await Promise.all([...sessions].map((session) => session.dispose()));
+  }
 
+  #takeOwnedSessions(): Set<TreeSitterSession> {
+    if (this.#runtime) unregisterTreeSitterCapabilities(this.#runtime, this.#cwd);
     clearSessionTreeSitterService(this.#cwd);
-
-    if (this.#state.kind === "ready") {
-      this.#state.runtime.dispose();
-    }
-
+    const sessions = new Set<TreeSitterSession>();
+    if (this.#pendingSession) sessions.add(this.#pendingSession);
+    if (this.#state.kind === "ready") sessions.add(this.#state.session);
+    this.#pendingSession = null;
     this.#state = { kind: "initial" };
+    return sessions;
   }
 }
+
+function supersededStart(): TsStartResult {
+  return { kind: "unavailable", reason: "Startup superseded" };
+}

package/node_modules/@mrclrchtr/supi-tree-sitter/src/session/session.ts

@@ -1,15 +1,6 @@
-// Session factory — creates runtime-backed Tree-sitter services and owned sessions.
+// Session factory — creates asynchronous Structural Worker proxies and owned sessions.
 
-import { detectGrammar } from "../language.ts";
-import { supportsGrammarOperation } from "../operation-support.ts";
-import {
-  extractCallSites,
-  extractExports,
-  extractImports,
-  extractOutline,
-  lookupCalleesAt,
-  lookupNodeAt,
-} from "../tool/structure.ts";
+import type { CodeRequestControl } from "@mrclrchtr/supi-code-runtime/api";
 import type {
   CalleesAtResult,
   CallSiteMatch,
@@ -22,108 +13,69 @@ import type {
   TreeSitterService,
   TreeSitterSession,
 } from "../types.ts";
-import { TreeSitterRuntime } from "./runtime.ts";
+import {
+  StructuralWorkerClient,
+  type StructuralWorkerFactory,
+} from "./structural-worker-client.ts";
 
-/** Create a runtime-backed structural service without taking ownership of disposal. */
-export function createTreeSitterService(runtime: TreeSitterRuntime): TreeSitterService {
+/** Create one asynchronous service backed by an owned Structural Worker client. */
+export function createTreeSitterService(client: StructuralWorkerClient): TreeSitterService {
   return {
-    async canParse(file: string) {
-      const result = await runtime.parseFile(file);
-      if (result.kind !== "success") return result;
-      const { resolvedPath, grammarId, tree } = result.data;
-      try {
-        return {
-          kind: "success",
-          data: { file: resolvedPath, language: grammarId },
-        };
-      } finally {
-        tree.delete();
-      }
+    canParse(file, control) {
+      return execute(client, { operation: "canParse", file }, control);
     },
-
-    async query(file: string, queryString: string): Promise<TreeSitterResult<QueryCapture[]>> {
-      return runtime.queryFile(file, queryString);
+    query(file, query, control) {
+      return execute<QueryCapture[]>(client, { operation: "query", file, query }, control);
     },
-
-    async outline(file: string): Promise<TreeSitterResult<OutlineItem[]>> {
-      const grammarId = detectGrammar(file);
-      if (grammarId && !supportsGrammarOperation(grammarId, "outline")) {
-        return {
-          kind: "unsupported-language",
-          file,
-          message: `outline is not supported for ${grammarId} files`,
-        };
-      }
-      const parseResult = await runtime.parseFile(file);
-      if (parseResult.kind !== "success") return parseResult;
-      const { tree, source } = parseResult.data;
-      try {
-        const items = extractOutline(tree.rootNode, source);
-        return { kind: "success", data: items };
-      } finally {
-        tree.delete();
-      }
+    outline(file, control) {
+      return execute<OutlineItem[]>(client, { operation: "outline", file }, control);
     },
-
-    async imports(file: string): Promise<TreeSitterResult<ImportRecord[]>> {
-      const grammarId = detectGrammar(file);
-      if (grammarId && !supportsGrammarOperation(grammarId, "imports")) {
-        return {
-          kind: "unsupported-language",
-          file,
-          message: `imports is not supported for ${grammarId} files`,
-        };
-      }
-      return extractImports(runtime, file);
+    imports(file, control) {
+      return execute<ImportRecord[]>(client, { operation: "imports", file }, control);
     },
-
-    async exports(file: string): Promise<TreeSitterResult<ExportRecord[]>> {
-      const grammarId = detectGrammar(file);
-      if (grammarId && !supportsGrammarOperation(grammarId, "exports")) {
-        return {
-          kind: "unsupported-language",
-          file,
-          message: `exports is not supported for ${grammarId} files`,
-        };
-      }
-      return extractExports(runtime, file);
+    exports(file, control) {
+      return execute<ExportRecord[]>(client, { operation: "exports", file }, control);
     },
-
-    async nodeAt(
-      file: string,
-      line: number,
-      character: number,
-    ): Promise<TreeSitterResult<NodeAtResult>> {
-      return lookupNodeAt(runtime, file, line, character);
+    nodeAt(file, line, character, control) {
+      return execute<NodeAtResult>(client, { operation: "nodeAt", file, line, character }, control);
     },
-
-    async calleesAt(
-      file: string,
-      line: number,
-      character: number,
-      depth?: "direct" | "deep",
-    ): Promise<TreeSitterResult<CalleesAtResult>> {
-      return lookupCalleesAt(runtime, file, line, character, depth);
+    calleesAt(file, line, character, depthOrOptions) {
+      const depth = typeof depthOrOptions === "string" ? depthOrOptions : depthOrOptions?.depth;
+      const control = typeof depthOrOptions === "string" ? undefined : depthOrOptions?.control;
+      return execute<CalleesAtResult>(
+        client,
+        { operation: "calleesAt", file, line, character, depth },
+        control,
+      );
     },
-
-    async callSites(file: string): Promise<TreeSitterResult<CallSiteMatch[]>> {
-      return extractCallSites(runtime, file);
+    callSites(file, control) {
+      return execute<CallSiteMatch[]>(client, { operation: "callSites", file }, control);
     },
   };
 }
 
 /**
- * Create a new Tree-sitter session bound to the given working directory.
- * The session owns parser/grammar reuse and must be disposed when done.
+ * Create one Tree-sitter session bound to a working directory.
+ * Await disposal to prove that its Structural Worker has terminated.
  */
-export function createTreeSitterSession(cwd: string): TreeSitterSession {
-  const runtime = new TreeSitterRuntime(cwd);
-  const service = createTreeSitterService(runtime);
-
+export function createTreeSitterSession(
+  cwd: string,
+  options: { readonly workerFactory?: StructuralWorkerFactory } = {},
+): TreeSitterSession {
+  const client = new StructuralWorkerClient(cwd, options.workerFactory);
+  const service = createTreeSitterService(client);
   return {
     ...service,
     dispose() {
-      runtime.dispose();
+      return client.dispose();
     },
   };
 }
+
+function execute<T>(
+  client: StructuralWorkerClient,
+  input: Parameters<StructuralWorkerClient["execute"]>[0],
+  control?: CodeRequestControl,
+): Promise<TreeSitterResult<T>> {
+  return control ? client.execute<T>(input, control) : client.execute<T>(input);
+}