@mrclrchtr/supi-code-intelligence 1.4.0 → 1.5.0

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

@@ -5,6 +5,18 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { detectGrammar, isJsTsGrammar } from "./language.ts";
 import { TreeSitterRuntime } from "./session/runtime.ts";
+import {
+  clearSessionTreeSitterService,
+  setSessionTreeSitterService,
+} from "./session/service-registry.ts";
+import { createTreeSitterService } from "./session/session.ts";
+import {
+  formatTreeSitterActionList,
+  getTreeSitterActionSpec,
+  isTreeSitterAction,
+  TREE_SITTER_ACTION_NAMES,
+  type TreeSitterAction,
+} from "./tool/action-specs.ts";
 import {
   formatNonSuccess,
   formatOutlineItemsCapped,
@@ -18,26 +30,30 @@ import { promptGuidelines, promptSnippet, toolDescription } from "./tool/guidanc
 import { collectOutline } from "./tool/outline.ts";
 import { extractExports, extractImports, lookupCalleesAt, lookupNodeAt } from "./tool/structure.ts";
 
-const TreeSitterActionEnum = StringEnum([
-  "outline",
-  "imports",
-  "exports",
-  "node_at",
-  "query",
-  "callees",
-] as const);
+const TreeSitterActionEnum = StringEnum(TREE_SITTER_ACTION_NAMES);
 
 export default function treeSitterExtension(pi: ExtensionAPI) {
   let runtime: TreeSitterRuntime | undefined;
+  let activeCwd: string | null = null;
 
   pi.on("session_start", (_event, ctx) => {
-    runtime?.dispose();
+    if (runtime && activeCwd) {
+      clearSessionTreeSitterService(activeCwd);
+      runtime.dispose();
+    }
+
+    activeCwd = ctx.cwd;
     runtime = new TreeSitterRuntime(ctx.cwd);
+    setSessionTreeSitterService(ctx.cwd, createTreeSitterService(runtime));
   });
 
   pi.on("session_shutdown", () => {
+    if (activeCwd) {
+      clearSessionTreeSitterService(activeCwd);
+    }
     runtime?.dispose();
     runtime = undefined;
+    activeCwd = null;
   });
 
   pi.registerTool({
@@ -73,8 +89,6 @@ export default function treeSitterExtension(pi: ExtensionAPI) {
   });
 }
 
-type TreeSitterAction = "outline" | "imports" | "exports" | "node_at" | "query" | "callees";
-
 type ToolParams = {
   action?: string;
   file?: string;
@@ -83,17 +97,47 @@ type ToolParams = {
   query?: string;
 };
 
+interface ValidatedToolParams {
+  action: TreeSitterAction;
+  file: string;
+  line?: number;
+  character?: number;
+  query?: string;
+}
+
+const SUPPORTED_ACTIONS_TEXT = formatTreeSitterActionList();
+
+const ACTION_HANDLERS: Record<
+  TreeSitterAction,
+  (runtime: TreeSitterRuntime, params: ValidatedToolParams) => Promise<string>
+> = {
+  outline: (runtime, params) => handleOutline(runtime, params.file),
+  imports: (runtime, params) => handleImports(runtime, params.file),
+  exports: (runtime, params) => handleExports(runtime, params.file),
+  node_at: (runtime, params) =>
+    handleNodeAt(runtime, params.file, params.line as number, params.character as number),
+  query: (runtime, params) => handleQuery(runtime, params.file, params.query as string),
+  callees: (runtime, params) =>
+    handleCallees(runtime, params.file, params.line as number, params.character as number),
+};
+
 async function executeToolAction(runtime: TreeSitterRuntime, params: ToolParams): Promise<string> {
+  const validated = validateToolParams(params);
+  if (typeof validated === "string") {
+    return validated;
+  }
+
+  return ACTION_HANDLERS[validated.action](runtime, validated);
+}
+
+function validateToolParams(params: ToolParams): ValidatedToolParams | string {
   if (!params.action) {
-    return validationError(
-      "`action` is required. Supported: outline, imports, exports, node_at, query, callees.",
-    );
+    return validationError(`\`action\` is required. Supported: ${SUPPORTED_ACTIONS_TEXT}.`);
   }
 
-  const action = toSupportedAction(params.action);
-  if (!action) {
+  if (!isTreeSitterAction(params.action)) {
     return validationError(
-      `Unknown action: ${params.action}. Supported: outline, imports, exports, node_at, query, callees`,
+      `Unknown action: ${params.action}. Supported: ${SUPPORTED_ACTIONS_TEXT}`,
     );
   }
 
@@ -101,12 +145,37 @@ async function executeToolAction(runtime: TreeSitterRuntime, params: ToolParams)
     return validationError("`file` is required for all actions.");
   }
 
-  if (action === "outline") return handleOutline(runtime, params.file);
-  if (action === "imports") return handleImports(runtime, params.file);
-  if (action === "exports") return handleExports(runtime, params.file);
-  if (action === "node_at") return handleNodeAt(runtime, params);
-  if (action === "callees") return handleCallees(runtime, params);
-  return handleQuery(runtime, params);
+  const spec = getTreeSitterActionSpec(params.action);
+  if (spec.requiresPosition) {
+    const lineError = validatePositiveInteger("line", params.line, params.action);
+    if (lineError) return lineError;
+
+    const characterError = validatePositiveInteger("character", params.character, params.action);
+    if (characterError) return characterError;
+  }
+
+  if (spec.requiresQuery && (!params.query || params.query.trim().length === 0)) {
+    return validationError("`query` is required and must be non-empty.");
+  }
+
+  return {
+    action: params.action,
+    file: params.file,
+    line: params.line,
+    character: params.character,
+    query: params.query,
+  };
+}
+
+function validatePositiveInteger(
+  field: "line" | "character",
+  value: number | undefined,
+  action: TreeSitterAction,
+): string | null {
+  if (value === undefined || !Number.isInteger(value) || value < 1) {
+    return validationError(`\`${field}\` must be a positive 1-based integer for ${action} action.`);
+  }
+  return null;
 }
 
 async function handleOutline(runtime: TreeSitterRuntime, file: string): Promise<string> {
@@ -175,18 +244,13 @@ async function handleExports(runtime: TreeSitterRuntime, file: string): Promise<
   return lines.join("\n");
 }
 
-async function handleNodeAt(runtime: TreeSitterRuntime, params: ToolParams): Promise<string> {
-  if (!Number.isInteger(params.line) || (params.line as number) < 1) {
-    return validationError("`line` must be a positive 1-based integer for node_at action.");
-  }
-  if (!Number.isInteger(params.character) || (params.character as number) < 1) {
-    return validationError("`character` must be a positive 1-based integer for node_at action.");
-  }
-
-  const file = params.file;
-  const line = params.line as number;
-  const character = params.character as number;
-  const result = await lookupNodeAt(runtime, file as string, line, character);
+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;
@@ -212,13 +276,12 @@ async function handleNodeAt(runtime: TreeSitterRuntime, params: ToolParams): Pro
   return lines.join("\n");
 }
 
-async function handleQuery(runtime: TreeSitterRuntime, params: ToolParams): Promise<string> {
-  if (!params.query || params.query.trim().length === 0) {
-    return validationError("`query` is required and must be non-empty.");
-  }
-
-  const file = params.file as string;
-  const result = await runtime.queryFile(file, params.query);
+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;
@@ -237,25 +300,12 @@ async function handleQuery(runtime: TreeSitterRuntime, params: ToolParams): Prom
   return lines.join("\n");
 }
 
-function toSupportedAction(action: string): TreeSitterAction | undefined {
-  if (["outline", "imports", "exports", "node_at", "query", "callees"].includes(action)) {
-    return action as TreeSitterAction;
-  }
-  return undefined;
-}
-
-async function handleCallees(runtime: TreeSitterRuntime, params: ToolParams): Promise<string> {
-  if (!Number.isInteger(params.line) || (params.line as number) < 1) {
-    return validationError("`line` must be a positive 1-based integer for callees action.");
-  }
-  if (!Number.isInteger(params.character) || (params.character as number) < 1) {
-    return validationError("`character` must be a positive 1-based integer for callees action.");
-  }
-
-  const file = params.file as string;
-  const line = params.line as number;
-  const character = params.character as number;
-
+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);
 

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

@@ -66,8 +66,8 @@ export interface QueryCapture {
   text: string;
 }
 
-/** Session-level Tree-sitter service. */
-export interface TreeSitterSession {
+/** Shared Tree-sitter service surface, independent of lifecycle ownership. */
+export interface TreeSitterService {
   /** Validate that a supported file can be read and parsed; does not expose the raw tree. */
   canParse(file: string): Promise<TreeSitterResult<{ file: string; language: string }>>;
   /** Run a Tree-sitter query and return all captures. */
@@ -86,10 +86,21 @@ export interface TreeSitterSession {
     line: number,
     character: number,
   ): Promise<TreeSitterResult<CalleesAtResult>>;
+}
+
+/** Owned Tree-sitter session that must release its runtime resources. */
+export interface TreeSitterSession extends TreeSitterService {
   /** Release parser and grammar resources owned by this session. */
   dispose(): void;
 }
 
+/** Session-scoped shared structural service published by the extension runtime. */
+export type SessionTreeSitterService = TreeSitterService;
+
+export type SessionTreeSitterServiceState =
+  | { kind: "ready"; service: SessionTreeSitterService }
+  | { kind: "unavailable"; reason: string };
+
 /** Supported grammar identifiers. */
 export type GrammarId =
   | "javascript"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-code-intelligence",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "SuPi Code Intelligence extension — architecture briefs, caller/callee analysis, impact assessment, and pattern search for pi",
   "license": "MIT",
   "repository": {
@@ -19,9 +19,9 @@
     "src/**/*.ts"
   ],
   "dependencies": {
-    "@mrclrchtr/supi-core": "1.4.0",
-    "@mrclrchtr/supi-lsp": "1.4.0",
-    "@mrclrchtr/supi-tree-sitter": "1.4.0"
+    "@mrclrchtr/supi-core": "1.5.0",
+    "@mrclrchtr/supi-tree-sitter": "1.5.0",
+    "@mrclrchtr/supi-lsp": "1.5.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-core",

package/src/actions/brief-action.ts

@@ -2,7 +2,7 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { TreeSitterSession } from "@mrclrchtr/supi-tree-sitter/api";
+import type { TreeSitterService } from "@mrclrchtr/supi-tree-sitter/api";
 import { buildArchitectureModel, findModuleForPath } from "../architecture.ts";
 import { generateFocusedBrief, generateProjectBrief } from "../brief.ts";
 import { withStructuralSession } from "../providers/structural-provider.ts";
@@ -123,7 +123,7 @@ async function addTreeSitterContext(input: TreeSitterContextInput): Promise<void
 
 async function addNodeContext(
   lines: string[],
-  ts: TreeSitterSession,
+  ts: TreeSitterService,
   relPath: string,
   pos: { line: number; char: number },
 ): Promise<void> {
@@ -143,7 +143,7 @@ async function addNodeContext(
 
 async function addOutlineContext(
   lines: string[],
-  ts: TreeSitterSession,
+  ts: TreeSitterService,
   relPath: string,
   line1: number,
 ): Promise<void> {
@@ -182,7 +182,7 @@ function getOutlinePrefix(kind: string): string {
 
 async function addImportsContext(
   lines: string[],
-  ts: TreeSitterSession,
+  ts: TreeSitterService,
   relPath: string,
 ): Promise<void> {
   const result = await ts.imports(relPath);
@@ -200,7 +200,7 @@ async function addImportsContext(
 
 async function addExportsContext(
   lines: string[],
-  ts: TreeSitterSession,
+  ts: TreeSitterService,
   relPath: string,
 ): Promise<void> {
   const result = await ts.exports(relPath);

package/src/code-intelligence.ts

@@ -6,20 +6,13 @@ import type { BeforeAgentStartEventResult, ExtensionAPI } from "@earendil-works/
 import { Type } from "typebox";
 import { buildArchitectureModel } from "./architecture.ts";
 import { generateOverview } from "./brief.ts";
+import { CODE_INTEL_ACTION_NAMES, type CodeIntelAction } from "./tool/action-specs.ts";
 import { promptGuidelines, promptSnippet, toolDescription } from "./tool/guidance.ts";
-import { type CodeIntelAction, executeAction } from "./tool-actions.ts";
+import { executeAction } from "./tool-actions.ts";
 
 const OVERVIEW_CUSTOM_TYPE = "code-intelligence-overview";
 
-const CodeIntelActionEnum = StringEnum([
-  "brief",
-  "callers",
-  "callees",
-  "implementations",
-  "affected",
-  "pattern",
-  "index",
-] as const);
+const CodeIntelActionEnum = StringEnum(CODE_INTEL_ACTION_NAMES);
 
 /**
  * Register the `code_intel` tool and inject a lightweight architecture overview

package/src/pattern-structured.ts

@@ -72,7 +72,7 @@ export async function getStructuredPatternMatches(
 // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: kind-specific tree-sitter matching is clearest as one helper
 async function collectMatchesForFile(
   matches: StructuredMatch[],
-  tsSession: import("@mrclrchtr/supi-tree-sitter/api").TreeSitterSession,
+  tsSession: import("@mrclrchtr/supi-tree-sitter/api").TreeSitterService,
   relFile: string,
   kind: StructuredPatternKind,
   matcher: (value: string) => boolean,

package/src/providers/structural-provider.ts

@@ -1,10 +1,22 @@
-import { createTreeSitterSession, type TreeSitterSession } from "@mrclrchtr/supi-tree-sitter/api";
+import {
+  createTreeSitterSession,
+  getSessionTreeSitterService,
+  type TreeSitterService,
+} from "@mrclrchtr/supi-tree-sitter/api";
 
-/** Run work against a short-lived Tree-sitter session and dispose it afterward. */
+/**
+ * Run work against the shared session-scoped Tree-sitter service when available,
+ * falling back to a short-lived owned session otherwise.
+ */
 export async function withStructuralSession<T>(
   cwd: string,
-  fn: (session: TreeSitterSession) => Promise<T>,
+  fn: (session: TreeSitterService) => Promise<T>,
 ): Promise<T> {
+  const current = getSessionTreeSitterService(cwd);
+  if (current.kind === "ready") {
+    return fn(current.service);
+  }
+
   const session = createTreeSitterSession(cwd);
   try {
     return await fn(session);

package/src/search-helpers.ts

@@ -2,6 +2,7 @@
 
 import { execFileSync } from "node:child_process";
 import * as path from "node:path";
+import { resolveToolPath, uriToFile as uriToFileShared } from "@mrclrchtr/supi-core/api";
 
 const LOW_SIGNAL_DIRS = new Set([
   "node_modules",
@@ -25,19 +26,8 @@ export function isLowSignalPath(filePath: string): boolean {
   return segments.some((s) => LOW_SIGNAL_DIRS.has(s));
 }
 
-/** Convert a file:// URI to a file path, matching the normalization in supi-lsp. */
-export function uriToFile(uri: string): string {
-  if (!uri.startsWith("file://")) return uri;
-  let filePath = decodeURIComponent(uri.slice(7));
-  if (
-    process.platform === "win32" &&
-    filePath.startsWith("/") &&
-    /^[A-Za-z]:/.test(filePath.slice(1))
-  ) {
-    filePath = filePath.slice(1);
-  }
-  return filePath;
-}
+/** Convert a file:// URI to a file path, matching the shared SuPi normalization. */
+export const uriToFile = uriToFileShared;
 
 /** Check whether a resolved file path is inside the current project (within cwd, not under node_modules or .pnpm). */
 export function isInProjectPath(filePath: string, cwd: string): boolean {
@@ -59,8 +49,7 @@ export function escapeRegex(s: string): string {
 
 /** Normalize a file/path value: strip leading @, resolve relative to cwd. */
 export function normalizePath(input: string, cwd: string): string {
-  const stripped = input.startsWith("@") ? input.slice(1) : input;
-  return path.resolve(cwd, stripped);
+  return resolveToolPath(cwd, input);
 }
 
 export interface RgMatch {

package/src/tool/action-specs.ts

@@ -0,0 +1,66 @@
+/**
+ * Single source of truth for the public `code_intel` action surface.
+ *
+ * The action list, prompt guidance, and router validation should derive from
+ * these specs so the high-level orchestration tool stays internally coherent.
+ */
+export const CODE_INTEL_ACTION_SPECS = [
+  {
+    name: "brief",
+    promptGuideline:
+      'Use code_intel with `action: "brief"` for a project, package, directory, file, or anchored-position brief before opening more files.',
+  },
+  {
+    name: "callers",
+    promptGuideline:
+      'Use code_intel with `action: "callers"` to find who invokes a symbol or file-level surface before falling back to text search.',
+  },
+  {
+    name: "callees",
+    promptGuideline:
+      'Use code_intel with `action: "callees"` for outgoing calls from a function or method at a known `file`, `line`, and `character`.',
+  },
+  {
+    name: "implementations",
+    promptGuideline:
+      'Use code_intel with `action: "implementations"` to find which concrete types implement a declaration.',
+  },
+  {
+    name: "affected",
+    promptGuideline:
+      'Use code_intel with `action: "affected"` before edits for blast radius, downstream modules, risk, and likely follow-up checks or tests.',
+  },
+  {
+    name: "pattern",
+    promptGuideline:
+      'Use code_intel with `action: "pattern"` for bounded search within a path; `pattern` is literal by default, set `regex: true` for regex, and use `kind: "definition" | "export" | "import"` for structured search.',
+  },
+  {
+    name: "index",
+    promptGuideline:
+      'Use code_intel with `action: "index"` for a project map, top-level directories, language mix, or landmark files.',
+  },
+] as const;
+
+export type CodeIntelAction = (typeof CODE_INTEL_ACTION_SPECS)[number]["name"];
+export type CodeIntelActionSpec = (typeof CODE_INTEL_ACTION_SPECS)[number];
+
+/** Ordered action names for schemas, validation messages, and docs. */
+export const CODE_INTEL_ACTION_NAMES = CODE_INTEL_ACTION_SPECS.map(
+  (spec) => spec.name,
+) as readonly CodeIntelAction[];
+
+const CODE_INTEL_ACTION_NAME_SET = new Set<string>(CODE_INTEL_ACTION_NAMES);
+
+/** Check whether a runtime string is a supported `code_intel` action. */
+export function isCodeIntelAction(action: string): action is CodeIntelAction {
+  return CODE_INTEL_ACTION_NAME_SET.has(action);
+}
+
+/** Format the public action list for validation messages and docs. */
+export function formatCodeIntelActionList(options?: { fenced?: boolean }): string {
+  if (options?.fenced) {
+    return CODE_INTEL_ACTION_NAMES.map((name) => `\`${name}\``).join(", ");
+  }
+  return CODE_INTEL_ACTION_NAMES.join(", ");
+}

package/src/tool/guidance.ts

@@ -1,18 +1,15 @@
 // Prompt guidance and tool description for the code_intel tool.
 
+import { CODE_INTEL_ACTION_SPECS, formatCodeIntelActionList } from "./action-specs.ts";
+
 export const toolDescription = `Code intelligence tool — codebase orientation, semantic relationships, impact analysis, and scoped search.
 
-Actions: brief, callers, callees, implementations, affected, pattern, index.
+Actions: ${formatCodeIntelActionList()}.
 
 Use code_intel to localize relevant files before precise drill-down: summarize a project/package/file, find callers/callees/implementations, estimate blast radius, or search within a scope. Prefer lsp_lookup, lsp_document_symbols, lsp_workspace_symbols, lsp_diagnostics, lsp_refactor, and lsp_recover for semantic drill-down once the target is known; use tree_sitter for exact syntax and read/rg once you know the file. line and character are 1-based and require file. pattern is literal unless regex is true; kind supports definition, export, or import. Relative paths resolve from cwd, and leading @ on path/file is stripped.`;
 
 export const promptGuidelines = [
-  'Use code_intel with `action: "brief"` for a project, package, directory, file, or anchored-position brief before opening more files.',
-  'Use code_intel with `action: "index"` for a project map, top-level directories, language mix, or landmark files.',
-  'Use code_intel with `action: "callers"` or `action: "implementations"` to find who invokes a symbol or which concrete types implement a declaration.',
-  'Use code_intel with `action: "callees"` for outgoing calls from a function or method at a known `file`, `line`, and `character`.',
-  'Use code_intel with `action: "affected"` before edits for blast radius, downstream modules, risk, and likely follow-up checks or tests.',
-  'Use code_intel with `action: "pattern"` for bounded search within a path; `pattern` is literal by default, set `regex: true` for regex, and use `kind: "definition" | "export" | "import"` for structured search.',
+  ...CODE_INTEL_ACTION_SPECS.map((spec) => spec.promptGuideline),
   "Use code_intel with `file`, `line`, and `character` for anchored positions; do not pair `line` or `character` with `path`.",
   "Use code_intel first when the area is not yet localized; switch to lsp_lookup, lsp_document_symbols, lsp_workspace_symbols, lsp_diagnostics, lsp_refactor, or lsp_recover for semantic drill-down once code_intel narrows the target.",
 ];

package/src/tool-actions.ts

@@ -9,16 +9,14 @@ import { executeImplementationsAction } from "./actions/implementations-action.t
 import { executeIndexAction } from "./actions/index-action.ts";
 import { executePatternAction } from "./actions/pattern-action.ts";
 import { normalizePath } from "./search-helpers.ts";
+import {
+  type CodeIntelAction,
+  formatCodeIntelActionList,
+  isCodeIntelAction,
+} from "./tool/action-specs.ts";
 import type { CodeIntelResult } from "./types.ts";
 
-export type CodeIntelAction =
-  | "brief"
-  | "callers"
-  | "callees"
-  | "implementations"
-  | "affected"
-  | "pattern"
-  | "index";
+export type { CodeIntelAction } from "./tool/action-specs.ts";
 
 /** Flat parameter bag shared by `code_intel` action handlers. */
 export interface ActionParams {
@@ -40,15 +38,20 @@ export interface ActionParams {
   summary?: boolean;
 }
 
-const SUPPORTED_ACTIONS = new Set<string>([
-  "brief",
-  "callers",
-  "callees",
-  "implementations",
-  "affected",
-  "pattern",
-  "index",
-]);
+type ActionHandler = (
+  params: ActionParams,
+  cwd: string,
+) => CodeIntelResult | Promise<CodeIntelResult>;
+
+const ACTION_HANDLERS: Record<CodeIntelAction, ActionHandler> = {
+  brief: executeBriefAction,
+  callers: executeCallersAction,
+  callees: executeCalleesAction,
+  implementations: executeImplementationsAction,
+  affected: executeAffectedAction,
+  pattern: executePatternAction,
+  index: (_params, cwd) => executeIndexAction(cwd),
+};
 
 /**
  * Main action dispatcher — validates params and routes to specific action handlers.
@@ -62,32 +65,12 @@ export async function executeAction(
   const error = validateParams(params, cwd);
   if (error) return { content: error, details: undefined };
 
-  switch (params.action) {
-    case "brief":
-      return executeBriefAction(params, cwd);
-    case "callers":
-      return executeCallersAction(params, cwd);
-    case "callees":
-      return executeCalleesAction(params, cwd);
-    case "implementations":
-      return executeImplementationsAction(params, cwd);
-    case "affected":
-      return executeAffectedAction(params, cwd);
-    case "pattern":
-      return executePatternAction(params, cwd);
-    case "index":
-      return executeIndexAction(cwd);
-    default:
-      return {
-        content: `**Error:** Unknown action \`${params.action}\`.`,
-        details: undefined,
-      };
-  }
+  return ACTION_HANDLERS[params.action](params, cwd);
 }
 
 function validateParams(params: ActionParams, cwd: string): string | null {
-  if (!params.action || !SUPPORTED_ACTIONS.has(params.action)) {
-    return `**Error:** Unknown action \`${params.action ?? "(none)"}\`. Supported: \`brief\`, \`callers\`, \`callees\`, \`implementations\`, \`affected\`, \`pattern\`, \`index\`.`;
+  if (!params.action || !isCodeIntelAction(params.action)) {
+    return `**Error:** Unknown action \`${params.action ?? "(none)"}\`. Supported: ${formatCodeIntelActionList({ fenced: true })}.`;
   }
 
   if (params.path && (params.line != null || params.character != null)) {