@mrclrchtr/supi-code-intelligence 4.9.0 → 4.10.0

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

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-tree-sitter",
-  "version": "4.9.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.9.0",
-    "@mrclrchtr/supi-core": "4.9.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/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/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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-code-intelligence",
-  "version": "4.9.0",
+  "version": "4.10.0",
   "description": "LSP and AST navigation, search, diagnostics, and refactoring",
   "license": "MIT",
   "repository": {
@@ -35,10 +35,10 @@
   ],
   "dependencies": {
     "yaml": "^2.9.0",
-    "@mrclrchtr/supi-code-runtime": "4.9.0",
-    "@mrclrchtr/supi-core": "4.9.0",
-    "@mrclrchtr/supi-tree-sitter": "4.9.0",
-    "@mrclrchtr/supi-lsp": "4.9.0"
+    "@mrclrchtr/supi-code-runtime": "4.10.0",
+    "@mrclrchtr/supi-tree-sitter": "4.10.0",
+    "@mrclrchtr/supi-lsp": "4.10.0",
+    "@mrclrchtr/supi-core": "4.10.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",

package/src/analysis/refactor/apply.ts

@@ -16,7 +16,7 @@ import { readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:
 import { basename, dirname, join } from "node:path";
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import type { FileEdit, WorkspaceEdit } from "@mrclrchtr/supi-code-runtime/api";
-import { compareCodePositions } from "./position.ts";
+import { compareCodePositions, createLogicalLineIndex } from "./position.ts";
 import { validateEditAgainstFiles } from "./safety.ts";
 
 export type ApplyResult =
@@ -158,18 +158,21 @@ function buildTransformedContents(
 }
 
 function applyEditsToContent(content: string, edits: FileEdit[]): string {
-  const lines = content.split("\n");
-  const sortedEdits = [...edits].sort(
-    (left, right) =>
-      // Descending by start position so later edits don't shift earlier ones.
-      compareCodePositions(right.range.start, left.range.start) ||
-      compareCodePositions(right.range.end, left.range.end),
-  );
+  const lineIndex = createLogicalLineIndex(content);
+  const sortedEdits = edits
+    .map((edit, protocolIndex) => ({ edit, protocolIndex }))
+    .sort(
+      (left, right) =>
+        // Descending positions prevent shifts. Reverse protocol order at one
+        // position so sequential inserts appear in their supplied order.
+        compareCodePositions(right.edit.range.start, left.edit.range.start) ||
+        right.protocolIndex - left.protocolIndex,
+    );
 
   let updated = content;
-  for (const fileEdit of sortedEdits) {
-    const startOffset = toOffset(lines, fileEdit.range.start.line, fileEdit.range.start.character);
-    const endOffset = toOffset(lines, fileEdit.range.end.line, fileEdit.range.end.character);
+  for (const { edit: fileEdit } of sortedEdits) {
+    const startOffset = lineIndex.offsetAt(fileEdit.range.start);
+    const endOffset = lineIndex.offsetAt(fileEdit.range.end);
     updated = updated.slice(0, startOffset) + fileEdit.newText + updated.slice(endOffset);
   }
 
@@ -266,14 +269,6 @@ function rollbackCommittedFiles(
   }
 }
 
-function toOffset(lines: string[], line: number, character: number): number {
-  let offset = 0;
-  for (let index = 0; index < line && index < lines.length; index++) {
-    offset += lines[index].length + 1;
-  }
-  return offset + character;
-}
-
 function toErrorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }

package/src/analysis/refactor/position.ts

@@ -1,5 +1,52 @@
 import type { CodePosition } from "@mrclrchtr/supi-code-runtime/api";
 
+interface IndexedLine {
+  readonly startOffset: number;
+  readonly length: number;
+}
+
+/** Logical source lines with offsets into the unchanged source string. */
+export interface LogicalLineIndex {
+  readonly lineCount: number;
+  /** Get one logical line length in UTF-16 code units. */
+  lineLength(line: number): number | undefined;
+  /** Convert a validated zero-based UTF-16 position to a source-string offset. */
+  offsetAt(position: CodePosition): number;
+}
+
+/**
+ * Index LF, CRLF, and bare-CR lines without normalizing source bytes.
+ *
+ * JavaScript string offsets and lengths use UTF-16 code units, which are the
+ * only LSP coordinate encoding that the refactor path supports.
+ */
+export function createLogicalLineIndex(source: string): LogicalLineIndex {
+  const lines: IndexedLine[] = [];
+  let lineStart = 0;
+
+  for (let offset = 0; offset < source.length; offset++) {
+    const codeUnit = source.charCodeAt(offset);
+    if (codeUnit !== 0x0a && codeUnit !== 0x0d) continue;
+
+    lines.push({ startOffset: lineStart, length: offset - lineStart });
+    if (codeUnit === 0x0d && source.charCodeAt(offset + 1) === 0x0a) offset++;
+    lineStart = offset + 1;
+  }
+  lines.push({ startOffset: lineStart, length: source.length - lineStart });
+
+  return {
+    lineCount: lines.length,
+    lineLength: (line) => lines[line]?.length,
+    offsetAt: (position) => {
+      const line = lines[position.line];
+      if (!line || position.character < 0 || position.character > line.length) {
+        throw new RangeError("Position is outside the logical source lines");
+      }
+      return line.startOffset + position.character;
+    },
+  };
+}
+
 /** Compare zero-based source positions lexicographically by line, then character. */
 export function compareCodePositions(left: CodePosition, right: CodePosition): number {
   return left.line - right.line || left.character - right.character;

package/src/analysis/refactor/safety.ts

@@ -7,7 +7,7 @@
 
 import { readFileSync } from "node:fs";
 import type { FileEdit, WorkspaceEdit } from "@mrclrchtr/supi-code-runtime/api";
-import { compareCodePositions } from "./position.ts";
+import { compareCodePositions, createLogicalLineIndex, type LogicalLineIndex } from "./position.ts";
 
 export type ValidationResult = { safe: true } | { safe: false; reason: string };
 
@@ -76,12 +76,12 @@ export function validateEditAgainstFiles(edit: WorkspaceEdit): ValidationResult
       };
     }
 
-    const lines = content.split("\n");
+    const lineIndex = createLogicalLineIndex(content);
     for (const fileEdit of fileEdits) {
-      const lineValidation = validateLineBounds(file, fileEdit, lines);
+      const lineValidation = validateLineBounds(file, fileEdit, lineIndex);
       if (!lineValidation.safe) return lineValidation;
 
-      const characterValidation = validateCharacterBounds(file, fileEdit, lines);
+      const characterValidation = validateCharacterBounds(file, fileEdit, lineIndex);
       if (!characterValidation.safe) return characterValidation;
     }
   }
@@ -89,19 +89,27 @@ export function validateEditAgainstFiles(edit: WorkspaceEdit): ValidationResult
   return { safe: true };
 }
 
-function validateLineBounds(file: string, edit: FileEdit, lines: string[]): ValidationResult {
-  const maxLine = lines.length - 1;
+function validateLineBounds(
+  file: string,
+  edit: FileEdit,
+  lineIndex: LogicalLineIndex,
+): ValidationResult {
+  const maxLine = lineIndex.lineCount - 1;
   if (edit.range.start.line > maxLine || edit.range.end.line > maxLine) {
     return {
       safe: false,
-      reason: `Edit in file "${file}" references line ${Math.max(edit.range.start.line, edit.range.end.line)}, but the file has only ${lines.length} line${lines.length === 1 ? "" : "s"}`,
+      reason: `Edit in file "${file}" references line ${Math.max(edit.range.start.line, edit.range.end.line)}, but the file has only ${lineIndex.lineCount} line${lineIndex.lineCount === 1 ? "" : "s"}`,
     };
   }
   return { safe: true };
 }
 
-function validateCharacterBounds(file: string, edit: FileEdit, lines: string[]): ValidationResult {
-  const startLineLength = lines[edit.range.start.line]?.length ?? 0;
+function validateCharacterBounds(
+  file: string,
+  edit: FileEdit,
+  lineIndex: LogicalLineIndex,
+): ValidationResult {
+  const startLineLength = lineIndex.lineLength(edit.range.start.line) ?? 0;
   if (edit.range.start.character > startLineLength) {
     return {
       safe: false,
@@ -109,7 +117,7 @@ function validateCharacterBounds(file: string, edit: FileEdit, lines: string[]):
     };
   }
 
-  const endLineLength = lines[edit.range.end.line]?.length ?? 0;
+  const endLineLength = lineIndex.lineLength(edit.range.end.line) ?? 0;
   if (edit.range.end.character > endLineLength) {
     return {
       safe: false,

package/src/analysis/search/ast-scan-timing.ts

@@ -3,7 +3,6 @@ import type { StructuralSearchOperation } from "@mrclrchtr/supi-tree-sitter/api"
 import type { StructuredFileAnalysis, StructuredPatternParams } from "./pattern-analysis.ts";
 
 interface ScanContext {
-  readonly cwd: string;
   readonly params: StructuredPatternParams;
 }
 
@@ -40,7 +39,6 @@ export function startAstScanTimer(): AstScanTimer {
           level: "debug",
           category: "ast-scan.timing",
           message: `AST ${input.context.params.kind} scan analyzed ${input.analysis.analyzedFileCount} files`,
-          cwd: input.context.cwd,
           data: {
             kind: input.context.params.kind,
             operation: input.operation,