@mrclrchtr/supi-tree-sitter 4.8.0 → 4.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-tree-sitter",
-  "version": "4.8.0",
+  "version": "4.10.0",
   "description": "Structural AST analysis for SuPi code intelligence",
   "license": "MIT",
   "repository": {
@@ -34,8 +34,8 @@
   ],
   "dependencies": {
     "web-tree-sitter": "^0.26.8",
-    "@mrclrchtr/supi-code-runtime": "4.8.0",
-    "@mrclrchtr/supi-core": "4.8.0"
+    "@mrclrchtr/supi-code-runtime": "4.10.0",
+    "@mrclrchtr/supi-core": "4.10.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",
@@ -49,6 +49,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/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/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/src/session/runtime.ts

@@ -1,7 +1,9 @@
 // Tree-sitter runtime — parser management, parse, and query services.
 
+import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { startDebugTimer } from "@mrclrchtr/supi-core/debug";
 import { resolveToolPath } from "@mrclrchtr/supi-core/path";
 import type { Language, Parser, Tree } from "web-tree-sitter";
 import { nodeToRange } from "../coordinates.ts";
@@ -126,11 +128,25 @@ export class TreeSitterRuntime {
       };
     }
 
+    const timer = startDebugTimer();
+    const parserState = this.parsers.has(grammarId)
+      ? "reused"
+      : this.parserPromises.has(grammarId)
+        ? "initializing"
+        : "cold";
+
     // Read the file
     let source: string;
     try {
       source = fs.readFileSync(resolvedPath, "utf-8");
     } catch (err: unknown) {
+      finishStructuralTiming(timer, {
+        operation: "parse",
+        grammar: grammarId,
+        parserState,
+        outcome: "file-access-error",
+        finalPhase: "file-read",
+      });
       const message = err instanceof Error ? err.message : "File could not be read";
       return {
         kind: "file-access-error",
@@ -138,15 +154,42 @@ export class TreeSitterRuntime {
         message,
       };
     }
+    timer.mark("file-read");
+
+    if (timer.enabled) {
+      try {
+        createHash("sha256").update(source).digest();
+      } catch {
+        // Timing-only hashing must not change structural behavior.
+      }
+    }
+    timer.mark("content-hash");
 
+    let parserReady = false;
     try {
       const entry = await this.ensureGrammarParser(grammarId);
+      timer.mark("parser-setup");
+      parserReady = true;
       const tree = entry.parser.parse(source);
+      finishStructuralTiming(timer, {
+        operation: "parse",
+        grammar: grammarId,
+        parserState,
+        outcome: "completed",
+        finalPhase: "parse",
+      });
       return {
         kind: "success",
         data: { tree: tree as Tree, source, resolvedPath, grammarId },
       };
     } catch (err: unknown) {
+      finishStructuralTiming(timer, {
+        operation: "parse",
+        grammar: grammarId,
+        parserState,
+        outcome: "runtime-error",
+        finalPhase: parserReady ? "parse" : "parser-setup",
+      });
       return { kind: "runtime-error", message: formatError(err, "Parser initialization failed") };
     }
   }
@@ -169,16 +212,27 @@ export class TreeSitterRuntime {
     const parseResult = await this.parseFile(filePath);
     if (parseResult.kind !== "success") return parseResult;
 
-    const { tree, source } = parseResult.data;
+    const { grammarId, tree, source } = parseResult.data;
+    const timer = startDebugTimer();
+    let compiled = false;
 
     try {
-      const entry = await this.ensureGrammarParser(parseResult.data.grammarId);
+      const entry = await this.ensureGrammarParser(grammarId);
       const mod = await this.ensureParserInit();
       let query: InstanceType<typeof mod.Query>;
 
       try {
         query = new mod.Query(entry.language, queryString);
+        compiled = true;
+        timer.mark("query-compilation");
       } catch (err: unknown) {
+        finishStructuralTiming(timer, {
+          operation: "query",
+          grammar: grammarId,
+          outcome: "validation-error",
+          captureCount: 0,
+          finalPhase: "query-compilation",
+        });
         return { kind: "validation-error", message: `Invalid query: ${formatError(err)}` };
       }
 
@@ -195,11 +249,25 @@ export class TreeSitterRuntime {
             });
           }
         }
+        finishStructuralTiming(timer, {
+          operation: "query",
+          grammar: grammarId,
+          outcome: "completed",
+          captureCount: captures.length,
+          finalPhase: "query-execution",
+        });
         return { kind: "success", data: captures };
       } finally {
         query.delete();
       }
     } catch (err: unknown) {
+      finishStructuralTiming(timer, {
+        operation: "query",
+        grammar: grammarId,
+        outcome: "runtime-error",
+        captureCount: 0,
+        finalPhase: compiled ? "query-execution" : "query-compilation",
+      });
       return { kind: "runtime-error", message: formatError(err, "Query execution failed") };
     } finally {
       tree.delete();
@@ -239,6 +307,42 @@ export class TreeSitterRuntime {
 /** Max query string length to prevent ReDoS via overly complex Tree-sitter patterns. */
 const MAX_QUERY_LENGTH = 10_000;
 
+type StructuralTimer = ReturnType<typeof startDebugTimer>;
+type ParserState = "cold" | "initializing" | "reused";
+
+type StructuralTimingObservation =
+  | {
+      readonly operation: "parse";
+      readonly grammar: GrammarId;
+      readonly parserState: ParserState;
+      readonly outcome: "completed" | "file-access-error" | "runtime-error";
+      readonly finalPhase: "file-read" | "parse" | "parser-setup";
+    }
+  | {
+      readonly operation: "query";
+      readonly grammar: GrammarId;
+      readonly outcome: "completed" | "runtime-error" | "validation-error";
+      readonly captureCount: number;
+      readonly finalPhase: "query-compilation" | "query-execution";
+    };
+
+function finishStructuralTiming(
+  timer: StructuralTimer,
+  observation: StructuralTimingObservation,
+): void {
+  const { finalPhase, ...data } = observation;
+  timer.finish(
+    () => ({
+      source: "tree-sitter",
+      level: "debug",
+      category: `structural.${data.operation}.timing`,
+      message: `Tree-sitter ${data.operation} ${data.outcome}`,
+      data: { ...data },
+    }),
+    finalPhase,
+  );
+}
+
 /** Format errors with their cause chain's first message for user-facing tool output. */
 function formatError(err: unknown, fallback = "Operation failed"): string {
   if (!(err instanceof Error)) return String(err || fallback);