@mrclrchtr/supi-tree-sitter 11.4.0 → 12.0.0

package/node_modules/@mrclrchtr/supi-code-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-code-runtime",
-  "version": "11.4.0",
+  "version": "12.0.0",
   "description": "Shared workspace context and capability contracts for code intelligence",
   "license": "MIT",
   "repository": {

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

@@ -60,6 +60,7 @@ export type {
   ImportData,
   NodeAtData,
   OutlineData,
+  RefactorActionIdentity,
   RefactorOperation,
   RefactorRequest,
   RefactorResult,

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

@@ -193,31 +193,53 @@ export interface WorkspaceEdit {
 }
 
 /**
- * Supported refactor operation names for the current semantic planning path.
- */
-export type RefactorOperation =
-  | "rename_symbol"
-  | "extract_function"
-  | "extract_variable"
-  | "rename_file"
-  | "move_file"
-  | "update_imports"
-  | "delete_dead_code";
-
-/**
- * Operation-aware refactor planning request.
+ * Operation-aware refactor planning request. Each operation carries only the
+ * scope it needs:
  *
- * Consumers provide a target file/position plus operation-specific options.
- * File/resource operations remain requestable so providers can reject them
- * explicitly and honestly until shared workspace-edit resource ops exist.
+ * - `rename_symbol`: one symbol position and the new name.
+ * - `code_action`: one file range and a CodeActionKind prefix under `refactor`.
+ * - `source_action`: one whole file and a CodeActionKind prefix under `source`.
+ *
+ * `kind` matches the requested kind and its dotted sub-kinds. `title`, when
+ * present, selects one action by its exact title.
  */
-export interface RefactorRequest {
-  operation: RefactorOperation;
-  file: string;
-  position: CodePosition;
-  range?: SourceRange;
-  newName?: string;
-  destination?: string;
+export type RefactorRequest =
+  | {
+      operation: "rename_symbol";
+      file: string;
+      position: CodePosition;
+      newName: string;
+    }
+  | {
+      operation: "code_action";
+      file: string;
+      range: SourceRange;
+      kind: string;
+      title?: string;
+    }
+  | {
+      operation: "source_action";
+      file: string;
+      kind: string;
+      title?: string;
+    };
+
+/** Supported refactor operation names. */
+export type RefactorOperation = RefactorRequest["operation"];
+
+/** The code action selected for a precise code- or source-action plan. */
+export interface RefactorActionIdentity {
+  /** Server-reported CodeActionKind. */
+  kind: string;
+  /** Server-reported action title. */
+  title: string;
+  /**
+   * How the edits were obtained: `edit` from the action itself (after
+   * `codeAction/resolve` when needed), or `captured-command` from the single
+   * `workspace/applyEdit` the server pushed while running the action's command.
+   * Captured edits were refused, never applied.
+   */
+  provenance?: "edit" | "captured-command";
 }
 
 /**
@@ -228,6 +250,10 @@ export interface DisambiguationCandidate {
   file?: string;
   line?: number;
   character?: number;
+  /** Server-reported CodeActionKind, for code-action candidates. */
+  kind?: string;
+  /** Exact action title to pass back as `title`, for code-action candidates. */
+  title?: string;
 }
 
 /**
@@ -241,6 +267,8 @@ export type RefactorResult =
   | {
       kind: "precise";
       edits: WorkspaceEdit;
+      /** The selected code action, for code- and source-action plans. */
+      action?: RefactorActionIdentity;
       /** Provider roots authorized by the semantic route. Consumers canonicalize before storage. */
       authorizedMutationRoots: string[];
     }

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-tree-sitter",
-  "version": "11.4.0",
+  "version": "12.0.0",
   "description": "Structural AST analysis for SuPi code intelligence",
   "license": "MIT",
   "repository": {
@@ -36,8 +36,8 @@
   "dependencies": {
     "jiti": "^2.7.0",
     "web-tree-sitter": "^0.27.0",
-    "@mrclrchtr/supi-core": "11.4.0",
-    "@mrclrchtr/supi-code-runtime": "11.4.0"
+    "@mrclrchtr/supi-code-runtime": "12.0.0",
+    "@mrclrchtr/supi-core": "12.0.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",

package/src/coordinates.ts

@@ -100,7 +100,21 @@ export function validatePublicPositionBounds(
   return null;
 }
 
-/** Split source into logical lines without CRLF line-ending bytes. */
+/**
+ * Split source into Tree-sitter rows, dropping the `\r` of CRLF endings.
+ * Tree-sitter rows break only on `\n`, so a lone `\r` is not a line break here.
+ * LSP treats a lone `\r` as a line break, so structural lines after one differ from LSP lines.
+ */
 export function splitSourceLines(source: string): string[] {
-  return source.replace(/\r\n?/g, "\n").split("\n");
+  if (lastSplit?.source === source) return lastSplit.lines;
+  const lines = source.split(/\r?\n/);
+  lastSplit = { source, lines };
+  return lines;
 }
+
+/**
+ * Single-entry cache: range conversion calls this once per node on the same
+ * source, so re-splitting each time made extraction quadratic in file size.
+ * Callers must not mutate the returned array.
+ */
+let lastSplit: { source: string; lines: string[] } | undefined;

package/src/session/structural-worker-client.ts

@@ -331,8 +331,9 @@ export class StructuralWorkerClient {
     try {
       throwIfCodeRequestInterrupted(active.control);
     } catch (error) {
+      // Keep the chunk handshake alive so the Worker can send its terminal message
+      // instead of waiting for the hard stop.
       this.#interrupt(active, error);
-      return;
     }
     active.chunks.push(Uint8Array.from(message.payload));
     active.nextSequence += 1;
@@ -433,7 +434,7 @@ export class StructuralWorkerClient {
       return;
     }
     const worker = this.#worker;
-    if (this.#active !== request || !worker) return;
+    if (this.#active !== request || !worker || request.hardStopTimer) return;
     Atomics.store(request.cancellationFlag, 0, 1);
     if (
       !this.#send(worker, {

package/src/syntax-errors.ts

@@ -4,7 +4,9 @@ import type { GrammarId, SourceRange } from "./types.ts";
 
 /** Return whether a parsed tree contains an explicit or recovered syntax error. */
 export function hasSyntaxErrors(root: SyntaxNodeLike): boolean {
+  // web-tree-sitter's hasError already covers ERROR and missing descendants.
   if (root.hasError === true) return true;
+  if (root.hasError === false) return false;
   if (root.type === "ERROR" || root.isMissing === true) return true;
   return (root.children ?? []).some(hasSyntaxErrors);
 }

package/src/tool/call-range.ts

@@ -0,0 +1,94 @@
+// Callee ranges for grammars whose call queries capture the whole call node.
+
+import { tsPointToPublic } from "../coordinates.ts";
+import type { SyntaxNodeLike } from "../syntax-node.ts";
+import type { GrammarId, SourceRange } from "../types.ts";
+
+/**
+ * Return the callee range for a whole-call capture, so call-site ranges cover the
+ * callee expression in every grammar (`a.b` in `a.b(1)`), as JS/TS, Python, Go,
+ * and Rust queries capture directly. Returns `null` when the capture already is
+ * the callee or no narrower callee exists.
+ */
+export function calleeRangeForCallNode(
+  node: SyntaxNodeLike,
+  grammarId: GrammarId,
+  source: string,
+): SourceRange | null {
+  const end = calleeEnd(node, grammarId);
+  if (!end) return null;
+  const start = tsPointToPublic(node.startPosition, source);
+  const publicEnd = tsPointToPublic(end, source);
+  return {
+    startLine: start.line,
+    startCharacter: start.character,
+    endLine: publicEnd.line,
+    endCharacter: publicEnd.character,
+  };
+}
+
+/**
+ * Find the syntax node for one query capture by walking up from the leaf at its start.
+ * Returns `null` when no ancestor has the capture's type and range.
+ */
+export function findCaptureNode(
+  root: SyntaxNodeLike & {
+    descendantForPosition(point: { row: number; column: number }): SyntaxNodeLike | null;
+  },
+  capture: { nodeType: string; range: SourceRange },
+): SyntaxNodeLike | null {
+  const { range } = capture;
+  let node = root.descendantForPosition({
+    row: range.startLine - 1,
+    column: range.startCharacter - 1,
+  });
+  while (node) {
+    if (
+      node.type === capture.nodeType &&
+      node.startPosition.row === range.startLine - 1 &&
+      node.startPosition.column === range.startCharacter - 1 &&
+      node.endPosition.row === range.endLine - 1 &&
+      node.endPosition.column === range.endCharacter - 1
+    ) {
+      return node;
+    }
+    node = node.parent;
+  }
+  return null;
+}
+
+function calleeEnd(
+  node: SyntaxNodeLike,
+  grammarId: GrammarId,
+): { row: number; column: number } | null {
+  switch (grammarId) {
+    case "java":
+      return node.type === "method_invocation"
+        ? (node.childForFieldName("name")?.endPosition ?? null)
+        : null;
+    case "kotlin":
+      return node.type === "call_expression" ? (kotlinCallee(node)?.endPosition ?? null) : null;
+    case "ruby":
+      return node.type === "call"
+        ? ((node.childForFieldName("method") ?? node.childForFieldName("receiver"))?.endPosition ??
+            null)
+        : null;
+    default:
+      return null;
+  }
+}
+
+/**
+ * Kotlin nests `f(x) { }` as an outer call (lambda-only suffix) wrapping `f(x)`.
+ * Treat both as one call so they share the callee `f`; `f(1)(2)` keeps `f(1)` as
+ * the outer callee because its suffix has value arguments.
+ */
+function kotlinCallee(node: SyntaxNodeLike): SyntaxNodeLike | null {
+  const callee = node.children[0];
+  if (!callee) return null;
+  const suffix = node.children.find((child) => child.type === "call_suffix");
+  const lambdaOnly =
+    suffix !== undefined && !suffix.children.some((child) => child.type === "value_arguments");
+  if (callee.type === "call_expression" && lambdaOnly) return kotlinCallee(callee);
+  return callee;
+}

package/src/tool/call-sites.ts

@@ -1,10 +1,17 @@
 /** File-wide call-site extraction using per-grammar tree-sitter queries. */
 
 import type { CodeRequestControl } from "@mrclrchtr/supi-code-runtime/api";
-import type { CallSiteMatch, GrammarId, TreeSitterResult } from "../types.ts";
+import type {
+  CallSiteMatch,
+  GrammarId,
+  QueryCapture,
+  SourceRange,
+  TreeSitterResult,
+} from "../types.ts";
 import { isTypeOnlyImportCapture } from "../worker/call-context.ts";
 import { queryParsedFile, type TreeSitterRuntime } from "../worker/runtime.ts";
 import { normalizeCallName } from "./call-name.ts";
+import { calleeRangeForCallNode, findCaptureNode } from "./call-range.ts";
 
 // ── Per-grammar call-site queries ─────────────────────────────────────
 
@@ -90,17 +97,19 @@ export async function extractCallSites(
       const name = normalizeCallName(capture.text, grammarId, capture.nodeType);
       if (name.length === 0) continue;
 
+      const range = callSiteRange(tree.rootNode, capture, grammarId, source);
+
       // Collapse duplicate captures only when they identify the same source range.
-      const key = `${capture.range.startLine}:${capture.range.startCharacter}:${capture.range.endLine}:${capture.range.endCharacter}`;
+      const key = `${range.startLine}:${range.startCharacter}:${range.endLine}:${range.endCharacter}`;
       if (seen.has(key)) continue;
       seen.add(key);
 
       matches.push({
         name,
-        startLine: capture.range.startLine,
-        startCharacter: capture.range.startCharacter,
-        endLine: capture.range.endLine,
-        endCharacter: capture.range.endCharacter,
+        startLine: range.startLine,
+        startCharacter: range.startCharacter,
+        endLine: range.endLine,
+        endCharacter: range.endCharacter,
       });
     }
 
@@ -111,3 +120,14 @@ export async function extractCallSites(
     tree.delete();
   }
 }
+
+/** Narrow whole-call captures to their callee so ranges match the other grammars. */
+function callSiteRange(
+  root: Parameters<typeof findCaptureNode>[0],
+  capture: QueryCapture,
+  grammarId: GrammarId,
+  source: string,
+): SourceRange {
+  const node = findCaptureNode(root, capture);
+  return (node && calleeRangeForCallNode(node, grammarId, source)) ?? capture.range;
+}

package/src/tool/callees.ts

@@ -9,6 +9,7 @@ import type { GrammarId, SourceRange, TreeSitterResult } from "../types.ts";
 import { isTypeOnlyImportCapture } from "../worker/call-context.ts";
 import { queryParsedFile, type TreeSitterRuntime } from "../worker/runtime.ts";
 import { normalizeCallName } from "./call-name.ts";
+import { calleeRangeForCallNode } from "./call-range.ts";
 import { createCalleeDisplayName, createSourceLineStarts } from "./callee-display-name.ts";
 import { extractScopeName } from "./scope.ts";
 
@@ -387,11 +388,13 @@ function filterCalleeCaptures(
 
     if (isTypeOnlyImportCapture(enclosingNode, capture, grammarId)) continue;
     const name = normalizeCallName(capture.text, grammarId, capture.nodeType);
-    const rangeKey = sourceRangeKey(capture.range);
+    const syntaxNode = syntaxNodes.get(captureNodeKey(capture));
+    const range =
+      (syntaxNode && calleeRangeForCallNode(syntaxNode, grammarId, source)) ?? capture.range;
+    const rangeKey = sourceRangeKey(range);
     if (name.length === 0 || seenRanges.has(rangeKey)) continue;
     seenRanges.add(rangeKey);
 
-    const syntaxNode = syntaxNodes.get(captureNodeKey(capture));
     const displayName = syntaxNode
       ? createCalleeDisplayName({
           node: syntaxNode,
@@ -404,7 +407,7 @@ function filterCalleeCaptures(
     callees.push({
       name,
       ...(displayName === undefined ? {} : { displayName }),
-      range: capture.range,
+      range,
     });
   }
 

package/src/tool/exports.ts

@@ -91,9 +91,11 @@ const DECLARATION_EXPORT_NODE_TYPES = new Set([
   "type_alias_declaration",
   "enum_declaration",
   "lexical_declaration",
+  "variable_declaration",
   "ambient_declaration",
   "internal_module",
   "module",
+  "import_alias",
 ]);
 
 function extractDeclarationExport(
@@ -101,7 +103,7 @@ function extractDeclarationExport(
   source: string,
   exports: ExportRecord[],
 ): void {
-  if (decl.type === "lexical_declaration") {
+  if (decl.type === "lexical_declaration" || decl.type === "variable_declaration") {
     extractLexicalDeclarationExports(decl, source, exports);
     return;
   }
@@ -111,7 +113,11 @@ function extractDeclarationExport(
     return;
   }
 
-  const name = getDeclarationName(decl);
+  // `export import X = Y.Z` exports the alias `X`, which may name a value, type, or namespace.
+  const name =
+    decl.type === "import_alias"
+      ? (decl.children.find((child) => child.type === "identifier")?.text ?? null)
+      : getDeclarationName(decl);
   if (!name) return;
 
   exports.push({
@@ -143,7 +149,7 @@ function extractAmbientDeclarationExport(
   const nested = decl.children.find((child) => child.type !== "declare" && child.type !== ";");
   if (!nested) return;
 
-  if (nested.type === "lexical_declaration") {
+  if (nested.type === "lexical_declaration" || nested.type === "variable_declaration") {
     extractLexicalDeclarationExports(nested, source, exports);
     return;
   }
@@ -177,6 +183,8 @@ function exportKindForDeclaration(type: string): string {
     case "internal_module":
     case "module":
       return "namespace";
+    case "import_alias":
+      return "alias";
     default:
       return type.replace(/_declaration$/, "");
   }
@@ -217,8 +225,9 @@ function extractDefaultExport(node: SyntaxNodeLike, source: string, exports: Exp
   });
 }
 
+/** Return the `from "module"` specifier; a string value such as `export default "x"` is not one. */
 function findStringChild(node: SyntaxNodeLike): SyntaxNodeLike | undefined {
-  return node.children.find((child) => child.type === "string");
+  return node.childForFieldName("source") ?? undefined;
 }
 
 function extractReExport(

package/src/worker/runtime.ts

@@ -13,11 +13,7 @@ import {
   type StructuralTimingEvent,
   startStructuralTiming,
 } from "../session/structural-timing.ts";
-import {
-  collectSyntaxErrorRanges,
-  hasSyntaxErrors,
-  withSyntaxCompleteness,
-} from "../syntax-errors.ts";
+import { withSyntaxCompleteness } from "../syntax-errors.ts";
 import type { GrammarId, QueryCapture, TreeSitterResult } from "../types.ts";
 import {
   ParsedFileReadError,
@@ -172,8 +168,6 @@ export class TreeSitterRuntime {
           source: string;
           resolvedPath: string;
           grammarId: GrammarId;
-          hasSyntaxErrors: boolean;
-          errorRanges: ReturnType<typeof collectSyntaxErrorRanges>;
         };
       }
     | Exclude<TreeSitterResult<never>, { kind: "success" | "partial" }>
@@ -249,8 +243,6 @@ 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) {