@optave/codegraph 2.5.1 → 3.0.0

package/src/queries.js

@@ -1,11 +1,14 @@
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
+import { evaluateBoundaries } from './boundaries.js';
 import { coChangeForFiles } from './cochange.js';
+import { loadConfig } from './config.js';
 import { findCycles } from './cycles.js';
 import { findDbPath, openReadonlyOrFail } from './db.js';
 import { debug } from './logger.js';
-import { paginateResult } from './paginate.js';
+import { ownersForFiles } from './owners.js';
+import { paginateResult, printNdjson } from './paginate.js';
 import { LANGUAGE_REGISTRY } from './parser.js';
 
 /**
@@ -56,7 +59,9 @@ export const FALSE_POSITIVE_NAMES = new Set([
 export const FALSE_POSITIVE_CALLER_THRESHOLD = 20;
 
 const FUNCTION_KINDS = ['function', 'method', 'class'];
-export const ALL_SYMBOL_KINDS = [
+
+// Original 10 kinds — used as default query scope
+export const CORE_SYMBOL_KINDS = [
   'function',
   'method',
   'class',
@@ -69,6 +74,39 @@ export const ALL_SYMBOL_KINDS = [
   'module',
 ];
 
+// Sub-declaration kinds (Phase 1)
+export const EXTENDED_SYMBOL_KINDS = [
+  'parameter',
+  'property',
+  'constant',
+  // Phase 2 (reserved, not yet extracted):
+  // 'constructor', 'namespace', 'decorator', 'getter', 'setter',
+];
+
+// Full set for --kind validation and MCP enum
+export const EVERY_SYMBOL_KIND = [...CORE_SYMBOL_KINDS, ...EXTENDED_SYMBOL_KINDS];
+
+// Backward compat: ALL_SYMBOL_KINDS stays as the core 10
+export const ALL_SYMBOL_KINDS = CORE_SYMBOL_KINDS;
+
+// ── Edge kind constants ─────────────────────────────────────────────
+// Core edge kinds — coupling and dependency relationships
+export const CORE_EDGE_KINDS = [
+  'imports',
+  'imports-type',
+  'reexports',
+  'calls',
+  'extends',
+  'implements',
+  'contains',
+];
+
+// Structural edge kinds — parent/child and type relationships
+export const STRUCTURAL_EDGE_KINDS = ['parameter_of', 'receiver'];
+
+// Full set for MCP enum and validation
+export const EVERY_EDGE_KIND = [...CORE_EDGE_KINDS, ...STRUCTURAL_EDGE_KINDS];
+
 export const VALID_ROLES = ['entry', 'core', 'utility', 'adapter', 'dead', 'leaf'];
 
 /**
@@ -187,6 +225,12 @@ export function kindIcon(kind) {
       return 'I';
     case 'type':
       return 'T';
+    case 'parameter':
+      return 'p';
+    case 'property':
+      return '.';
+    case 'constant':
+      return 'C';
     default:
       return '-';
   }
@@ -204,6 +248,7 @@ export function queryNameData(name, customDbPath, opts = {}) {
     return { query: name, results: [] };
   }
 
+  const hc = new Map();
   const results = nodes.map((node) => {
     let callees = db
       .prepare(`
@@ -227,10 +272,7 @@ export function queryNameData(name, customDbPath, opts = {}) {
     }
 
     return {
-      name: node.name,
-      kind: node.kind,
-      file: node.file,
-      line: node.line,
+      ...normalizeSymbol(node, db, hc),
       callees: callees.map((c) => ({
         name: c.name,
         kind: c.kind,
@@ -324,12 +366,12 @@ export function moduleMapData(customDbPath, limit = 20, opts = {}) {
   const nodes = db
     .prepare(`
     SELECT n.*,
-      (SELECT COUNT(*) FROM edges WHERE source_id = n.id AND kind != 'contains') as out_edges,
-      (SELECT COUNT(*) FROM edges WHERE target_id = n.id AND kind != 'contains') as in_edges
+      (SELECT COUNT(*) FROM edges WHERE source_id = n.id AND kind NOT IN ('contains', 'parameter_of', 'receiver')) as out_edges,
+      (SELECT COUNT(*) FROM edges WHERE target_id = n.id AND kind NOT IN ('contains', 'parameter_of', 'receiver')) as in_edges
     FROM nodes n
     WHERE n.kind = 'file'
       ${testFilter}
-    ORDER BY (SELECT COUNT(*) FROM edges WHERE target_id = n.id AND kind != 'contains') DESC
+    ORDER BY (SELECT COUNT(*) FROM edges WHERE target_id = n.id AND kind NOT IN ('contains', 'parameter_of', 'receiver')) DESC
     LIMIT ?
   `)
     .all(limit);
@@ -391,13 +433,15 @@ export function fileDepsData(file, customDbPath, opts = {}) {
   });
 
   db.close();
-  return { file, results };
+  const base = { file, results };
+  return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
 }
 
 export function fnDepsData(name, customDbPath, opts = {}) {
   const db = openReadonlyOrFail(customDbPath);
   const depth = opts.depth || 3;
   const noTests = opts.noTests || false;
+  const hc = new Map();
 
   const nodes = findMatchingNodes(db, name, { noTests, file: opts.file, kind: opts.kind });
   if (nodes.length === 0) {
@@ -489,10 +533,7 @@ export function fnDepsData(name, customDbPath, opts = {}) {
     }
 
     return {
-      name: node.name,
-      kind: node.kind,
-      file: node.file,
-      line: node.line,
+      ...normalizeSymbol(node, db, hc),
       callees: filteredCallees.map((c) => ({
         name: c.name,
         kind: c.kind,
@@ -511,13 +552,15 @@ export function fnDepsData(name, customDbPath, opts = {}) {
   });
 
   db.close();
-  return { name, results };
+  const base = { name, results };
+  return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
 }
 
 export function fnImpactData(name, customDbPath, opts = {}) {
   const db = openReadonlyOrFail(customDbPath);
   const maxDepth = opts.depth || 5;
   const noTests = opts.noTests || false;
+  const hc = new Map();
 
   const nodes = findMatchingNodes(db, name, { noTests, file: opts.file, kind: opts.kind });
   if (nodes.length === 0) {
@@ -525,7 +568,7 @@ export function fnImpactData(name, customDbPath, opts = {}) {
     return { name, results: [] };
   }
 
-  const results = nodes.slice(0, 3).map((node) => {
+  const results = nodes.map((node) => {
     const visited = new Set([node.id]);
     const levels = {};
     let frontier = [node.id];
@@ -554,17 +597,15 @@ export function fnImpactData(name, customDbPath, opts = {}) {
     }
 
     return {
-      name: node.name,
-      kind: node.kind,
-      file: node.file,
-      line: node.line,
+      ...normalizeSymbol(node, db, hc),
       levels,
       totalDependents: visited.size - 1,
     };
   });
 
   db.close();
-  return { name, results };
+  const base = { name, results };
+  return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
 }
 
 export function pathData(from, to, customDbPath, opts = {}) {
@@ -998,20 +1039,60 @@ export function diffImpactData(customDbPath, opts = {}) {
     /* co_changes table doesn't exist — skip silently */
   }
 
+  // Look up CODEOWNERS for changed + affected files
+  let ownership = null;
+  try {
+    const allFilePaths = [...new Set([...changedRanges.keys(), ...affectedFiles])];
+    const ownerResult = ownersForFiles(allFilePaths, repoRoot);
+    if (ownerResult.affectedOwners.length > 0) {
+      ownership = {
+        owners: Object.fromEntries(ownerResult.owners),
+        affectedOwners: ownerResult.affectedOwners,
+        suggestedReviewers: ownerResult.suggestedReviewers,
+      };
+    }
+  } catch {
+    /* CODEOWNERS missing or unreadable — skip silently */
+  }
+
+  // Check boundary violations scoped to changed files
+  let boundaryViolations = [];
+  let boundaryViolationCount = 0;
+  try {
+    const config = loadConfig(repoRoot);
+    const boundaryConfig = config.manifesto?.boundaries;
+    if (boundaryConfig) {
+      const result = evaluateBoundaries(db, boundaryConfig, {
+        scopeFiles: [...changedRanges.keys()],
+        noTests,
+      });
+      boundaryViolations = result.violations;
+      boundaryViolationCount = result.violationCount;
+    }
+  } catch {
+    /* boundary check failed — skip silently */
+  }
+
   db.close();
-  return {
+  const base = {
     changedFiles: changedRanges.size,
     newFiles: [...newFiles],
     affectedFunctions: functionResults,
     affectedFiles: [...affectedFiles],
     historicallyCoupled,
+    ownership,
+    boundaryViolations,
+    boundaryViolationCount,
     summary: {
       functionsChanged: affectedFunctions.length,
       callersAffected: allAffected.size,
       filesAffected: affectedFiles.size,
       historicallyCoupledCount: historicallyCoupled.length,
+      ownersAffected: ownership ? ownership.affectedOwners.length : 0,
+      boundaryViolationCount,
     },
   };
+  return paginateResult(base, 'affectedFunctions', { limit: opts.limit, offset: opts.offset });
 }
 
 export function diffImpactMermaid(customDbPath, opts = {}) {
@@ -1148,17 +1229,158 @@ export function listFunctionsData(customDbPath, opts = {}) {
 
   let rows = db
     .prepare(
-      `SELECT name, kind, file, line, role FROM nodes WHERE ${conditions.join(' AND ')} ORDER BY file, line`,
+      `SELECT name, kind, file, line, end_line, role FROM nodes WHERE ${conditions.join(' AND ')} ORDER BY file, line`,
     )
     .all(...params);
 
   if (noTests) rows = rows.filter((r) => !isTestFile(r.file));
 
+  const hc = new Map();
+  const functions = rows.map((r) => normalizeSymbol(r, db, hc));
   db.close();
-  const base = { count: rows.length, functions: rows };
+  const base = { count: functions.length, functions };
   return paginateResult(base, 'functions', { limit: opts.limit, offset: opts.offset });
 }
 
+/**
+ * Generator: stream functions one-by-one using .iterate() for memory efficiency.
+ * @param {string} [customDbPath]
+ * @param {object} [opts]
+ * @param {boolean} [opts.noTests]
+ * @param {string} [opts.file]
+ * @param {string} [opts.pattern]
+ * @yields {{ name: string, kind: string, file: string, line: number, role: string|null }}
+ */
+export function* iterListFunctions(customDbPath, opts = {}) {
+  const db = openReadonlyOrFail(customDbPath);
+  try {
+    const noTests = opts.noTests || false;
+    const kinds = ['function', 'method', 'class'];
+    const placeholders = kinds.map(() => '?').join(', ');
+
+    const conditions = [`kind IN (${placeholders})`];
+    const params = [...kinds];
+
+    if (opts.file) {
+      conditions.push('file LIKE ?');
+      params.push(`%${opts.file}%`);
+    }
+    if (opts.pattern) {
+      conditions.push('name LIKE ?');
+      params.push(`%${opts.pattern}%`);
+    }
+
+    const stmt = db.prepare(
+      `SELECT name, kind, file, line, end_line, role FROM nodes WHERE ${conditions.join(' AND ')} ORDER BY file, line`,
+    );
+    for (const row of stmt.iterate(...params)) {
+      if (noTests && isTestFile(row.file)) continue;
+      yield {
+        name: row.name,
+        kind: row.kind,
+        file: row.file,
+        line: row.line,
+        endLine: row.end_line ?? null,
+        role: row.role ?? null,
+      };
+    }
+  } finally {
+    db.close();
+  }
+}
+
+/**
+ * Generator: stream role-classified symbols one-by-one.
+ * @param {string} [customDbPath]
+ * @param {object} [opts]
+ * @param {boolean} [opts.noTests]
+ * @param {string} [opts.role]
+ * @param {string} [opts.file]
+ * @yields {{ name: string, kind: string, file: string, line: number, endLine: number|null, role: string }}
+ */
+export function* iterRoles(customDbPath, opts = {}) {
+  const db = openReadonlyOrFail(customDbPath);
+  try {
+    const noTests = opts.noTests || false;
+    const conditions = ['role IS NOT NULL'];
+    const params = [];
+
+    if (opts.role) {
+      conditions.push('role = ?');
+      params.push(opts.role);
+    }
+    if (opts.file) {
+      conditions.push('file LIKE ?');
+      params.push(`%${opts.file}%`);
+    }
+
+    const stmt = db.prepare(
+      `SELECT name, kind, file, line, end_line, role FROM nodes WHERE ${conditions.join(' AND ')} ORDER BY role, file, line`,
+    );
+    for (const row of stmt.iterate(...params)) {
+      if (noTests && isTestFile(row.file)) continue;
+      yield {
+        name: row.name,
+        kind: row.kind,
+        file: row.file,
+        line: row.line,
+        endLine: row.end_line ?? null,
+        role: row.role ?? null,
+      };
+    }
+  } finally {
+    db.close();
+  }
+}
+
+/**
+ * Generator: stream symbol lookup results one-by-one.
+ * @param {string} target - Symbol name to search for (partial match)
+ * @param {string} [customDbPath]
+ * @param {object} [opts]
+ * @param {boolean} [opts.noTests]
+ * @yields {{ name: string, kind: string, file: string, line: number, role: string|null, exported: boolean, uses: object[] }}
+ */
+export function* iterWhere(target, customDbPath, opts = {}) {
+  const db = openReadonlyOrFail(customDbPath);
+  try {
+    const noTests = opts.noTests || false;
+    const placeholders = ALL_SYMBOL_KINDS.map(() => '?').join(', ');
+    const stmt = db.prepare(
+      `SELECT * FROM nodes WHERE name LIKE ? AND kind IN (${placeholders}) ORDER BY file, line`,
+    );
+    const crossFileCallersStmt = db.prepare(
+      `SELECT COUNT(*) as cnt FROM edges e JOIN nodes n ON e.source_id = n.id
+       WHERE e.target_id = ? AND e.kind = 'calls' AND n.file != ?`,
+    );
+    const usesStmt = db.prepare(
+      `SELECT n.name, n.file, n.line FROM edges e JOIN nodes n ON e.source_id = n.id
+       WHERE e.target_id = ? AND e.kind = 'calls'`,
+    );
+    for (const node of stmt.iterate(`%${target}%`, ...ALL_SYMBOL_KINDS)) {
+      if (noTests && isTestFile(node.file)) continue;
+
+      const crossFileCallers = crossFileCallersStmt.get(node.id, node.file);
+      const exported = crossFileCallers.cnt > 0;
+
+      let uses = usesStmt.all(node.id);
+      if (noTests) uses = uses.filter((u) => !isTestFile(u.file));
+
+      yield {
+        name: node.name,
+        kind: node.kind,
+        file: node.file,
+        line: node.line,
+        role: node.role || null,
+        exported,
+        uses: uses.map((u) => ({ name: u.name, file: u.file, line: u.line })),
+      };
+    }
+  } finally {
+    db.close();
+  }
+}
+
 export function statsData(customDbPath, opts = {}) {
   const db = openReadonlyOrFail(customDbPath);
   const noTests = opts.noTests || false;
@@ -1553,8 +1775,7 @@ export function queryName(name, customDbPath, opts = {}) {
     offset: opts.offset,
   });
   if (opts.ndjson) {
-    if (data._pagination) console.log(JSON.stringify({ _meta: data._pagination }));
-    for (const r of data.results) console.log(JSON.stringify(r));
+    printNdjson(data, 'results');
     return;
   }
   if (opts.json) {
@@ -1586,7 +1807,11 @@ export function queryName(name, customDbPath, opts = {}) {
 }
 
 export function impactAnalysis(file, customDbPath, opts = {}) {
-  const data = impactAnalysisData(file, customDbPath, { noTests: opts.noTests });
+  const data = impactAnalysisData(file, customDbPath, opts);
+  if (opts.ndjson) {
+    printNdjson(data, 'sources');
+    return;
+  }
   if (opts.json) {
     console.log(JSON.stringify(data, null, 2));
     return;
@@ -1645,7 +1870,11 @@ export function moduleMap(customDbPath, limit = 20, opts = {}) {
 }
 
 export function fileDeps(file, customDbPath, opts = {}) {
-  const data = fileDepsData(file, customDbPath, { noTests: opts.noTests });
+  const data = fileDepsData(file, customDbPath, opts);
+  if (opts.ndjson) {
+    printNdjson(data, 'results');
+    return;
+  }
   if (opts.json) {
     console.log(JSON.stringify(data, null, 2));
     return;
@@ -1676,6 +1905,10 @@ export function fileDeps(file, customDbPath, opts = {}) {
 
 export function fnDeps(name, customDbPath, opts = {}) {
   const data = fnDepsData(name, customDbPath, opts);
+  if (opts.ndjson) {
+    printNdjson(data, 'results');
+    return;
+  }
   if (opts.json) {
     console.log(JSON.stringify(data, null, 2));
     return;
@@ -1838,14 +2071,13 @@ export function contextData(name, customDbPath, opts = {}) {
   const dbPath = findDbPath(customDbPath);
   const repoRoot = path.resolve(path.dirname(dbPath), '..');
 
-  let nodes = findMatchingNodes(db, name, { noTests, file: opts.file, kind: opts.kind });
+  const nodes = findMatchingNodes(db, name, { noTests, file: opts.file, kind: opts.kind });
   if (nodes.length === 0) {
     db.close();
     return { name, results: [] };
   }
 
-  // Limit to first 5 results
-  nodes = nodes.slice(0, 5);
+  // No hardcoded slice — pagination handles bounding via limit/offset
 
   // File-lines cache to avoid re-reading the same file
   const fileCache = new Map();
@@ -2033,6 +2265,17 @@ export function contextData(name, customDbPath, opts = {}) {
       /* table may not exist */
     }
 
+    // Children (parameters, properties, constants)
+    let nodeChildren = [];
+    try {
+      nodeChildren = db
+        .prepare('SELECT name, kind, line, end_line FROM nodes WHERE parent_id = ? ORDER BY line')
+        .all(node.id)
+        .map((c) => ({ name: c.name, kind: c.kind, line: c.line, endLine: c.end_line || null }));
+    } catch {
+      /* parent_id column may not exist */
+    }
+
     return {
       name: node.name,
       kind: node.kind,
@@ -2043,6 +2286,7 @@ export function contextData(name, customDbPath, opts = {}) {
       source,
       signature,
       complexity: complexityMetrics,
+      children: nodeChildren.length > 0 ? nodeChildren : undefined,
       callees,
       callers,
       relatedTests,
@@ -2050,11 +2294,16 @@ export function contextData(name, customDbPath, opts = {}) {
   });
 
   db.close();
-  return { name, results };
+  const base = { name, results };
+  return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
 }
 
 export function context(name, customDbPath, opts = {}) {
   const data = contextData(name, customDbPath, opts);
+  if (opts.ndjson) {
+    printNdjson(data, 'results');
+    return;
+  }
   if (opts.json) {
     console.log(JSON.stringify(data, null, 2));
     return;
@@ -2077,6 +2326,15 @@ export function context(name, customDbPath, opts = {}) {
       console.log();
     }
 
+    // Children
+    if (r.children && r.children.length > 0) {
+      console.log(`## Children (${r.children.length})`);
+      for (const c of r.children) {
+        console.log(`  ${kindIcon(c.kind)} ${c.name}  :${c.line}`);
+      }
+      console.log();
+    }
+
     // Complexity
     if (r.complexity) {
       const cx = r.complexity;
@@ -2149,6 +2407,69 @@ export function context(name, customDbPath, opts = {}) {
   }
 }
 
+// ─── childrenData ───────────────────────────────────────────────────────
+
+export function childrenData(name, customDbPath, opts = {}) {
+  const db = openReadonlyOrFail(customDbPath);
+  const noTests = opts.noTests || false;
+
+  const nodes = findMatchingNodes(db, name, { noTests, file: opts.file, kind: opts.kind });
+  if (nodes.length === 0) {
+    db.close();
+    return { name, results: [] };
+  }
+
+  const results = nodes.map((node) => {
+    let children;
+    try {
+      children = db
+        .prepare('SELECT name, kind, line, end_line FROM nodes WHERE parent_id = ? ORDER BY line')
+        .all(node.id);
+    } catch {
+      children = [];
+    }
+    if (noTests) children = children.filter((c) => !isTestFile(c.file || node.file));
+    return {
+      name: node.name,
+      kind: node.kind,
+      file: node.file,
+      line: node.line,
+      children: children.map((c) => ({
+        name: c.name,
+        kind: c.kind,
+        line: c.line,
+        endLine: c.end_line || null,
+      })),
+    };
+  });
+
+  db.close();
+  const base = { name, results };
+  return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
+}
+
+export function children(name, customDbPath, opts = {}) {
+  const data = childrenData(name, customDbPath, opts);
+  if (opts.json) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  if (data.results.length === 0) {
+    console.log(`No symbol matching "${name}"`);
+    return;
+  }
+  for (const r of data.results) {
+    console.log(`\n${kindIcon(r.kind)} ${r.name}  ${r.file}:${r.line}`);
+    if (r.children.length === 0) {
+      console.log('  (no children)');
+    } else {
+      for (const c of r.children) {
+        console.log(`  ${kindIcon(c.kind)} ${c.name}  :${c.line}`);
+      }
+    }
+  }
+}
+
 // ─── explainData ────────────────────────────────────────────────────────
 
 function isFileLikeTarget(target) {
@@ -2271,6 +2592,7 @@ function explainFunctionImpl(db, target, noTests, getFileLines) {
   if (noTests) nodes = nodes.filter((n) => !isTestFile(n.file));
   if (nodes.length === 0) return [];
 
+  const hc = new Map();
   return nodes.slice(0, 10).map((node) => {
     const fileLines = getFileLines(node.file);
     const lineCount = node.end_line ? node.end_line - node.line + 1 : null;
@@ -2328,12 +2650,7 @@ function explainFunctionImpl(db, target, noTests, getFileLines) {
     }
 
     return {
-      name: node.name,
-      kind: node.kind,
-      file: node.file,
-      line: node.line,
-      role: node.role || null,
-      endLine: node.end_line || null,
+      ...normalizeSymbol(node, db, hc),
       lineCount,
       summary,
       signature,
@@ -2410,11 +2727,16 @@ export function explainData(target, customDbPath, opts = {}) {
   }
 
   db.close();
-  return { target, kind, results };
+  const base = { target, kind, results };
+  return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
 }
 
 export function explain(target, customDbPath, opts = {}) {
   const data = explainData(target, customDbPath, opts);
+  if (opts.ndjson) {
+    printNdjson(data, 'results');
+    return;
+  }
   if (opts.json) {
     console.log(JSON.stringify(data, null, 2));
     return;
@@ -2541,6 +2863,41 @@ export function explain(target, customDbPath, opts = {}) {
 
 // ─── whereData ──────────────────────────────────────────────────────────
 
+function getFileHash(db, file) {
+  const row = db.prepare('SELECT hash FROM file_hashes WHERE file = ?').get(file);
+  return row ? row.hash : null;
+}
+
+/**
+ * Normalize a raw DB/query row into the stable 7-field symbol shape.
+ * @param {object} row    - Raw row (from SELECT * or explicit columns)
+ * @param {object} [db]   - Open DB handle; when null, fileHash will be null
+ * @param {Map}    [hashCache] - Optional per-file cache to avoid repeated getFileHash calls
+ * @returns {{ name: string, kind: string, file: string, line: number, endLine: number|null, role: string|null, fileHash: string|null }}
+ */
+export function normalizeSymbol(row, db, hashCache) {
+  let fileHash = null;
+  if (db) {
+    if (hashCache) {
+      if (!hashCache.has(row.file)) {
+        hashCache.set(row.file, getFileHash(db, row.file));
+      }
+      fileHash = hashCache.get(row.file);
+    } else {
+      fileHash = getFileHash(db, row.file);
+    }
+  }
+  return {
+    name: row.name,
+    kind: row.kind,
+    file: row.file,
+    line: row.line,
+    endLine: row.end_line ?? row.endLine ?? null,
+    role: row.role ?? null,
+    fileHash,
+  };
+}
+
 function whereSymbolImpl(db, target, noTests) {
   const placeholders = ALL_SYMBOL_KINDS.map(() => '?').join(', ');
   let nodes = db
@@ -2550,6 +2907,7 @@ function whereSymbolImpl(db, target, noTests) {
     .all(`%${target}%`, ...ALL_SYMBOL_KINDS);
   if (noTests) nodes = nodes.filter((n) => !isTestFile(n.file));
 
+  const hc = new Map();
   return nodes.map((node) => {
     const crossFileCallers = db
       .prepare(
@@ -2568,11 +2926,7 @@ function whereSymbolImpl(db, target, noTests) {
     if (noTests) uses = uses.filter((u) => !isTestFile(u.file));
 
     return {
-      name: node.name,
-      kind: node.kind,
-      file: node.file,
-      line: node.line,
-      role: node.role || null,
+      ...normalizeSymbol(node, db, hc),
       exported,
       uses: uses.map((u) => ({ name: u.name, file: u.file, line: u.line })),
     };
@@ -2622,6 +2976,7 @@ function whereFileImpl(db, target) {
 
     return {
       file: fn.file,
+      fileHash: getFileHash(db, fn.file),
       symbols: symbols.map((s) => ({ name: s.name, kind: s.kind, line: s.line })),
       imports,
       importedBy,
@@ -2645,8 +3000,7 @@ export function whereData(target, customDbPath, opts = {}) {
 export function where(target, customDbPath, opts = {}) {
   const data = whereData(target, customDbPath, opts);
   if (opts.ndjson) {
-    if (data._pagination) console.log(JSON.stringify({ _meta: data._pagination }));
-    for (const r of data.results) console.log(JSON.stringify(r));
+    printNdjson(data, 'results');
     return;
   }
   if (opts.json) {
@@ -2718,7 +3072,7 @@ export function rolesData(customDbPath, opts = {}) {
 
   let rows = db
     .prepare(
-      `SELECT name, kind, file, line, role FROM nodes WHERE ${conditions.join(' AND ')} ORDER BY role, file, line`,
+      `SELECT name, kind, file, line, end_line, role FROM nodes WHERE ${conditions.join(' AND ')} ORDER BY role, file, line`,
     )
     .all(...params);
 
@@ -2729,16 +3083,17 @@ export function rolesData(customDbPath, opts = {}) {
     summary[r.role] = (summary[r.role] || 0) + 1;
   }
 
+  const hc = new Map();
+  const symbols = rows.map((r) => normalizeSymbol(r, db, hc));
   db.close();
-  const base = { count: rows.length, summary, symbols: rows };
+  const base = { count: symbols.length, summary, symbols };
   return paginateResult(base, 'symbols', { limit: opts.limit, offset: opts.offset });
 }
 
 export function roles(customDbPath, opts = {}) {
   const data = rolesData(customDbPath, opts);
   if (opts.ndjson) {
-    if (data._pagination) console.log(JSON.stringify({ _meta: data._pagination }));
-    for (const s of data.symbols) console.log(JSON.stringify(s));
+    printNdjson(data, 'symbols');
     return;
   }
   if (opts.json) {
@@ -2777,8 +3132,172 @@ export function roles(customDbPath, opts = {}) {
   }
 }
 
+// ─── exportsData ─────────────────────────────────────────────────────
+
+function exportsFileImpl(db, target, noTests, getFileLines) {
+  const fileNodes = db
+    .prepare(`SELECT * FROM nodes WHERE file LIKE ? AND kind = 'file'`)
+    .all(`%${target}%`);
+  if (fileNodes.length === 0) return [];
+
+  return fileNodes.map((fn) => {
+    const symbols = db
+      .prepare(`SELECT * FROM nodes WHERE file = ? AND kind != 'file' ORDER BY line`)
+      .all(fn.file);
+
+    // IDs of symbols that have incoming calls from other files (exported)
+    const exportedIds = new Set(
+      db
+        .prepare(
+          `SELECT DISTINCT e.target_id FROM edges e
+           JOIN nodes caller ON e.source_id = caller.id
+           JOIN nodes target ON e.target_id = target.id
+           WHERE target.file = ? AND caller.file != ? AND e.kind = 'calls'`,
+        )
+        .all(fn.file, fn.file)
+        .map((r) => r.target_id),
+    );
+
+    const exported = symbols.filter((s) => exportedIds.has(s.id));
+    const internalCount = symbols.length - exported.length;
+
+    const results = exported.map((s) => {
+      const fileLines = getFileLines(fn.file);
+
+      let consumers = db
+        .prepare(
+          `SELECT n.name, n.file, n.line FROM edges e JOIN nodes n ON e.source_id = n.id
+           WHERE e.target_id = ? AND e.kind = 'calls'`,
+        )
+        .all(s.id);
+      if (noTests) consumers = consumers.filter((c) => !isTestFile(c.file));
+
+      return {
+        name: s.name,
+        kind: s.kind,
+        line: s.line,
+        endLine: s.end_line ?? null,
+        role: s.role || null,
+        signature: fileLines ? extractSignature(fileLines, s.line) : null,
+        summary: fileLines ? extractSummary(fileLines, s.line) : null,
+        consumers: consumers.map((c) => ({ name: c.name, file: c.file, line: c.line })),
+        consumerCount: consumers.length,
+      };
+    });
+
+    // Files that re-export this file (barrel → this file)
+    const reexports = db
+      .prepare(
+        `SELECT DISTINCT n.file FROM edges e JOIN nodes n ON e.source_id = n.id
+         WHERE e.target_id = ? AND e.kind = 'reexports'`,
+      )
+      .all(fn.id)
+      .map((r) => ({ file: r.file }));
+
+    return {
+      file: fn.file,
+      results,
+      reexports,
+      totalExported: exported.length,
+      totalInternal: internalCount,
+    };
+  });
+}
+
+export function exportsData(file, customDbPath, opts = {}) {
+  const db = openReadonlyOrFail(customDbPath);
+  const noTests = opts.noTests || false;
+
+  const dbFilePath = findDbPath(customDbPath);
+  const repoRoot = path.resolve(path.dirname(dbFilePath), '..');
+
+  const fileCache = new Map();
+  function getFileLines(file) {
+    if (fileCache.has(file)) return fileCache.get(file);
+    try {
+      const absPath = safePath(repoRoot, file);
+      if (!absPath) {
+        fileCache.set(file, null);
+        return null;
+      }
+      const lines = fs.readFileSync(absPath, 'utf-8').split('\n');
+      fileCache.set(file, lines);
+      return lines;
+    } catch {
+      fileCache.set(file, null);
+      return null;
+    }
+  }
+
+  const fileResults = exportsFileImpl(db, file, noTests, getFileLines);
+  db.close();
+
+  if (fileResults.length === 0) {
+    return paginateResult(
+      { file, results: [], reexports: [], totalExported: 0, totalInternal: 0 },
+      'results',
+      { limit: opts.limit, offset: opts.offset },
+    );
+  }
+
+  // For single-file match return flat; for multi-match return first (like explainData)
+  const first = fileResults[0];
+  const base = {
+    file: first.file,
+    results: first.results,
+    reexports: first.reexports,
+    totalExported: first.totalExported,
+    totalInternal: first.totalInternal,
+  };
+  return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
+}
+
+export function fileExports(file, customDbPath, opts = {}) {
+  const data = exportsData(file, customDbPath, opts);
+  if (opts.ndjson) {
+    printNdjson(data, 'results');
+    return;
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+
+  if (data.results.length === 0) {
+    console.log(`No exported symbols found for "${file}". Run "codegraph build" first.`);
+    return;
+  }
+
+  console.log(
+    `\n# ${data.file} — ${data.totalExported} exported, ${data.totalInternal} internal\n`,
+  );
+
+  for (const sym of data.results) {
+    const icon = kindIcon(sym.kind);
+    const sig = sym.signature?.params ? `(${sym.signature.params})` : '';
+    const role = sym.role ? ` [${sym.role}]` : '';
+    console.log(`  ${icon} ${sym.name}${sig}${role} :${sym.line}`);
+    if (sym.consumers.length === 0) {
+      console.log('    (no consumers)');
+    } else {
+      for (const c of sym.consumers) {
+        console.log(`    <- ${c.name} (${c.file}:${c.line})`);
+      }
+    }
+  }
+
+  if (data.reexports.length > 0) {
+    console.log(`\n  Re-exports: ${data.reexports.map((r) => r.file).join(', ')}`);
+  }
+  console.log();
+}
+
 export function fnImpact(name, customDbPath, opts = {}) {
   const data = fnImpactData(name, customDbPath, opts);
+  if (opts.ndjson) {
+    printNdjson(data, 'results');
+    return;
+  }
   if (opts.json) {
     console.log(JSON.stringify(data, null, 2));
     return;
@@ -2811,6 +3330,10 @@ export function diffImpact(customDbPath, opts = {}) {
     return;
   }
   const data = diffImpactData(customDbPath, opts);
+  if (opts.ndjson) {
+    printNdjson(data, 'affectedFunctions');
+    return;
+  }
   if (opts.json || opts.format === 'json') {
     console.log(JSON.stringify(data, null, 2));
     return;
@@ -2845,11 +3368,28 @@ export function diffImpact(customDbPath, opts = {}) {
       );
     }
   }
+  if (data.ownership) {
+    console.log(`\n  Affected owners: ${data.ownership.affectedOwners.join(', ')}`);
+    console.log(`  Suggested reviewers: ${data.ownership.suggestedReviewers.join(', ')}`);
+  }
+  if (data.boundaryViolations && data.boundaryViolations.length > 0) {
+    console.log(`\n  Boundary violations (${data.boundaryViolationCount}):\n`);
+    for (const v of data.boundaryViolations) {
+      console.log(`    [${v.name}] ${v.file} -> ${v.targetFile}`);
+      if (v.message) console.log(`      ${v.message}`);
+    }
+  }
   if (data.summary) {
     let summaryLine = `\n  Summary: ${data.summary.functionsChanged} functions changed -> ${data.summary.callersAffected} callers affected across ${data.summary.filesAffected} files`;
     if (data.summary.historicallyCoupledCount > 0) {
       summaryLine += `, ${data.summary.historicallyCoupledCount} historically coupled`;
     }
+    if (data.summary.ownersAffected > 0) {
+      summaryLine += `, ${data.summary.ownersAffected} owners affected`;
+    }
+    if (data.summary.boundaryViolationCount > 0) {
+      summaryLine += `, ${data.summary.boundaryViolationCount} boundary violations`;
+    }
     console.log(`${summaryLine}\n`);
   }
 }