@mrclrchtr/supi-code-intelligence 1.7.0 → 1.9.0

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

@@ -0,0 +1,15 @@
+// supi-core project domain — project root discovery and traversal.
+export type { KnownRootEntry } from "./project-roots.ts";
+export {
+  buildKnownRootsMap,
+  byPathDepth,
+  dedupeTopmostRoots,
+  findProjectRoot,
+  isWithin,
+  isWithinOrEqual,
+  mergeKnownRoots,
+  resolveKnownRoot,
+  segmentCount,
+  sortRootsBySpecificity,
+  walkProject,
+} from "./project-roots.ts";

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

@@ -0,0 +1,4 @@
+// supi-core session domain — session utilities and registries.
+
+export { createRegistry, createSessionStateRegistry } from "./registry-utils.ts";
+export { getActiveBranchEntries } from "./session-utils.ts";

package/node_modules/@mrclrchtr/supi-tree-sitter/node_modules/@mrclrchtr/supi-core/src/settings-ui.ts

@@ -0,0 +1,2 @@
+// supi-core settings-ui domain — settings TUI components (imports pi-tui at runtime, heavy).
+export { createInputSubmenu, openSettingsOverlay } from "./settings/settings-ui.ts";

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

@@ -0,0 +1,9 @@
+// supi-core settings domain — settings registry (lightweight, type-only pi-tui import).
+
+export { registerSettingsCommand } from "./settings/settings-command.ts";
+export type { SettingsScope, SettingsSection } from "./settings/settings-registry.ts";
+export {
+  clearRegisteredSettings,
+  getRegisteredSettings,
+  registerSettings,
+} from "./settings/settings-registry.ts";

package/node_modules/@mrclrchtr/supi-tree-sitter/node_modules/@mrclrchtr/supi-core/src/substrate-types.ts

@@ -0,0 +1,11 @@
+/** 0-based position used by LSP and code-intelligence internally. */
+export interface CodePosition {
+  line: number;
+  character: number;
+}
+
+/** Normalized location — flat replacement for LSP's nested Location/range shape. */
+export interface CodeLocation {
+  uri: string;
+  range: { start: CodePosition; end: CodePosition };
+}

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

@@ -0,0 +1,2 @@
+// supi-core types domain — shared substrate types (zero dependencies, pure types).
+export type { CodeLocation, CodePosition } from "./substrate-types.ts";

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

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-tree-sitter",
-  "version": "1.7.0",
+  "version": "1.9.0",
   "description": "SuPi Tree-sitter extension — structural AST analysis for pi",
   "license": "MIT",
   "repository": {
@@ -24,7 +24,8 @@
   ],
   "dependencies": {
     "web-tree-sitter": "^0.26.8",
-    "@mrclrchtr/supi-core": "1.7.0"
+    "@mrclrchtr/supi-code-runtime": "1.9.0",
+    "@mrclrchtr/supi-core": "1.9.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",
@@ -44,18 +45,20 @@
   },
   "pi": {
     "extensions": [
-      "./src/extension.ts",
-      "node_modules/@mrclrchtr/supi-core/src/extension.ts"
-    ]
+      "./src/extension.ts"
+    ],
+    "image": "https://raw.githubusercontent.com/mrclrchtr/supi/main/packages/supi-tree-sitter/assets/logo.png"
   },
   "bundledDependencies": [
+    "@mrclrchtr/supi-code-runtime",
     "@mrclrchtr/supi-core"
   ],
   "main": "src/api.ts",
   "exports": {
     "./api": "./src/api.ts",
     "./extension": "./src/extension.ts",
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./provider/tree-sitter-provider": "./src/provider/tree-sitter-provider.ts"
   },
   "scripts": {
     "vendor:wasm": "node scripts/vendor-wasm.mjs",

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

@@ -0,0 +1,144 @@
+// Structural provider adapter — wraps TreeSitterService into the shared
+// StructuralProvider contract from supi-code-runtime.
+
+import type {
+  CalleesData,
+  CodeResult,
+  ExportData,
+  ImportData,
+  NodeAtData,
+  OutlineData,
+  StructuralProvider,
+} from "@mrclrchtr/supi-code-runtime/api";
+import type {
+  CalleesAtResult,
+  ExportRecord,
+  ImportRecord,
+  NodeAtResult,
+  OutlineItem,
+  TreeSitterResult,
+  TreeSitterService,
+} from "../types.ts";
+
+/**
+ * Create a StructuralProvider backed by a TreeSitterService.
+ * Maps tree-sitter's nested `range` shapes into the flat range
+ * fields used by the shared code-runtime types.
+ */
+export function createTreeSitterProvider(service: TreeSitterService): StructuralProvider {
+  return {
+    async calleesAt(file, line, character) {
+      const result = await service.calleesAt(file, line, character);
+      return mapTreeSitterResult(result, mapCalleesAtResult);
+    },
+
+    async exports(file) {
+      const result = await service.exports(file);
+      return mapTreeSitterResult(result, mapExportRecords);
+    },
+
+    async outline(file) {
+      const result = await service.outline(file);
+      return mapTreeSitterResult(result, mapOutlineItems);
+    },
+
+    async imports(file) {
+      const result = await service.imports(file);
+      return mapTreeSitterResult(result, mapImportRecords);
+    },
+
+    async nodeAt(file, line, character) {
+      const result = await service.nodeAt(file, line, character);
+      return mapTreeSitterResult(result, mapNodeAtResult);
+    },
+  };
+}
+
+// ── Generic result mapper ─────────────────────────────────────────────
+
+function mapTreeSitterResult<T, U>(
+  result: TreeSitterResult<T>,
+  mapData: (data: T) => U,
+): CodeResult<U> {
+  switch (result.kind) {
+    case "success":
+      return { kind: "success", data: mapData(result.data) };
+    case "unsupported-language":
+      return { kind: "unsupported-language", file: result.file, message: result.message };
+    case "file-access-error":
+      return { kind: "file-access-error", file: result.file, message: result.message };
+    case "validation-error":
+      return { kind: "validation-error", message: result.message };
+    case "runtime-error":
+      return { kind: "runtime-error", message: result.message };
+  }
+}
+
+// ── Data mappers (nested range → flat fields) ─────────────────────────
+
+type RangeLike = {
+  startLine: number;
+  startCharacter: number;
+  endLine: number;
+  endCharacter: number;
+};
+
+function takeRange(r: RangeLike) {
+  return {
+    startLine: r.startLine,
+    startCharacter: r.startCharacter,
+    endLine: r.endLine,
+    endCharacter: r.endCharacter,
+  };
+}
+
+function mapOutlineItems(items: OutlineItem[]): OutlineData[] {
+  return items.map((item) => ({
+    name: item.name,
+    kind: item.kind,
+    ...takeRange(item.range),
+    children: item.children ? mapOutlineItems(item.children) : undefined,
+  }));
+}
+
+function mapExportRecords(records: ExportRecord[]): ExportData[] {
+  return records.map((record) => ({
+    name: record.name,
+    kind: record.kind,
+    ...takeRange(record.range),
+    moduleSpecifier: record.moduleSpecifier,
+  }));
+}
+
+function mapImportRecords(records: ImportRecord[]): ImportData[] {
+  return records.map((record) => ({
+    moduleSpecifier: record.moduleSpecifier,
+    ...takeRange(record.range),
+  }));
+}
+
+function mapNodeAtResult(result: NodeAtResult): NodeAtData {
+  return {
+    type: result.type,
+    ...takeRange(result.range),
+    text: result.text,
+    ancestry: result.ancestry.map((a) => ({
+      type: a.type,
+      ...takeRange(a.range),
+    })),
+  };
+}
+
+function mapCalleesAtResult(result: CalleesAtResult): CalleesData {
+  return {
+    enclosingScope: {
+      name: result.enclosingScope.name,
+      startLine: result.enclosingScope.range.startLine,
+      endLine: result.enclosingScope.range.endLine,
+    },
+    callees: result.callees.map((c) => ({
+      name: c.name,
+      startLine: c.range.startLine,
+    })),
+  };
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Tree-sitter-to-runtime capability registration.
+ *
+ * Adapts a TreeSitterService into the runtime's StructuralProvider interface
+ * via the existing tree-sitter-provider adapter, and registers/unregisters it
+ * with the shared WorkspaceRuntime at session lifecycle boundaries.
+ */
+
+import type { WorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
+import { createTreeSitterProvider } from "../provider/tree-sitter-provider.ts";
+import type { TreeSitterService } from "../types.ts";
+
+/**
+ * Register tree-sitter structural capabilities for a workspace cwd.
+ *
+ * Wraps TreeSitterService into a StructuralProvider via the existing
+ * structural adapter and publishes it into the shared workspace runtime.
+ */
+export function registerTreeSitterCapabilities(
+  runtime: WorkspaceRuntime,
+  cwd: string,
+  service: TreeSitterService,
+): void {
+  const provider = createTreeSitterProvider(service);
+  runtime.registerStructural(cwd, provider);
+}
+
+/**
+ * Unregister tree-sitter structural capabilities for a workspace cwd.
+ *
+ * Clears only the structural capability slot — semantic (LSP) state
+ * is left intact so that a tree-sitter session restart does not wipe
+ * LSP capabilities that were registered earlier in the same lifecycle.
+ */
+export function unregisterTreeSitterCapabilities(runtime: WorkspaceRuntime, cwd: string): void {
+  runtime.clearStructural(cwd);
+}

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

@@ -2,7 +2,7 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { resolveToolPath } from "@mrclrchtr/supi-core/api";
+import { resolveToolPath } from "@mrclrchtr/supi-core/path";
 import type { Language, Parser, Tree } from "web-tree-sitter";
 import { nodeToRange } from "../coordinates.ts";
 import { detectGrammar, resolveGrammarWasmPath } from "../language.ts";

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

@@ -2,7 +2,7 @@
 // Peer extensions can import `getSessionTreeSitterService` from the package API
 // to reuse the active structural runtime without creating duplicate sessions.
 
-import { createSessionStateRegistry } from "@mrclrchtr/supi-core/api";
+import { createSessionStateRegistry } from "@mrclrchtr/supi-core/session";
 import type { SessionTreeSitterService, SessionTreeSitterServiceState } from "../types.ts";
 
 const registry = createSessionStateRegistry<SessionTreeSitterServiceState>(

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

@@ -1,31 +1,35 @@
-// Prompt guidance and tool description for the tree_sitter tool.
+// Guidance surfaces for the focused tree_sitter_* tool set.
 //
-// Note: We intentionally do NOT include cross-tool routing (e.g., "use lsp for
-// type info") because this package can be installed standalone without supi-lsp.
+// Derives from tool-specs.ts so prompt surfaces stay in sync with
+// the public tool metadata.
 
-import {
-  formatTreeSitterActionList,
-  getTreeSitterActionNamesByGuidanceGroup,
-} from "./action-specs.ts";
+import { TREE_SITTER_TOOL_SPECS, type TreeSitterToolName } from "./tool-specs.ts";
 
-const jsTsStructureActions = getTreeSitterActionNamesByGuidanceGroup("js-ts-structure")
-  .map((action) => `tree_sitter.${action}(file)`)
-  .join(", ");
+export interface TreeSitterToolPromptSurface {
+  description: string;
+  promptSnippet: string;
+  promptGuidelines: string[];
+}
 
-export const toolDescription = `Tree-sitter tool — parser-level structure and syntax queries for supported files.
+export type TreeSitterToolPromptSurfaceMap = Record<
+  TreeSitterToolName,
+  TreeSitterToolPromptSurface
+>;
 
-Actions: ${formatTreeSitterActionList()}.
+const _DEFAULT_SURFACES = buildTreeSitterToolPromptSurfaces();
 
-Use tree_sitter for exact syntax nodes, shallow structure, parsed imports/exports, outgoing calls, or custom AST queries within one file. file is required for all actions. line and character are 1-based UTF-16 coordinates for node_at and callees. query is required for query. outline, imports, and exports are JavaScript/TypeScript-only; node_at and query work across supported grammars; callees works for many grammars. Relative paths resolve from the session working directory, and a leading @ on file paths is stripped.`;
-
-export const promptGuidelines = [
-  `Use ${jsTsStructureActions} for shallow JavaScript or TypeScript structure without reading the whole file.`,
-  "Use tree_sitter.node_at(file, line, character) for the exact syntax node and ancestry at a known position.",
-  "Use tree_sitter.callees(file, line, character) for outgoing calls from the enclosing function or method at a known position.",
-  "Use tree_sitter.query(file, query) for custom Tree-sitter patterns when the built-in actions are not specific enough.",
-  "Use tree_sitter for syntax, node types, source ranges, and other parser-backed structure within one supported file.",
-  "Do not use tree_sitter for type information, cross-file references, semantic renames, or codebase-wide orientation.",
-];
-
-export const promptSnippet =
-  "tree_sitter — parser-backed single-file structure, node lookup, callees, and AST queries";
+/**
+ * Build the full prompt-surface map for all 6 tree_sitter_* tools.
+ */
+export function buildTreeSitterToolPromptSurfaces(): TreeSitterToolPromptSurfaceMap {
+  return Object.fromEntries(
+    TREE_SITTER_TOOL_SPECS.map((spec) => [
+      spec.name,
+      {
+        description: spec.description,
+        promptSnippet: spec.promptSnippet,
+        promptGuidelines: [...spec.promptGuidelines],
+      } satisfies TreeSitterToolPromptSurface,
+    ]),
+  ) as TreeSitterToolPromptSurfaceMap;
+}

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

@@ -0,0 +1,196 @@
+// Per-action handler functions for the focused tree_sitter tool surface.
+//
+// Each handler receives only the parameters it needs (no action dispatch).
+// Handlers are shared between the extension factory (tree-sitter.ts) and the
+// tool registration layer (register-tools.ts).
+
+import { detectGrammar, isJsTsGrammar } from "../language.ts";
+import type { TreeSitterRuntime } from "../session/runtime.ts";
+import {
+  formatNonSuccess,
+  formatOutlineItemsCapped,
+  MAX_ITEMS,
+  truncate,
+  truncatedNotice,
+  truncateText,
+} from "./formatting.ts";
+import { collectOutline } from "./outline.ts";
+import { extractExports, extractImports, lookupCalleesAt, lookupNodeAt } from "./structure.ts";
+
+// ---------------------------------------------------------------------------
+// Outline — JS/TS only
+// ---------------------------------------------------------------------------
+
+export async function handleOutline(runtime: TreeSitterRuntime, file: string): Promise<string> {
+  const parseResult = await runtime.parseFile(file);
+  if (parseResult.kind !== "success") return formatNonSuccess(parseResult);
+  if (!isJsTsGrammar(parseResult.data.grammarId)) {
+    return "Unsupported language: outline is only supported for JavaScript and TypeScript files";
+  }
+
+  const { tree, source } = parseResult.data;
+  let items: ReturnType<typeof collectOutline>;
+  try {
+    items = collectOutline(tree.rootNode, source);
+  } finally {
+    tree.delete();
+  }
+
+  if (items.length === 0) return `No structural declarations found in ${file}`;
+
+  const lines = [`## Outline: ${file}`, ""];
+  const { omitted } = formatOutlineItemsCapped(items, lines, MAX_ITEMS);
+  if (omitted) lines.push("", truncatedNotice(omitted, "outline items"));
+  return lines.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Imports — JS/TS only
+// ---------------------------------------------------------------------------
+
+export async function handleImports(runtime: TreeSitterRuntime, file: string): Promise<string> {
+  const grammarId = detectGrammar(file);
+  if (grammarId && !isJsTsGrammar(grammarId)) {
+    return "Unsupported language: imports is only supported for JavaScript and TypeScript files";
+  }
+  const result = await extractImports(runtime, file);
+  if (result.kind !== "success") return formatNonSuccess(result);
+
+  const { data: imports } = result;
+  if (imports.length === 0) return `No imports found in ${file}`;
+
+  const { included, truncated } = truncate(imports, MAX_ITEMS);
+  const lines = [`## Imports: ${file}`, ""];
+  for (const imp of included) {
+    const r = imp.range;
+    lines.push(`- "${imp.moduleSpecifier}" (L${r.startLine}:${r.startCharacter})`);
+  }
+  if (truncated) lines.push("", truncatedNotice(truncated, "imports"));
+  return lines.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Exports — JS/TS only
+// ---------------------------------------------------------------------------
+
+export async function handleExports(runtime: TreeSitterRuntime, file: string): Promise<string> {
+  const grammarId = detectGrammar(file);
+  if (grammarId && !isJsTsGrammar(grammarId)) {
+    return "Unsupported language: exports is only supported for JavaScript and TypeScript files";
+  }
+  const result = await extractExports(runtime, file);
+  if (result.kind !== "success") return formatNonSuccess(result);
+
+  const { data: exports } = result;
+  if (exports.length === 0) return `No exports found in ${file}`;
+
+  const { included, truncated } = truncate(exports, MAX_ITEMS);
+  const lines = [`## Exports: ${file}`, ""];
+  for (const exp of included) {
+    const r = exp.range;
+    const from = exp.moduleSpecifier ? ` from "${exp.moduleSpecifier}"` : "";
+    lines.push(`- ${exp.kind}: ${exp.name}${from} (L${r.startLine}:${r.startCharacter})`);
+  }
+  if (truncated) lines.push("", truncatedNotice(truncated, "exports"));
+  return lines.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Node at position — all supported grammars
+// ---------------------------------------------------------------------------
+
+export async function handleNodeAt(
+  runtime: TreeSitterRuntime,
+  file: string,
+  line: number,
+  character: number,
+): Promise<string> {
+  const result = await lookupNodeAt(runtime, file, line, character);
+  if (result.kind !== "success") return formatNonSuccess(result);
+
+  const { data } = result;
+  const lines = [
+    `## Node at ${file}:${line}:${character}`,
+    "",
+    `**Type:** ${data.type}`,
+    `**Range:** L${data.range.startLine}:${data.range.startCharacter} — L${data.range.endLine}:${data.range.endCharacter}`,
+    `**Text:** ${truncateText(data.text, 200)}`,
+  ];
+
+  if (data.ancestry.length > 0) {
+    lines.push("", "**Ancestry:**");
+    const { included, truncated } = truncate(data.ancestry, MAX_ITEMS);
+    for (const ancestor of included) {
+      lines.push(
+        `- ${ancestor.type} (L${ancestor.range.startLine}:${ancestor.range.startCharacter}-L${ancestor.range.endLine}:${ancestor.range.endCharacter})`,
+      );
+    }
+    if (truncated) lines.push("", truncatedNotice(truncated, "ancestry entries"));
+  }
+
+  return lines.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Query — all supported grammars
+// ---------------------------------------------------------------------------
+
+export async function handleQuery(
+  runtime: TreeSitterRuntime,
+  file: string,
+  query: string,
+): Promise<string> {
+  const result = await runtime.queryFile(file, query);
+  if (result.kind !== "success") return formatNonSuccess(result);
+
+  const { data: captures } = result;
+  if (captures.length === 0) return `No matches for query in ${file}`;
+
+  const { included, truncated } = truncate(captures, MAX_ITEMS);
+  const lines = [`## Query results: ${file}`, ""];
+  for (const capture of included) {
+    const r = capture.range;
+    lines.push(
+      `- ${capture.name}: ${capture.nodeType} (L${r.startLine}:${r.startCharacter}-L${r.endLine}:${r.endCharacter})`,
+    );
+    lines.push(`  \`${truncateText(capture.text, 120)}\``);
+  }
+  if (truncated) lines.push("", truncatedNotice(truncated, "captures"));
+  return lines.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Callees — many supported grammars
+// ---------------------------------------------------------------------------
+
+export async function handleCallees(
+  runtime: TreeSitterRuntime,
+  file: string,
+  line: number,
+  character: number,
+): Promise<string> {
+  const result = await lookupCalleesAt(runtime, file, line, character);
+  if (result.kind !== "success") return formatNonSuccess(result);
+
+  const { enclosingScope, callees } = result.data;
+  if (callees.length === 0) {
+    return `No outgoing calls found in \`${enclosingScope.name}\` at ${file}:${line}:${character}`;
+  }
+
+  const lines: string[] = [];
+  lines.push(`## Callees: ${file}:${line}:${character}`);
+  lines.push("");
+  lines.push(
+    `**${callees.length} outgoing call${callees.length > 1 ? "s" : ""}** from \`${enclosingScope.name}\` at L${enclosingScope.range.startLine}-L${enclosingScope.range.endLine}`,
+  );
+  lines.push("");
+
+  for (const c of callees.slice(0, MAX_ITEMS)) {
+    lines.push(`- \`${c.name}\` (L${c.range.startLine})`);
+  }
+  if (callees.length > MAX_ITEMS) {
+    lines.push("", truncatedNotice(callees.length - MAX_ITEMS, "callees"));
+  }
+
+  return lines.join("\n");
+}

package/node_modules/@mrclrchtr/supi-tree-sitter/src/tool/register-tools.ts

@@ -0,0 +1,107 @@
+// Focused tool registration for the tree_sitter extension.
+//
+// Derives tool metadata, schemas, and prompt surfaces from tool-specs.ts.
+// Handler functions from ./handlers.ts do the actual work.
+
+import type { AgentToolResult, ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { TreeSitterRuntime } from "../session/runtime.ts";
+import {
+  handleCallees,
+  handleExports,
+  handleImports,
+  handleNodeAt,
+  handleOutline,
+  handleQuery,
+} from "./handlers.ts";
+import {
+  getTreeSitterToolSpec,
+  PARAM_SCHEMAS,
+  TREE_SITTER_TOOL_SPECS,
+  type TreeSitterToolName,
+} from "./tool-specs.ts";
+
+function notInitializedResult(): AgentToolResult<Record<string, unknown>> {
+  return {
+    content: [{ type: "text", text: "Tree-sitter not initialized. Start a new session first." }],
+    details: {},
+  };
+}
+
+function textResult(text: string): AgentToolResult<Record<string, unknown>> {
+  return { content: [{ type: "text", text }], details: {} };
+}
+
+/** Wraps a handler call into a pi-compatible execute function. */
+function createExecute(
+  fn: (runtime: TreeSitterRuntime, params: Record<string, unknown>) => Promise<string> | string,
+  getRuntime: () => TreeSitterRuntime | undefined,
+) {
+  // biome-ignore lint/complexity/useMaxParams: pi ToolDefinition.execute signature
+  return async (
+    _toolCallId: string,
+    params: Record<string, unknown>,
+    _signal: AbortSignal | undefined,
+    _onUpdate: unknown,
+    _ctx: { cwd: string },
+  ): Promise<AgentToolResult<Record<string, unknown>>> => {
+    const runtime = getRuntime();
+    if (!runtime) return notInitializedResult();
+
+    // Guard against direct execute calls (tests, tool reuse) that bypass pi's schema validation
+    if (!params.file || typeof params.file !== "string") {
+      return textResult("Validation error: `file` is required.");
+    }
+
+    try {
+      const text = await fn(runtime, params);
+      return textResult(text);
+    } catch (error) {
+      return textResult(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  };
+}
+
+// ── Handler dispatch map ───────────────────────────────────────────────
+
+type HandlerFn = (
+  runtime: TreeSitterRuntime,
+  params: Record<string, unknown>,
+) => Promise<string> | string;
+
+const HANDLER_MAP: Record<TreeSitterToolName, HandlerFn> = {
+  tree_sitter_outline: (runtime, params) => handleOutline(runtime, String(params.file)),
+  tree_sitter_imports: (runtime, params) => handleImports(runtime, String(params.file)),
+  tree_sitter_exports: (runtime, params) => handleExports(runtime, String(params.file)),
+  tree_sitter_node_at: (runtime, params) =>
+    handleNodeAt(runtime, String(params.file), Number(params.line), Number(params.character)),
+  tree_sitter_query: (runtime, params) =>
+    handleQuery(runtime, String(params.file), String(params.query)),
+  tree_sitter_callees: (runtime, params) =>
+    handleCallees(runtime, String(params.file), Number(params.line), Number(params.character)),
+};
+
+// ── Registration ───────────────────────────────────────────────────────
+
+/**
+ * Register 6 focused tree-sitter tools.
+ *
+ * @param pi — extension API
+ * @param getRuntime — thunk returning the current runtime (or undefined before session_start)
+ */
+export function registerFocusedTreeSitterTools(
+  pi: ExtensionAPI,
+  getRuntime: () => TreeSitterRuntime | undefined,
+): void {
+  for (const spec of TREE_SITTER_TOOL_SPECS) {
+    const spec2 = getTreeSitterToolSpec(spec.name);
+    pi.registerTool({
+      name: spec2.name,
+      label: spec2.label,
+      description: spec2.description,
+      promptSnippet: spec2.promptSnippet,
+      promptGuidelines: spec2.promptGuidelines,
+      parameters: PARAM_SCHEMAS[spec2.paramSchemaKey],
+      execute: createExecute(HANDLER_MAP[spec2.name], getRuntime),
+    });
+  }
+}