@mrclrchtr/supi-code-intelligence 1.6.0 → 1.8.0

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

@@ -1,41 +1,20 @@
-// Tree-sitter extension entry point — registers the `tree_sitter` tool with pi.
+// Tree-sitter extension entry point — registers 6 focused tree_sitter_* tools.
 
-import { StringEnum } from "@earendil-works/pi-ai";
 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,
-  MAX_ITEMS,
-  truncate,
-  truncatedNotice,
-  truncateText,
-  validationError,
-} from "./tool/formatting.ts";
-import { promptGuidelines, promptSnippet, toolDescription } from "./tool/guidance.ts";
-import { collectOutline } from "./tool/outline.ts";
-import { extractExports, extractImports, lookupCalleesAt, lookupNodeAt } from "./tool/structure.ts";
-
-const TreeSitterActionEnum = StringEnum(TREE_SITTER_ACTION_NAMES);
+import { registerFocusedTreeSitterTools } from "./tool/register-tools.ts";
 
 export default function treeSitterExtension(pi: ExtensionAPI) {
   let runtime: TreeSitterRuntime | undefined;
   let activeCwd: string | null = null;
 
+  registerFocusedTreeSitterTools(pi, () => runtime);
+
   pi.on("session_start", (_event, ctx) => {
     if (runtime && activeCwd) {
       clearSessionTreeSitterService(activeCwd);
@@ -55,279 +34,4 @@ export default function treeSitterExtension(pi: ExtensionAPI) {
     runtime = undefined;
     activeCwd = null;
   });
-
-  pi.registerTool({
-    name: "tree_sitter",
-    label: "Tree-sitter",
-    description: toolDescription,
-    promptGuidelines,
-    promptSnippet,
-    parameters: Type.Object({
-      action: TreeSitterActionEnum,
-      file: Type.Optional(Type.String({ description: "File path (relative or absolute)" })),
-      line: Type.Optional(Type.Number({ description: "1-based line number" })),
-      character: Type.Optional(Type.Number({ description: "1-based column number (UTF-16)" })),
-      query: Type.Optional(Type.String({ description: "Tree-sitter query string" })),
-    }),
-    // biome-ignore lint/complexity/useMaxParams: pi ToolDefinition.execute signature
-    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-      if (!runtime) {
-        return {
-          content: [
-            { type: "text", text: "Tree-sitter not initialized. Start a new session first." },
-          ],
-          details: {},
-        };
-      }
-
-      const text = await executeToolAction(runtime, params);
-      return {
-        content: [{ type: "text", text }],
-        details: {},
-      };
-    },
-  });
-}
-
-type ToolParams = {
-  action?: string;
-  file?: string;
-  line?: number;
-  character?: number;
-  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: ${SUPPORTED_ACTIONS_TEXT}.`);
-  }
-
-  if (!isTreeSitterAction(params.action)) {
-    return validationError(
-      `Unknown action: ${params.action}. Supported: ${SUPPORTED_ACTIONS_TEXT}`,
-    );
-  }
-
-  if (!params.file) {
-    return validationError("`file` is required for all actions.");
-  }
-
-  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> {
-  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");
-}
-
-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");
-}
-
-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");
-}
-
-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");
-}
-
-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");
-}
-
-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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-code-intelligence",
-  "version": "1.6.0",
+  "version": "1.8.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.6.0",
-    "@mrclrchtr/supi-lsp": "1.6.0",
-    "@mrclrchtr/supi-tree-sitter": "1.6.0"
+    "@mrclrchtr/supi-lsp": "1.8.0",
+    "@mrclrchtr/supi-core": "1.8.0",
+    "@mrclrchtr/supi-tree-sitter": "1.8.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-core",

package/src/api.ts

@@ -9,6 +9,21 @@ export {
 } from "./architecture.ts";
 
 export { generateFocusedBrief, generateOverview, generateProjectBrief } from "./brief.ts";
+export { createSemanticSubstrate } from "./substrates/lsp-adapter.ts";
+export { createStructuralSubstrate } from "./substrates/tree-sitter-adapter.ts";
+
+// Substrate adapters
+export type {
+  CalleesData,
+  CodeSymbol,
+  ExportData,
+  ImportData,
+  NodeAtData,
+  OutlineData,
+  SemanticSubstrate,
+  StructuralResult,
+  StructuralSubstrate,
+} from "./substrates/types.ts";
 export type { ResolvedTarget, TargetResolutionResult } from "./target-resolution.ts";
 export {
   normalizePath,
@@ -23,5 +38,6 @@ export type {
   CodeIntelResult,
   ConfidenceMode,
   DisambiguationCandidate,
+  MapDetails,
   SearchDetails,
 } from "./types.ts";

package/src/architecture.ts

@@ -3,7 +3,7 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { findProjectRoot, isWithinOrEqual, walkProject } from "@mrclrchtr/supi-core/api";
+import { findProjectRoot, isWithinOrEqual, walkProject } from "@mrclrchtr/supi-core/project";
 
 // ── Types ─────────────────────────────────────────────────────────────
 

package/src/brief-focused.ts

@@ -183,13 +183,13 @@ function addDependentsSection(
       const depShort = dep.name.replace(/^@[^/]+\//, "");
       lines.push(`- ${depShort} (\`${dep.relativePath}\`)`);
     }
-    nextQueries.push("`code_intel affected` before modifying exports from this module");
+    nextQueries.push("`code_affected` before modifying exports from this module");
   }
 
   if (mod.entrypoints.length > 0) {
     const ep = mod.entrypoints[0];
     nextQueries.push(
-      `\`code_intel brief\` with \`file: "${mod.relativePath}/${ep.replace(/^\.\//, "")}"\` for entrypoint details`,
+      `\`code_brief\` with \`file: "${mod.relativePath}/${ep.replace(/^\.\//, "")}"\` for entrypoint details`,
     );
   }
 }
@@ -276,7 +276,7 @@ function formatNonModuleDir(ctx: NonModuleDirContext): void {
     lines.push(`- Exports: ${summary.exportCount}`);
     lines.push("");
     nextQueries.push(
-      `\`code_intel pattern\` with \`path: "${relPath || originalPath}"\` to inspect a specific nested symbol`,
+      `\`code_pattern\` with \`path: "${relPath || originalPath}"\` to inspect a specific nested symbol`,
     );
   }
 
@@ -334,11 +334,11 @@ function generateFileBrief(
   }
 
   nextQueries.push(
-    `\`code_intel callers\` with \`file: "${relPath}"\` and a line/character for call-site analysis`,
+    `\`code_relations\` with \`kind: "callers"\`, \`file: "${relPath}"\`, and a line/character for call-site analysis`,
   );
   if (mod) {
     nextQueries.push(
-      `\`code_intel brief\` with \`path: "${mod.relativePath}"\` for the containing module overview`,
+      `\`code_brief\` with \`path: "${mod.relativePath}"\` for the containing module overview`,
     );
   }
 

package/src/brief.ts

@@ -1,9 +1,12 @@
-// Brief generation — compact overviews and project briefs from the architecture model.
+// Public facade — delegates to the new use-case and presentation layers.
+// Existing callers (api.ts, index.ts, code-intelligence.ts) remain compatible.
 
 import type { ArchitectureModel } from "./architecture.ts";
 import { getDependents } from "./architecture.ts";
 import { formatGitContext, gatherGitContext } from "./git-context.ts";
+import { renderOverview } from "./presentation/markdown/overview.ts";
 import type { BriefDetails, ConfidenceMode } from "./types.ts";
+import { buildOverviewData } from "./use-case/build-overview.ts";
 
 // Re-export focused brief generation
 export { generateFocusedBrief } from "./brief-focused.ts";
@@ -13,60 +16,13 @@ export { generateFocusedBrief } from "./brief-focused.ts";
 /**
  * Generate a compact architecture overview for first-turn session injection.
  * Targets roughly 500 tokens or less; prefers dense module-edge format.
+ *
+ * Delegates to use-case/build-overview + presentation/markdown/overview.
  */
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: overview formatting with module/edge budget logic
 export function generateOverview(model: ArchitectureModel): string | null {
-  if (model.modules.length === 0) return null;
-
-  const lines: string[] = [];
-  lines.push("# Project: Code Intelligence Overview");
-  lines.push("");
-
-  if (model.name) {
-    lines.push(`**${model.name}**${model.description ? ` — ${model.description}` : ""}`);
-    lines.push("");
-  }
-
-  // Dense module-edge format (budget: ~8 modules, ~8 edges)
-  const modules = model.modules.slice(0, 8);
-  const dependedOn = new Set(model.edges.map((e) => e.to));
-
-  lines.push("## Modules");
-  lines.push("");
-
-  for (const mod of modules) {
-    const isLeaf = !dependedOn.has(mod.name);
-    const deps = mod.internalDeps.filter((d) => modules.some((m) => m.name === d));
-    const shortName = mod.name.replace(/^@[^/]+\//, "");
-
-    if (deps.length === 0) {
-      lines.push(
-        `- **${shortName}**${isLeaf ? " (leaf)" : ""}${mod.description ? ` — ${mod.description}` : ""}`,
-      );
-    } else {
-      const depNames = deps.slice(0, 4).map((d) => d.replace(/^@[^/]+\//, ""));
-      const depStr = depNames.join(", ");
-      const suffix = deps.length > 4 ? ` +${deps.length - 4} more` : "";
-      lines.push(
-        `- **${shortName}** → ${depStr}${suffix}${mod.description ? ` — ${mod.description}` : ""}`,
-      );
-    }
-  }
-
-  if (model.modules.length > 8) {
-    lines.push(`- _+${model.modules.length - 8} more modules omitted_`);
-  }
-
-  lines.push("");
-
-  const gitCtx = gatherGitContext(model.root);
-  if (gitCtx) {
-    lines.push(formatGitContext(gitCtx));
-  }
-
-  lines.push("_Use `code_intel brief` for deeper context on any module or file._");
-
-  return lines.join("\n");
+  const data = buildOverviewData(model);
+  if (!data) return null;
+  return renderOverview(data);
 }
 
 // ── Full-project brief ────────────────────────────────────────────────
@@ -208,11 +164,11 @@ function buildNextQueries(model: ArchitectureModel, publicSurfaces: string[]): s
   if (model.modules.length > 0) {
     const firstMod = model.modules[0];
     nextQueries.push(
-      `\`code_intel brief\` with \`path: "${firstMod.relativePath}"\` for a focused module brief`,
+      `\`code_brief\` with \`path: "${firstMod.relativePath}"\` for a focused module brief`,
     );
   }
   if (publicSurfaces.length > 0) {
-    nextQueries.push("`code_intel affected` before modifying shared exports");
+    nextQueries.push("`code_affected` before modifying shared exports");
   }
   return nextQueries;
 }

package/src/code-intelligence.ts

@@ -1,22 +1,17 @@
-// Code Intelligence extension entry point — registers the `code_intel` tool with pi.
-// Provides architecture briefs, caller/callee analysis, impact assessment, and pattern search.
+// Code Intelligence extension entry point — registers the focused code-intelligence tools.
+// Provides architecture briefs, project maps, relationship tracing, impact assessment, and pattern search.
 
-import { StringEnum } from "@earendil-works/pi-ai";
 import type { BeforeAgentStartEventResult, ExtensionAPI } from "@earendil-works/pi-coding-agent";
-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 { executeAction } from "./tool-actions.ts";
+import { renderOverview } from "./presentation/markdown/overview.ts";
+import { registerCodeIntelligenceTools } from "./tool/register-tools.ts";
+import { buildOverviewData } from "./use-case/build-overview.ts";
 
 const OVERVIEW_CUSTOM_TYPE = "code-intelligence-overview";
 
-const CodeIntelActionEnum = StringEnum(CODE_INTEL_ACTION_NAMES);
-
 /**
- * Register the `code_intel` tool and inject a lightweight architecture overview
- * once per session.
+ * Register the focused code-intelligence tools and inject a lightweight
+ * architecture overview once per session.
  */
 export default function codeIntelligenceExtension(pi: ExtensionAPI) {
   let hasInjectedOverview = false;
@@ -43,7 +38,10 @@ export default function codeIntelligenceExtension(pi: ExtensionAPI) {
       const model = await buildArchitectureModel(ctx.cwd);
       if (!model || model.modules.length === 0) return;
 
-      const overview = generateOverview(model);
+      const data = buildOverviewData(model);
+      if (!data) return;
+
+      const overview = renderOverview(data);
       if (!overview) return;
 
       return {
@@ -56,68 +54,5 @@ export default function codeIntelligenceExtension(pi: ExtensionAPI) {
     },
   );
 
-  pi.registerTool({
-    name: "code_intel",
-    label: "Code Intelligence",
-    description: toolDescription,
-    parameters: Type.Object({
-      action: CodeIntelActionEnum,
-      path: Type.Optional(
-        Type.String({ description: "Scope or focus path (package, directory, or file)" }),
-      ),
-      file: Type.Optional(
-        Type.String({
-          description:
-            "Anchored target file (use with line/character) or a file-level semantic target for brief/callers/affected",
-        }),
-      ),
-      line: Type.Optional(Type.Number({ description: "1-based line number for anchored target" })),
-      character: Type.Optional(
-        Type.Number({ description: "1-based character column (UTF-16) for anchored target" }),
-      ),
-      symbol: Type.Optional(
-        Type.String({ description: "Symbol name for discovery-based resolution" }),
-      ),
-      pattern: Type.Optional(
-        Type.String({
-          description: "Text search pattern (pattern action only; literal by default)",
-        }),
-      ),
-      regex: Type.Optional(
-        Type.Boolean({
-          description: "Use regex semantics for pattern action (default: false, literal search)",
-        }),
-      ),
-      kind: Type.Optional(
-        Type.String({
-          description:
-            "Symbol kind filter for discovery, or pattern kind (`definition` | `export` | `import`) for structured searches",
-        }),
-      ),
-      exportedOnly: Type.Optional(
-        Type.Boolean({ description: "Limit discovery to exported symbols" }),
-      ),
-      maxResults: Type.Optional(Type.Number({ description: "Maximum results to return" })),
-      contextLines: Type.Optional(Type.Number({ description: "Context lines around matches" })),
-      summary: Type.Optional(
-        Type.Boolean({
-          description:
-            "Aggregate counts by directory instead of line-level matches (pattern action only)",
-        }),
-      ),
-    }),
-    promptSnippet,
-    promptGuidelines,
-    // biome-ignore lint/complexity/useMaxParams: pi ToolDefinition.execute signature
-    execute: async (_toolCallId, params, _signal, _onUpdate, ctx) => {
-      const { content, details } = await executeAction(
-        params as unknown as { action: CodeIntelAction } & Record<string, unknown>,
-        { cwd: ctx.cwd },
-      );
-      return {
-        content: [{ type: "text", text: content }],
-        details,
-      };
-    },
-  });
+  registerCodeIntelligenceTools(pi);
 }

package/src/index.ts

@@ -10,6 +10,21 @@ export {
 } from "./architecture.ts";
 
 export { generateFocusedBrief, generateOverview, generateProjectBrief } from "./brief.ts";
+export { createSemanticSubstrate } from "./substrates/lsp-adapter.ts";
+export { createStructuralSubstrate } from "./substrates/tree-sitter-adapter.ts";
+
+// Substrate adapters
+export type {
+  CalleesData,
+  CodeSymbol,
+  ExportData,
+  ImportData,
+  NodeAtData,
+  OutlineData,
+  SemanticSubstrate,
+  StructuralResult,
+  StructuralSubstrate,
+} from "./substrates/types.ts";
 export type { ResolvedTarget, TargetResolutionResult } from "./target-resolution.ts";
 export {
   normalizePath,
@@ -24,5 +39,6 @@ export type {
   CodeIntelResult,
   ConfidenceMode,
   DisambiguationCandidate,
+  MapDetails,
   SearchDetails,
 } from "./types.ts";