fix(cli): formatter audit — render missing metadata fields, README callers qualifier

- Fix metadata formatter: render componentsByType, layers, deps by category
- Fix search formatter: render hints.tests, hasTests flag
- Fix refs formatter: show "results capped" when isComplete=false
- Extend types.ts: MetadataStatistics.componentsByType/componentsByLayer,
  architecture.layers, CyclesResponse fields, RefsResponse.isComplete
- README: replace "caller coverage" with "import-graph coverage" (2 places)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: PatrickSys

.gitignore

@@ -26,3 +26,4 @@ grammars/*.wasm
 
 .tmp-research-repos/
 docs/visuals.md
+.repolore/

README.md

@@ -207,7 +207,7 @@ This is where it all comes together. One call returns:
 - **Relationships** per result: `importedByCount` and `hasTests` (condensed) + **hints** (capped ranked callers, consumers, tests) — so you see suggested next reads and know what you haven't looked at yet
 - **Related memories**: up to 3 team decisions, gotchas, and failures matched to the query
 - **Search quality**: `ok` or `low_confidence` with confidence score and `hint` when low
-- **Preflight**: `ready` (boolean) with decision card when `intent="edit"|"refactor"|"migrate"`. Shows `nextAction` (if not ready), `warnings`, `patterns` (do/avoid), `bestExample`, `impact` (caller coverage), and `whatWouldHelp` (next steps). If search quality is low, `ready` is always `false`.
+- **Preflight**: `ready` (boolean) with decision card when `intent="edit"|"refactor"|"migrate"`. Shows `nextAction` (if not ready), `warnings`, `patterns` (do/avoid), `bestExample`, `impact` (import-graph coverage — how many files that import or reference the result are in your search), and `whatWouldHelp` (next steps). If search quality is low, `ready` is always `false`.
 
 Snippets are optional (`includeSnippets: true`). When enabled, snippets that have symbol metadata (e.g. from the Generic analyzer's AST chunking or Angular component chunks) start with a scope header so you know where the code lives (e.g. `// AuthService.getToken()` or `// SpotifyApiService`). Example:
 
@@ -246,7 +246,7 @@ Record a decision once. It surfaces automatically in search results and prefligh
 
 | Tool                           | What it does                                                                                                                                            |
 | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `search_codebase`              | Hybrid search + decision card. Pass `intent="edit"` to get `ready`, `nextAction`, patterns, caller coverage, and `whatWouldHelp`.                       |
+| `search_codebase`              | Hybrid search + decision card. Pass `intent="edit"` to get `ready`, `nextAction`, patterns, import-graph coverage, and `whatWouldHelp`.                 |
 | `get_team_patterns`            | Pattern frequencies, golden files, conflict detection                                                                                                   |
 | `get_symbol_references`        | Find concrete references to a symbol (usageCount + top snippets). `confidence: "syntactic"` = static/source-based only; no runtime or dynamic dispatch. |
 | `remember`                     | Record a convention, decision, gotcha, or failure                                                                                                       |

src/cli-formatters.ts

@@ -390,6 +390,7 @@ export function formatSearch(
       const metaParts = [`confidence: ${scoreBar(scoreValue)} ${score}`];
       if (typePart) metaParts.push(typePart);
       if (trendPart) metaParts.push(trendPart);
+      if (r.relationships?.hasTests) metaParts.push('has tests');
 
       console.log(`${i + 1}.  ${file}`);
       console.log(`    ${metaParts.join(` ${g.dot} `)}`);
@@ -411,6 +412,10 @@ export function formatSearch(
         const more = total > 3 ? ` (+${total - 3} more)` : '';
         console.log(`    used by: ${shortCallers.join(', ')}${more}`);
       }
+      if (hints?.tests && hints.tests.length > 0) {
+        const shortTests = hints.tests.slice(0, 2).map((t) => shortPath(t, rootPath));
+        console.log(`    tested:  ${shortTests.join(', ')}`);
+      }
 
       const snippet = r.snippet ?? '';
       if (snippet) {
@@ -474,6 +479,11 @@ export function formatRefs(data: RefsResponse, rootPath: string): void {
     }
   }
 
+  if (data.isComplete === false) {
+    lines.push('');
+    lines.push(`${g.arrow} results capped at limit — use --limit to see more`);
+  }
+
   lines.push('');
 
   const confLabel =
@@ -594,16 +604,30 @@ export function formatMetadata(data: MetadataResponse): void {
     if (statParts.length > 0) lines.push(statParts.join(` ${g.dot} `));
   }
 
-  // Dependencies
-  const deps = m.dependencies ?? [];
-  if (deps.length > 0) {
-    lines.push('');
-    lines.push(
-      `Dependencies: ${deps
-        .slice(0, 6)
-        .map((d: MetadataDependency) => d.name)
-        .join(` ${g.dot} `)}${deps.length > 6 ? ` (+${deps.length - 6} more)` : ''}`
-    );
+  // Component breakdown by type (e.g. module 199  component 53  service 31)
+  const byType = stats?.componentsByType;
+  if (byType) {
+    const entries = Object.entries(byType)
+      .filter(([, v]) => v > 0)
+      .sort(([, a], [, b]) => b - a);
+    if (entries.length > 0) {
+      const shown = entries.slice(0, 3);
+      const more = entries.length > 3 ? `  (+${entries.length - 3} more)` : '';
+      const str = shown.map(([k, v]) => `${k} ${v}`).join('  ');
+      lines.push(`By type:   ${str}${more}`);
+    }
+  }
+
+  // Layer breakdown — skip zero-count and 'unknown' (e.g. presentation 57  business 23)
+  const layers = m.architecture?.layers;
+  if (layers) {
+    const entries = Object.entries(layers)
+      .filter(([k, v]) => v > 0 && k !== 'unknown')
+      .sort(([, a], [, b]) => b - a);
+    if (entries.length > 0) {
+      const str = entries.map(([k, v]) => `${k} ${v}`).join('  ');
+      lines.push(`By layer:  ${str}`);
+    }
   }
 
   // Framework extras: state, testing, ui
@@ -624,6 +648,31 @@ export function formatMetadata(data: MetadataResponse): void {
     }
   }
 
+  // Dependencies grouped by category (framework / state / other)
+  const deps = m.dependencies ?? [];
+  if (deps.length > 0) {
+    lines.push('');
+    const grouped: Record<string, string[]> = {};
+    for (const d of deps) {
+      const cat = d.category ?? 'other';
+      if (!grouped[cat]) grouped[cat] = [];
+      grouped[cat].push(d.name);
+    }
+    const catOrder = ['framework', 'state', 'testing', 'other'];
+    const cats = [
+      ...catOrder.filter((c) => grouped[c]),
+      ...Object.keys(grouped).filter((c) => !catOrder.includes(c)),
+    ];
+    for (const cat of cats) {
+      const names = grouped[cat];
+      if (!names || names.length === 0) continue;
+      const label = padRight(cat, 9);
+      const shown = names.slice(0, 2).join(` ${g.dot} `);
+      const more = names.length > 2 ? ` (+${names.length - 2} more)` : '';
+      lines.push(`  ${label}  ${shown}${more}`);
+    }
+  }
+
   // Modules (if any)
   const modules = m.architecture?.modules;
   if (modules && modules.length > 0) {

src/tools/types.ts

@@ -145,16 +145,26 @@ export interface MetadataStatistics {
   totalFiles?: number;
   totalLines?: number;
   totalComponents?: number;
+  componentsByType?: Record<string, number>;
+  componentsByLayer?: Record<string, number>;
 }
 
 export interface MetadataInner {
   name?: string;
   framework?: MetadataFramework;
   languages?: MetadataLanguage[];
   dependencies?: MetadataDependency[];
-  architecture?: { type?: string; modules?: Array<{ name: string }> };
-  projectStructure?: { type?: string };
+  architecture?: {
+    type?: string;
+    layers?: Record<string, number>;
+    patterns?: unknown[];
+    modules?: Array<{ name: string }>;
+  };
+  projectStructure?: { type?: string; workspaces?: string[] };
   statistics?: MetadataStatistics;
+  // teamPatterns mirrors the shape from get_team_patterns — not rendered here
+  // since the `patterns` command covers it; modelled so the field isn't invisible
+  teamPatterns?: Record<string, unknown>;
 }
 
 export interface MetadataResponse {
@@ -188,6 +198,7 @@ export interface CycleItem {
   files?: string[];
   cycle?: string[];
   severity?: string;
+  length?: number;
 }
 
 export interface GraphStats {
@@ -197,8 +208,13 @@ export interface GraphStats {
 }
 
 export interface CyclesResponse {
+  status?: string;
+  message?: string;
+  scope?: string;
   cycles?: CycleItem[];
+  count?: number;
   graphStats?: GraphStats;
+  advice?: string;
 }
 
 // --- Refs response types ---
@@ -209,8 +225,11 @@ export interface RefsUsage {
 }
 
 export interface RefsResponse {
+  status?: string;
   symbol: string;
   usageCount: number;
   confidence: string;
   usages: RefsUsage[];
+  /** false when results were capped at limit — more references exist */
+  isComplete?: boolean;
 }