@mrclrchtr/supi-code-intelligence 1.7.0 → 1.9.0

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

@@ -0,0 +1,117 @@
+/**
+ * Single source of truth for the split `tree_sitter_*` tool surface.
+ *
+ * Tool registration, guidance, and parameter validation should derive
+ * from these specs so the public surface does not drift from the
+ * metadata that drives it.
+ */
+
+import { Type } from "typebox";
+
+// ── Shared parameter fragments ─────────────────────────────────────────
+
+const FileParam = Type.String({ description: "File path" });
+const LineParam = Type.Number({ description: "1-based line", minimum: 1 });
+const CharacterParam = Type.Number({
+  description: "1-based UTF-16 column",
+  minimum: 1,
+});
+const QueryParam = Type.String({ description: "Tree-sitter query" });
+
+export const PARAM_SCHEMAS = {
+  fileOnly: Type.Object({ file: FileParam }, { additionalProperties: false }),
+  fileLineChar: Type.Object(
+    { file: FileParam, line: LineParam, character: CharacterParam },
+    { additionalProperties: false },
+  ),
+  fileQuery: Type.Object({ file: FileParam, query: QueryParam }, { additionalProperties: false }),
+} as const;
+
+export type ParamSchemaKey = keyof typeof PARAM_SCHEMAS;
+
+// ── Tool names ─────────────────────────────────────────────────────────
+
+export const TREE_SITTER_TOOL_NAMES = [
+  "tree_sitter_outline",
+  "tree_sitter_imports",
+  "tree_sitter_exports",
+  "tree_sitter_node_at",
+  "tree_sitter_query",
+  "tree_sitter_callees",
+] as const;
+
+export type TreeSitterToolName = (typeof TREE_SITTER_TOOL_NAMES)[number];
+
+// ── Per-tool metadata ──────────────────────────────────────────────────
+
+export interface TreeSitterToolSpec {
+  name: TreeSitterToolName;
+  label: string;
+  description: string;
+  promptSnippet: string;
+  promptGuidelines: string[];
+  paramSchemaKey: ParamSchemaKey;
+}
+
+export const TREE_SITTER_TOOL_SPECS: readonly TreeSitterToolSpec[] = [
+  {
+    name: "tree_sitter_outline",
+    label: "Tree-sitter Outline",
+    description: "Shallow JS/TS outline of top-level declarations and supported members.",
+    promptSnippet: "tree_sitter_outline — quick JS/TS outline",
+    promptGuidelines: ["Use tree_sitter_outline(file) for a quick JS/TS outline."],
+    paramSchemaKey: "fileOnly",
+  },
+  {
+    name: "tree_sitter_imports",
+    label: "Tree-sitter Imports",
+    description: "List imports in a JS/TS file.",
+    promptSnippet: "tree_sitter_imports — JS/TS imports",
+    promptGuidelines: ["Use tree_sitter_imports(file) to inspect JS/TS dependencies."],
+    paramSchemaKey: "fileOnly",
+  },
+  {
+    name: "tree_sitter_exports",
+    label: "Tree-sitter Exports",
+    description: "List exports in a JS/TS file.",
+    promptSnippet: "tree_sitter_exports — JS/TS exports",
+    promptGuidelines: ["Use tree_sitter_exports(file) to inspect JS/TS exports."],
+    paramSchemaKey: "fileOnly",
+  },
+  {
+    name: "tree_sitter_node_at",
+    label: "Tree-sitter Node At",
+    description: "Show the syntax node and ancestry at a file position.",
+    promptSnippet: "tree_sitter_node_at — syntax node at a position",
+    promptGuidelines: ["Use tree_sitter_node_at(file,line,character) for the exact syntax node."],
+    paramSchemaKey: "fileLineChar",
+  },
+  {
+    name: "tree_sitter_query",
+    label: "Tree-sitter Query",
+    description: "Run a custom Tree-sitter query against a file.",
+    promptSnippet: "tree_sitter_query — custom AST query",
+    promptGuidelines: ["Use tree_sitter_query(file,query) for custom AST matching."],
+    paramSchemaKey: "fileQuery",
+  },
+  {
+    name: "tree_sitter_callees",
+    label: "Tree-sitter Callees",
+    description: "List outgoing callees from the enclosing scope at a file position.",
+    promptSnippet: "tree_sitter_callees — outgoing callees",
+    promptGuidelines: ["Use tree_sitter_callees(file,line,character) for outgoing calls."],
+    paramSchemaKey: "fileLineChar",
+  },
+];
+
+// ── Lookup helpers ─────────────────────────────────────────────────────
+
+const TREE_SITTER_TOOL_SPEC_MAP = new Map<TreeSitterToolName, TreeSitterToolSpec>(
+  TREE_SITTER_TOOL_SPECS.map((spec) => [spec.name, spec]),
+);
+
+export function getTreeSitterToolSpec(toolName: TreeSitterToolName): TreeSitterToolSpec {
+  const spec = TREE_SITTER_TOOL_SPEC_MAP.get(toolName);
+  if (!spec) throw new Error(`Unknown tree_sitter tool: ${toolName}`);
+  return spec;
+}

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

@@ -1,333 +1,47 @@
-// 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 { getDefaultWorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
 import { TreeSitterRuntime } from "./session/runtime.ts";
+import {
+  registerTreeSitterCapabilities,
+  unregisterTreeSitterCapabilities,
+} from "./session/runtime-registration.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 treeSitterRuntime: TreeSitterRuntime | undefined;
   let activeCwd: string | null = null;
+  const workspaceRuntime = getDefaultWorkspaceRuntime();
+
+  registerFocusedTreeSitterTools(pi, () => treeSitterRuntime);
 
   pi.on("session_start", (_event, ctx) => {
-    if (runtime && activeCwd) {
+    if (treeSitterRuntime && activeCwd) {
+      unregisterTreeSitterCapabilities(workspaceRuntime, activeCwd);
       clearSessionTreeSitterService(activeCwd);
-      runtime.dispose();
+      treeSitterRuntime.dispose();
     }
 
     activeCwd = ctx.cwd;
-    runtime = new TreeSitterRuntime(ctx.cwd);
-    setSessionTreeSitterService(ctx.cwd, createTreeSitterService(runtime));
+    treeSitterRuntime = new TreeSitterRuntime(ctx.cwd);
+    const service = createTreeSitterService(treeSitterRuntime);
+    setSessionTreeSitterService(ctx.cwd, service);
+    registerTreeSitterCapabilities(workspaceRuntime, ctx.cwd, service);
   });
 
   pi.on("session_shutdown", () => {
     if (activeCwd) {
+      unregisterTreeSitterCapabilities(workspaceRuntime, activeCwd);
       clearSessionTreeSitterService(activeCwd);
     }
-    runtime?.dispose();
-    runtime = undefined;
+    treeSitterRuntime?.dispose();
+    treeSitterRuntime = 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.7.0",
+  "version": "1.9.0",
   "description": "SuPi Code Intelligence extension — architecture briefs, caller/callee analysis, impact assessment, and pattern search for pi",
   "license": "MIT",
   "repository": {
@@ -19,11 +19,13 @@
     "src/**/*.ts"
   ],
   "dependencies": {
-    "@mrclrchtr/supi-core": "1.7.0",
-    "@mrclrchtr/supi-tree-sitter": "1.7.0",
-    "@mrclrchtr/supi-lsp": "1.7.0"
+    "@mrclrchtr/supi-code-runtime": "1.9.0",
+    "@mrclrchtr/supi-core": "1.9.0",
+    "@mrclrchtr/supi-lsp": "1.9.0",
+    "@mrclrchtr/supi-tree-sitter": "1.9.0"
   },
   "bundledDependencies": [
+    "@mrclrchtr/supi-code-runtime",
     "@mrclrchtr/supi-core",
     "@mrclrchtr/supi-lsp",
     "@mrclrchtr/supi-tree-sitter"
@@ -48,9 +50,9 @@
     "extensions": [
       "./src/extension.ts",
       "node_modules/@mrclrchtr/supi-lsp/src/extension.ts",
-      "node_modules/@mrclrchtr/supi-core/src/extension.ts",
       "node_modules/@mrclrchtr/supi-tree-sitter/src/extension.ts"
-    ]
+    ],
+    "image": "https://raw.githubusercontent.com/mrclrchtr/supi/main/packages/supi-code-intelligence/assets/logo.png"
   },
   "main": "src/api.ts",
   "exports": {

package/src/api.ts

@@ -1,14 +1,30 @@
 // Reusable architecture and target-resolution helpers for peer extensions.
+// Non-provider contracts for the code-understanding stack.
 
-export type { ArchitectureModel, DependencyEdge, ModuleInfo } from "./architecture.ts";
+// Provider contracts re-exported from the shared runtime for convenience.
+export type {
+  SemanticProvider,
+  StructuralProvider,
+  StructuralResult,
+} from "@mrclrchtr/supi-code-runtime/api";
+export { generateFocusedBrief, generateOverview, generateProjectBrief } from "./brief.ts";
+// Architecture model hosted locally in supi-code-intelligence.
+export type {
+  ArchitectureModel,
+  DependencyEdge,
+  ModuleInfo,
+} from "./model.ts";
 export {
   buildArchitectureModel,
   findModuleForPath,
   getDependencies,
   getDependents,
-} from "./architecture.ts";
-
-export { generateFocusedBrief, generateOverview, generateProjectBrief } from "./brief.ts";
+} from "./model.ts";
+// Substrate adapters (type aliases for provider contracts)
+export type {
+  SemanticSubstrate,
+  StructuralSubstrate,
+} from "./substrates/types.ts";
 export type { ResolvedTarget, TargetResolutionResult } from "./target-resolution.ts";
 export {
   normalizePath,
@@ -16,13 +32,27 @@ export {
   resolveSymbolTarget,
   toZeroBased,
 } from "./target-resolution.ts";
-
+// Shared canonical types
 export type {
   AffectedDetails,
   BriefDetails,
+  CalleesData,
   CodeIntelResult,
+  CodeLocation,
+  CodePosition,
+  CodeResult,
+  CodeSymbol,
   ConfidenceMode,
   DisambiguationCandidate,
+  ExportData,
+  ImportData,
   MapDetails,
+  NodeAtData,
+  OutlineData,
+  ProviderAvailability,
   SearchDetails,
+  SourceRange,
 } from "./types.ts";
+// Code provider — reads capabilities from the shared workspace runtime.
+export type { CodeProvider, CodeProviderState } from "./workspace/request-context.ts";
+export { getCodeProvider } from "./workspace/request-context.ts";

package/src/brief-focused.ts

@@ -3,9 +3,9 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { ArchitectureModel } from "./architecture.ts";
-import { findModuleForPath, getDependencies, getDependents } from "./architecture.ts";
 import { formatGitContext, gatherGitContext } from "./git-context.ts";
+import type { ArchitectureModel } from "./model.ts";
+import { findModuleForPath, getDependencies, getDependents } from "./model.ts";
 import {
   appendPrioritySignalsSection,
   summarizePrioritySignalsForFiles,

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 type { ArchitectureModel } from "./model.ts";
+import { getDependents } from "./model.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_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 ────────────────────────────────────────────────