@mrclrchtr/supi-code-intelligence 1.7.0 → 1.8.0

package/src/code-intelligence.ts

@@ -3,8 +3,9 @@
 
 import type { BeforeAgentStartEventResult, ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { buildArchitectureModel } from "./architecture.ts";
-import { generateOverview } from "./brief.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";
 
@@ -37,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 {

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,

package/src/pattern-structured.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { withStructuralSession } from "./providers/structural-provider.ts";
 import type { CodeQueryParams as ActionParams } from "./query-params.ts";
+import type { StructuralSubstrate } from "./substrates/types.ts";
 
 export const STRUCTURED_PATTERN_FILE_CAP = 200;
 const STRUCTURED_PATTERN_TIMEOUT_MS = 10_000;
@@ -25,11 +25,13 @@ export function isStructuredPatternKind(kind: string | undefined): kind is Struc
   return kind === "definition" || kind === "export" || kind === "import";
 }
 
+// biome-ignore lint/complexity/useMaxParams: substrate injection keeps related inputs explicit for readability
 export async function getStructuredPatternMatches(
   params: ActionParams & { pattern: string; kind: StructuredPatternKind },
   scopePath: string,
   cwd: string,
   relScope: string,
+  structural: StructuralSubstrate,
 ): Promise<StructuredPatternResult | string | null> {
   const deadline = Date.now() + STRUCTURED_PATTERN_TIMEOUT_MS;
   const collected = collectStructuredFiles(scopePath, deadline);
@@ -43,26 +45,24 @@ export async function getStructuredPatternMatches(
   }
 
   try {
-    return await withStructuralSession(cwd, async (tsSession) => {
-      const matches: StructuredMatch[] = [];
-      let timedOut = collected.timedOut;
-
-      for (const [index, file] of collected.files.entries()) {
-        if (Date.now() > deadline) {
-          collected.omittedCount += collected.files.length - index;
-          timedOut = true;
-          break;
-        }
-        const relFile = path.relative(cwd, file);
-        await collectMatchesForFile(matches, tsSession, relFile, params.kind, matcher);
+    const matches: StructuredMatch[] = [];
+    let timedOut = collected.timedOut;
+
+    for (const [index, file] of collected.files.entries()) {
+      if (Date.now() > deadline) {
+        collected.omittedCount += collected.files.length - index;
+        timedOut = true;
+        break;
       }
+      const relFile = path.relative(cwd, file);
+      await collectMatchesForFile(matches, structural, relFile, params.kind, matcher);
+    }
 
-      return {
-        matches,
-        omittedCount: timedOut ? Math.max(1, collected.omittedCount) : collected.omittedCount,
-        partialReason: timedOut ? "timeout" : collected.omittedCount > 0 ? "file-cap" : null,
-      };
-    });
+    return {
+      matches,
+      omittedCount: timedOut ? Math.max(1, collected.omittedCount) : collected.omittedCount,
+      partialReason: timedOut ? "timeout" : collected.omittedCount > 0 ? "file-cap" : null,
+    };
   } catch {
     return `No structured ${params.kind} search data available in \`${relScope}\`. Try omitting \`kind\` for plain text search.`;
   }
@@ -72,32 +72,32 @@ 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").TreeSitterService,
+  structural: StructuralSubstrate,
   relFile: string,
   kind: StructuredPatternKind,
   matcher: (value: string) => boolean,
 ): Promise<void> {
   if (kind === "definition") {
-    const outline = await tsSession.outline(relFile);
+    const outline = await structural.outline(relFile);
     if (outline.kind !== "success") return;
     for (const item of outline.data) {
       if (!matcher(item.name)) continue;
-      matches.push({ file: relFile, name: item.name, kind: item.kind, line: item.range.startLine });
+      matches.push({ file: relFile, name: item.name, kind: item.kind, line: item.startLine });
     }
     return;
   }
 
   if (kind === "export") {
-    const exportsResult = await tsSession.exports(relFile);
+    const exportsResult = await structural.exports(relFile);
     if (exportsResult.kind !== "success") return;
     for (const item of exportsResult.data) {
       if (!matcher(item.name)) continue;
-      matches.push({ file: relFile, name: item.name, kind: item.kind, line: item.range.startLine });
+      matches.push({ file: relFile, name: item.name, kind: item.kind, line: item.startLine });
     }
     return;
   }
 
-  const importsResult = await tsSession.imports(relFile);
+  const importsResult = await structural.imports(relFile);
   if (importsResult.kind !== "success") return;
   for (const item of importsResult.data) {
     if (!matcher(item.moduleSpecifier)) continue;
@@ -105,7 +105,7 @@ async function collectMatchesForFile(
       file: relFile,
       name: item.moduleSpecifier,
       kind: "import",
-      line: item.range.startLine,
+      line: item.startLine,
     });
   }
 }

package/src/presentation/markdown/affected.ts

@@ -0,0 +1,170 @@
+// Affected markdown renderer — consumes analysis data and produces markdown content.
+
+import type { PrioritySignalsSummary } from "../../prioritization-signals.ts";
+import { appendPrioritySignalsSection } from "../../prioritization-signals.ts";
+import type { ResolvedTarget, ResolvedTargetGroup } from "../../target-resolution.ts";
+import type { ReferenceCollection } from "../../use-case/support/semantic-references.ts";
+import { formatReferenceList } from "../../use-case/support/semantic-references.ts";
+
+// ── Types ────────────────────────────────────────────────────────────
+
+export interface ImpactAnalysis {
+  confidence: "semantic" | "structural" | "heuristic" | "unavailable";
+  affectedFiles: Set<string>;
+  affectedModules: Set<string>;
+  downstreamCount: number;
+  checkNext: string[];
+  likelyTests: string[];
+  riskLevel: "low" | "medium" | "high";
+  externalRefs: number;
+}
+
+interface RenderSingleParams {
+  symbolName: string;
+  refs: ReferenceCollection;
+  analysis: ImpactAnalysis;
+  maxResults: number;
+  prioritySignals: PrioritySignalsSummary | null;
+  target: ResolvedTarget;
+  cwd: string;
+}
+
+// ── Single target renderer ───────────────────────────────────────────
+
+export function renderAffectedSingle(params: RenderSingleParams): string {
+  const { symbolName, refs, analysis, maxResults, prioritySignals, target, cwd } = params;
+  const totalRefs = refs.refs.length + analysis.externalRefs;
+  const lines: string[] = [];
+
+  lines.push(`# Affected: \`${symbolName}\``);
+  lines.push("");
+
+  const refSummary =
+    analysis.externalRefs > 0
+      ? `${totalRefs} refs (${refs.refs.length} direct + ${analysis.externalRefs} external)`
+      : `${totalRefs} ref${totalRefs !== 1 ? "s" : ""}`;
+  lines.push(
+    `**Risk: ${analysis.riskLevel.toUpperCase()}** | ${refSummary} | ${analysis.affectedFiles.size} file${analysis.affectedFiles.size !== 1 ? "s" : ""} | ${analysis.affectedModules.size} module${analysis.affectedModules.size !== 1 ? "s" : ""} | ${analysis.downstreamCount} downstream (${analysis.confidence})`,
+  );
+  if (analysis.externalRefs > 0) {
+    lines.push(
+      "_External references are not listed individually (node_modules, .pnpm, or out-of-tree)_",
+    );
+  }
+  lines.push("");
+
+  addRiskSection(lines, analysis, totalRefs);
+  formatReferenceList(lines, refs.refs, maxResults, cwd);
+  appendPrioritySignalsSection(lines, prioritySignals);
+  addCheckNextSection(lines, analysis.checkNext);
+  addTestsSection(lines, analysis.likelyTests);
+
+  const relPath = target.file ? pathRelative(cwd, target.file) : "";
+  lines.push("## Next");
+  lines.push(
+    `- \`code_brief\` with \`file: "${relPath}"\`, \`line: ${target.displayLine}\`, and \`character: ${target.displayCharacter}\` for deeper context around ${symbolName}`,
+  );
+  lines.push(
+    `- \`code_relations\` with \`kind: "callers"\`, \`file: "${relPath}"\`, \`line: ${target.displayLine}\`, and \`character: ${target.displayCharacter}\` for call sites`,
+  );
+  lines.push("");
+
+  return lines.join("\n");
+}
+
+// ── File-level target group renderer ─────────────────────────────────
+
+interface RenderFileLevelParams {
+  targetGroup: ResolvedTargetGroup;
+  perTarget: Array<{ target: ResolvedTarget; refs: ReferenceCollection }>;
+  aggregated: ReferenceCollection;
+  analysis: ImpactAnalysis;
+  maxResults: number;
+  prioritySignals: PrioritySignalsSummary | null;
+}
+
+export function renderAffectedFileLevel(params: RenderFileLevelParams): string {
+  const { targetGroup, perTarget, aggregated, analysis, maxResults, prioritySignals } = params;
+  const totalRefs = aggregated.refs.length + aggregated.externalCount;
+  const refSummary =
+    aggregated.externalCount > 0
+      ? `${totalRefs} refs (${aggregated.refs.length} direct + ${aggregated.externalCount} external)`
+      : `${totalRefs} ref${totalRefs !== 1 ? "s" : ""}`;
+
+  const lines: string[] = [];
+  lines.push(`# Affected: \`${targetGroup.displayName}\``);
+  lines.push("");
+  lines.push(
+    `**Risk: ${analysis.riskLevel.toUpperCase()}** | ${targetGroup.targets.length} exported target${targetGroup.targets.length !== 1 ? "s" : ""} | ${refSummary} | ${analysis.affectedFiles.size} file${analysis.affectedFiles.size !== 1 ? "s" : ""} | ${analysis.affectedModules.size} module${analysis.affectedModules.size !== 1 ? "s" : ""} | ${analysis.downstreamCount} downstream (${analysis.confidence})`,
+  );
+  lines.push("");
+
+  lines.push("## Exported Targets");
+  for (const entry of perTarget) {
+    lines.push(
+      `- \`${entry.target.name ?? "symbol"}\` — ${entry.refs.refs.length} ref${entry.refs.refs.length !== 1 ? "s" : ""}`,
+    );
+  }
+  lines.push("");
+
+  addRiskSection(lines, analysis, totalRefs);
+  formatReferenceList(lines, aggregated.refs, maxResults, "");
+  appendPrioritySignalsSection(lines, prioritySignals);
+  addCheckNextSection(lines, analysis.checkNext);
+  addTestsSection(lines, analysis.likelyTests);
+  lines.push("## Next");
+  lines.push("- `code_brief` on the most-affected module for deeper context");
+  lines.push("- Use `file` + coordinates to inspect one exported target precisely");
+  lines.push("");
+
+  return lines.join("\n");
+}
+
+// ── Shared formatting helpers ────────────────────────────────────────
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: risk-level formatting with branching per level is clearer as one function
+function addRiskSection(lines: string[], analysis: ImpactAnalysis, directCount: number): void {
+  lines.push("## Risk Assessment");
+  const { riskLevel, affectedFiles, affectedModules, downstreamCount } = analysis;
+  if (riskLevel === "low") {
+    lines.push(
+      `\`low\` — ${directCount} ref${directCount !== 1 ? "s" : ""}, local, no downstream dependents.`,
+    );
+  } else if (riskLevel === "medium") {
+    lines.push(
+      `\`medium\` — ${directCount} ref${directCount !== 1 ? "s" : ""} across ${affectedFiles.size} file${affectedFiles.size !== 1 ? "s" : ""}${downstreamCount > 0 ? `, ${downstreamCount} downstream` : ""}.`,
+    );
+  } else {
+    lines.push(
+      `\`high\` — ${directCount} ref${directCount !== 1 ? "s" : ""} across ${affectedFiles.size} file${affectedFiles.size !== 1 ? "s" : ""} in ${affectedModules.size} module${affectedModules.size !== 1 ? "s" : ""}${downstreamCount > 0 ? `, ${downstreamCount} downstream` : ""}.`,
+    );
+  }
+  lines.push("");
+}
+
+function addCheckNextSection(lines: string[], checkNext: string[]): void {
+  if (checkNext.length === 0) return;
+  lines.push("## Check Next");
+  for (const item of checkNext.slice(0, 3)) {
+    lines.push(`- ${item}`);
+  }
+  lines.push("");
+}
+
+function addTestsSection(lines: string[], tests: string[]): void {
+  if (tests.length === 0) return;
+  lines.push("## Likely Tests");
+  for (const t of tests.slice(0, 3)) {
+    lines.push(`- \`${t}\``);
+  }
+  lines.push("");
+}
+
+function pathRelative(cwd: string, file: string): string {
+  // Simple relative path computation
+  if (file.startsWith(cwd)) {
+    const rel = file.slice(cwd.length).replace(/^[/\\]/, "");
+    return rel || ".";
+  }
+  return file;
+}

package/src/presentation/markdown/brief.ts

@@ -0,0 +1,174 @@
+// Brief markdown renderer — consumes use-case data and produces markdown content + details metadata.
+
+import * as path from "node:path";
+import type { ArchitectureModel } from "../../architecture.ts";
+import { findModuleForPath } from "../../architecture.ts";
+import type { BriefDetails } from "../../types.ts";
+
+// ── Anchored brief ───────────────────────────────────────────────────
+
+interface TreeSitterContext {
+  nodeInfo: { type: string; text: string; startLine: number; startCharacter: number } | null;
+  outline: Array<{ name: string; kind: string; startLine: number; endLine: number }>;
+  imports: Array<{ moduleSpecifier: string }>;
+  exports: Array<{ name: string; kind: string }>;
+}
+
+export function renderAnchoredBrief(params: {
+  relPath: string;
+  line: number;
+  character: number;
+  context: TreeSitterContext;
+  model: ArchitectureModel | null;
+  details: BriefDetails;
+  cwd: string;
+}): { content: string; details: BriefDetails } {
+  const lines: string[] = [];
+  lines.push(`# Anchored Brief: ${params.relPath}:${params.line}:${params.character}`);
+  lines.push("");
+
+  appendTreeSitterContext(lines, params.context, params.relPath, params.line, params.cwd);
+
+  if (params.model) {
+    const resolvedFile = path.resolve(params.cwd, params.relPath);
+    const mod = findModuleForPath(params.model, resolvedFile);
+    if (mod) {
+      const shortName = mod.name.replace(/^@[^/]+\//, "");
+      lines.push(`_Module: ${shortName} (\`${mod.relativePath}\`)_`);
+      lines.push("");
+    }
+  }
+
+  appendNextQueries(lines, params.relPath, params.line, params.character);
+
+  return { content: lines.join("\n"), details: params.details };
+}
+
+// ── Symbol brief ──────────────────────────────────────────────────────
+
+export function renderSymbolBrief(params: {
+  relPath: string;
+  symbolName: string;
+  targetLine: number;
+  targetCharacter: number;
+  targetKind: string | null;
+  context: TreeSitterContext;
+  model: ArchitectureModel | null;
+  details: BriefDetails;
+  cwd: string;
+}): { content: string; details: BriefDetails } {
+  const lines: string[] = [];
+  lines.push(`# Symbol Brief: ${params.symbolName || params.relPath}`);
+  lines.push("");
+  lines.push(
+    `**Resolved to:** \`${params.relPath}:${params.targetLine}:${params.targetCharacter}\`${params.targetKind ? ` (${params.targetKind})` : ""}`,
+  );
+  lines.push("");
+
+  appendTreeSitterContext(lines, params.context, params.relPath, params.targetLine, params.cwd);
+
+  if (params.model) {
+    const resolvedFile = path.resolve(params.cwd, params.relPath);
+    const mod = findModuleForPath(params.model, resolvedFile);
+    if (mod) {
+      const shortName = mod.name.replace(/^@[^/]+\//, "");
+      lines.push(`_Module: ${shortName} (\`${mod.relativePath}\`)_`);
+      lines.push("");
+    }
+  }
+
+  appendNextQueries(lines, params.relPath, params.targetLine, params.targetCharacter);
+
+  return { content: lines.join("\n"), details: params.details };
+}
+
+// ── Tree-sitter context rendering ─────────────────────────────────────
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: tree-sitter context rendering with node/outline/imports/exports sections kept together for readability
+// biome-ignore lint/complexity/useMaxParams: options-object refactor would reduce clarity for this rendering helper
+function appendTreeSitterContext(
+  lines: string[],
+  context: TreeSitterContext,
+  relPath: string,
+  line: number,
+  _cwd: string,
+): void {
+  if (context.nodeInfo) {
+    const node = context.nodeInfo;
+    lines.push(`**Node:** \`${node.type}\` at ${relPath}:${node.startLine}:${node.startCharacter}`);
+    if (node.text && node.text.length <= 200) {
+      lines.push("```");
+      lines.push(node.text);
+      lines.push("```");
+    }
+    lines.push("");
+  }
+
+  if (context.outline.length > 0) {
+    const enclosing = context.outline.find(
+      (item) => item.startLine <= line && item.endLine >= line,
+    );
+    if (enclosing) {
+      lines.push(`**Enclosing symbol:** \`${enclosing.name}\` (${enclosing.kind})`);
+      lines.push(`- Range: ${relPath}:${enclosing.startLine}–${enclosing.endLine}`);
+      lines.push("");
+    }
+
+    lines.push("## File Outline");
+    const shown = context.outline.slice(0, 15);
+    for (const item of shown) {
+      const prefix = getOutlinePrefix(item.kind);
+      lines.push(`- ${prefix} \`${item.name}\` (${item.kind}) L${item.startLine}`);
+    }
+    if (context.outline.length > 15) {
+      lines.push(`- _+${context.outline.length - 15} more declarations_`);
+    }
+    lines.push("");
+  }
+
+  if (context.imports.length > 0) {
+    lines.push("## Imports");
+    const shown = context.imports.slice(0, 10);
+    for (const imp of shown) {
+      lines.push(`- \`${imp.moduleSpecifier}\``);
+    }
+    if (context.imports.length > 10) {
+      lines.push(`- _+${context.imports.length - 10} more_`);
+    }
+    lines.push("");
+  }
+
+  if (context.exports.length > 0) {
+    lines.push("## Exports");
+    const shown = context.exports.slice(0, 10);
+    for (const exp of shown) {
+      lines.push(`- \`${exp.name}\` (${exp.kind})`);
+    }
+    if (context.exports.length > 10) {
+      lines.push(`- _+${context.exports.length - 10} more_`);
+    }
+    lines.push("");
+  }
+}
+
+function getOutlinePrefix(kind: string): string {
+  if (kind === "function" || kind === "method") return "ƒ";
+  if (kind === "class") return "◆";
+  return "·";
+}
+
+function appendNextQueries(
+  lines: string[],
+  relPath: string,
+  line: number,
+  character: number,
+): void {
+  lines.push("## Next");
+  lines.push(
+    `- \`code_relations\` with \`kind: "callers"\`, \`file: "${relPath}"\`, \`line: ${line}\`, and \`character: ${character}\` for call sites`,
+  );
+  lines.push(
+    `- \`code_affected\` with \`file: "${relPath}"\`, \`line: ${line}\`, and \`character: ${character}\` for impact analysis`,
+  );
+  lines.push("");
+}

package/src/presentation/markdown/map.ts

@@ -0,0 +1,54 @@
+// Map markdown renderer — consumes MapData and produces markdown content + details metadata.
+
+import type { MapDetails } from "../../types.ts";
+import type { MapData, MapStats } from "../../use-case/generate-map.ts";
+import { SOURCE_EXTENSIONS } from "../../use-case/generate-map.ts";
+
+export function renderMap(data: MapData): { content: string; details: MapDetails } {
+  const content = formatMap(data.scope, data.stats);
+  const details: MapDetails = {
+    scope: data.scope,
+    totalFiles: data.stats.total,
+    childDirectoryCount: data.stats.byChildDir.size,
+    landmarkCount: data.stats.landmarkFiles.length,
+    nextQueries: ["`code_brief` for prioritized context on this scope"],
+  };
+
+  return { content, details };
+}
+
+function formatMap(scope: string, stats: MapStats): string {
+  const lines: string[] = [];
+
+  lines.push(`# Code Map: ${scope}`);
+  lines.push("");
+  lines.push(`**Files:** ${stats.total} total`);
+  for (const [ext, count] of [...stats.byExtension.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 10)) {
+    const label = SOURCE_EXTENSIONS.get(ext) ?? (ext || "(no extension)");
+    lines.push(`- ${label}: ${count}`);
+  }
+  if (stats.byExtension.size > 10) {
+    lines.push(`- _+${stats.byExtension.size - 10} more extensions_`);
+  }
+  lines.push("");
+
+  if (stats.byChildDir.size > 0) {
+    lines.push("**Child directories:**");
+    for (const [dir, count] of [...stats.byChildDir.entries()].sort((a, b) => b[1] - a[1])) {
+      lines.push(`- ${dir}/ (${count} file${count !== 1 ? "s" : ""})`);
+    }
+    lines.push("");
+  }
+
+  if (stats.landmarkFiles.length > 0) {
+    lines.push("**Landmark files:**");
+    for (const file of stats.landmarkFiles) {
+      lines.push(`- \`${file}\``);
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}

package/src/presentation/markdown/overview.ts

@@ -0,0 +1,59 @@
+// Hidden overview markdown renderer for the first-turn session injection.
+// Consumes OverviewData produced by the overview use-case.
+
+import type { OverviewData } from "../../use-case/types.ts";
+
+/**
+ * Render the compact architecture overview for first-turn session injection.
+ * Targets roughly 500 tokens.
+ */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: module-edge overview rendering with multiple formatting paths is clearer as one function
+export function renderOverview(data: OverviewData): string {
+  const lines: string[] = [];
+
+  lines.push("# Project: Code Intelligence Overview");
+  lines.push("");
+
+  if (data.projectName) {
+    lines.push(
+      `**${data.projectName}**${data.projectDescription ? ` — ${data.projectDescription}` : ""}`,
+    );
+    lines.push("");
+  }
+
+  lines.push("## Modules");
+  lines.push("");
+
+  for (const mod of data.modules) {
+    const deps = mod.internalDeps.filter((d) =>
+      data.modules.some((m) => m.name === d || m.shortName === d),
+    );
+
+    if (deps.length === 0) {
+      lines.push(
+        `- **${mod.shortName}**${mod.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(
+        `- **${mod.shortName}** → ${depStr}${suffix}${mod.description ? ` — ${mod.description}` : ""}`,
+      );
+    }
+  }
+
+  if (data.omittedModuleCount > 0) {
+    lines.push(`- _+${data.omittedModuleCount} more modules omitted_`);
+  }
+
+  lines.push("");
+
+  if (data.gitContextOverview) {
+    lines.push(data.gitContextOverview);
+  }
+
+  lines.push("_Use `code_brief` for deeper context on any module or file._");
+
+  return lines.join("\n");
+}