optave-codegraph 3.13.0

package/src/presentation/manifesto.ts

@@ -0,0 +1,92 @@
+import { manifestoData } from '../features/manifesto.js';
+import { outputResult } from '../infrastructure/result-formatter.js';
+
+interface ManifestoOpts {
+  json?: boolean;
+  ndjson?: boolean;
+  table?: boolean;
+  csv?: boolean;
+  config?: unknown;
+  noTests?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+interface ManifestoViolationRow {
+  rule: string;
+  level: string;
+  value: number;
+  threshold: number;
+  name?: string;
+  file?: string;
+  line?: number;
+}
+
+function renderRulesTable(data: any): void {
+  console.log('\n# Manifesto Rules\n');
+
+  console.log(
+    `  ${'Rule'.padEnd(20)} ${'Level'.padEnd(10)} ${'Status'.padEnd(8)} ${'Warn'.padStart(6)} ${'Fail'.padStart(6)} ${'Violations'.padStart(11)}`,
+  );
+  console.log(
+    `  ${'─'.repeat(20)} ${'─'.repeat(10)} ${'─'.repeat(8)} ${'─'.repeat(6)} ${'─'.repeat(6)} ${'─'.repeat(11)}`,
+  );
+
+  for (const rule of data.rules) {
+    const warn = rule.thresholds.warn != null ? String(rule.thresholds.warn) : '—';
+    const fail = rule.thresholds.fail != null ? String(rule.thresholds.fail) : '—';
+    const statusIcon = rule.status === 'pass' ? 'pass' : rule.status === 'warn' ? 'WARN' : 'FAIL';
+    console.log(
+      `  ${rule.name.padEnd(20)} ${rule.level.padEnd(10)} ${statusIcon.padEnd(8)} ${warn.padStart(6)} ${fail.padStart(6)} ${String(rule.violationCount).padStart(11)}`,
+    );
+  }
+
+  const s = data.summary;
+  console.log(
+    `\n  ${s.total} rules | ${s.passed} passed | ${s.warned} warned | ${s.failed} failed | ${s.violationCount} violations`,
+  );
+}
+
+function renderViolationList(
+  label: string,
+  violations: ManifestoViolationRow[],
+  maxShown = 20,
+): void {
+  if (violations.length === 0) return;
+  console.log(`\n## ${label} (${violations.length})\n`);
+  for (const v of violations.slice(0, maxShown)) {
+    const loc = v.line ? `${v.file}:${v.line}` : v.file;
+    const tag = label === 'Failures' ? 'FAIL' : 'WARN';
+    console.log(
+      `  [${tag}] ${v.rule}: ${v.name} (${v.value}) at ${loc} — threshold ${v.threshold}`,
+    );
+  }
+  if (violations.length > maxShown) {
+    console.log(`  ... and ${violations.length - maxShown} more`);
+  }
+}
+
+function renderViolations(violations: ManifestoViolationRow[]): void {
+  if (violations.length === 0) return;
+  const failViolations = violations.filter((v) => v.level === 'fail');
+  const warnViolations = violations.filter((v) => v.level === 'warn');
+  renderViolationList('Failures', failViolations);
+  renderViolationList('Warnings', warnViolations);
+}
+
+export function manifesto(customDbPath: string | undefined, opts: ManifestoOpts = {}): void {
+  const data = manifestoData(customDbPath, opts as any) as any;
+
+  if (outputResult(data, 'violations', opts)) {
+    if (!data.passed) process.exitCode = 1;
+    return;
+  }
+
+  renderRulesTable(data);
+  renderViolations(data.violations);
+  console.log();
+
+  if (!data.passed) {
+    process.exitCode = 1;
+  }
+}

package/src/presentation/owners.ts

@@ -0,0 +1,89 @@
+import { ownersData } from '../features/owners.js';
+import { outputResult } from '../infrastructure/result-formatter.js';
+
+interface OwnersOpts {
+  json?: boolean;
+  ndjson?: boolean;
+  table?: boolean;
+  csv?: boolean;
+  owner?: string;
+  boundary?: string;
+  file?: string | string[];
+  kind?: string;
+  noTests?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+interface OwnerEntry {
+  name: string;
+  kind: string;
+  file: string;
+  line: number;
+  owners: string[];
+}
+
+interface OwnersResult {
+  codeownersFile: string | null;
+  files: Array<{ file: string; owners: string[] }>;
+  symbols: OwnerEntry[];
+  boundaries: Array<{
+    from: OwnerEntry;
+    to: OwnerEntry;
+    edgeKind: string;
+  }>;
+  summary: {
+    coveragePercent: number;
+    ownedFiles: number;
+    totalFiles: number;
+    ownerCount: number;
+    byOwner: Array<{ owner: string; fileCount: number }>;
+  };
+}
+
+export function owners(customDbPath: string | undefined, opts: OwnersOpts = {}): void {
+  const data = ownersData(customDbPath, opts as any) as OwnersResult;
+  if (outputResult(data as unknown as Record<string, unknown>, null, opts)) return;
+
+  if (!data.codeownersFile) {
+    console.log('No CODEOWNERS file found.');
+    return;
+  }
+
+  console.log(`\nCODEOWNERS: ${data.codeownersFile}\n`);
+
+  const s = data.summary;
+  console.log(
+    `  Coverage: ${s.coveragePercent}% (${s.ownedFiles}/${s.totalFiles} files owned, ${s.ownerCount} owners)\n`,
+  );
+
+  if (s.byOwner.length > 0) {
+    console.log('  Owners:\n');
+    for (const o of s.byOwner) {
+      console.log(`    ${o.owner}  ${o.fileCount} files`);
+    }
+    console.log();
+  }
+
+  if (data.files.length > 0 && opts.owner) {
+    console.log(`  Files owned by ${opts.owner}:\n`);
+    for (const f of data.files) {
+      console.log(`    ${f.file}`);
+    }
+    console.log();
+  }
+
+  if (data.boundaries.length > 0) {
+    console.log(`  Cross-owner boundaries: ${data.boundaries.length} edges\n`);
+    const shown = data.boundaries.slice(0, 30);
+    for (const b of shown) {
+      const srcOwner = b.from.owners.join(', ') || '(unowned)';
+      const tgtOwner = b.to.owners.join(', ') || '(unowned)';
+      console.log(`    ${b.from.name} [${srcOwner}] -> ${b.to.name} [${tgtOwner}]`);
+    }
+    if (data.boundaries.length > 30) {
+      console.log(`    ... and ${data.boundaries.length - 30} more`);
+    }
+    console.log();
+  }
+}

package/src/presentation/queries-cli/exports.ts

@@ -0,0 +1,152 @@
+import { exportsData, kindIcon } from '../../domain/queries.js';
+import { outputResult } from '../../infrastructure/result-formatter.js';
+
+interface ExportConsumer {
+  name: string;
+  file: string;
+  line: number;
+}
+
+interface ExportSymbol {
+  kind: string;
+  name: string;
+  line: number;
+  role?: string;
+  signature?: { params?: string };
+  consumers: ExportConsumer[];
+}
+
+interface ReexportedSymbol extends ExportSymbol {
+  originFile: string;
+}
+
+interface ExportsDataResult {
+  file: string;
+  totalExported: number;
+  totalInternal: number;
+  totalUnused: number;
+  totalReexported?: number;
+  totalReexportedUnused?: number;
+  results: ExportSymbol[];
+  reexportedSymbols: ReexportedSymbol[];
+  reexports: { file: string }[];
+}
+
+interface ExportsOpts {
+  json?: boolean;
+  ndjson?: boolean;
+  csv?: boolean;
+  table?: boolean;
+  noTests?: boolean;
+  unused?: boolean;
+  [key: string]: unknown;
+}
+
+function printExportHeader(data: ExportsDataResult, opts: ExportsOpts): void {
+  if (opts.unused) {
+    console.log(
+      `\n# ${data.file} — ${data.totalUnused} unused export${data.totalUnused !== 1 ? 's' : ''} (of ${data.totalExported} exported)\n`,
+    );
+  } else {
+    const unusedNote = data.totalUnused > 0 ? ` (${data.totalUnused} unused)` : '';
+    console.log(
+      `\n# ${data.file} — ${data.totalExported} exported${unusedNote}, ${data.totalInternal} internal\n`,
+    );
+  }
+}
+
+function printExportSymbols(results: ExportSymbol[]): void {
+  for (const sym of 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})`);
+      }
+    }
+  }
+}
+
+function groupByOriginFile(reexportedSymbols: ReexportedSymbol[]): Map<string, ReexportedSymbol[]> {
+  const byOrigin = new Map<string, ReexportedSymbol[]>();
+  for (const sym of reexportedSymbols) {
+    if (!byOrigin.has(sym.originFile)) byOrigin.set(sym.originFile, []);
+    byOrigin.get(sym.originFile)!.push(sym);
+  }
+  return byOrigin;
+}
+
+function printReexportSymbol(sym: ExportSymbol, indent: string): void {
+  const icon = kindIcon(sym.kind);
+  const sig = sym.signature?.params ? `(${sym.signature.params})` : '';
+  const role = sym.role ? ` [${sym.role}]` : '';
+  console.log(`${indent}${icon} ${sym.name}${sig}${role} :${sym.line}`);
+  if (sym.consumers.length === 0) {
+    console.log(`${indent}  (no consumers)`);
+  } else {
+    for (const c of sym.consumers) {
+      console.log(`${indent}  <- ${c.name} (${c.file}:${c.line})`);
+    }
+  }
+}
+
+function printReexportedSymbols(reexportedSymbols: ReexportedSymbol[]): void {
+  const byOrigin = groupByOriginFile(reexportedSymbols);
+
+  for (const [originFile, syms] of byOrigin) {
+    console.log(`\n  from ${originFile}:`);
+    for (const sym of syms) {
+      printReexportSymbol(sym, '    ');
+    }
+  }
+}
+
+function printReexportedSection(data: ExportsDataResult, opts: ExportsOpts): void {
+  const totalReexported = opts.unused
+    ? (data.totalReexportedUnused ?? data.reexportedSymbols.length)
+    : (data.totalReexported ?? data.reexportedSymbols.length);
+  const plural = totalReexported !== 1 ? 's' : '';
+  if (data.results.length === 0) {
+    const label = opts.unused ? 'unused re-exported' : 're-exported';
+    console.log(
+      `\n# ${data.file} — barrel file (${totalReexported} ${label} symbol${plural} from sub-modules)\n`,
+    );
+  } else {
+    console.log(`\n  Re-exported symbols (${totalReexported} from sub-modules):`);
+  }
+  printReexportedSymbols(data.reexportedSymbols);
+}
+
+export function fileExports(file: string, customDbPath: string, opts: ExportsOpts = {}): void {
+  const data = exportsData(file, customDbPath, opts) as ExportsDataResult;
+  if (outputResult(data as unknown as Record<string, unknown>, 'results', opts)) return;
+
+  const hasReexported = data.reexportedSymbols && data.reexportedSymbols.length > 0;
+
+  if (data.results.length === 0 && !hasReexported) {
+    if (opts.unused) {
+      console.log(`No unused exports found for "${file}".`);
+    } else {
+      console.log(`No exported symbols found for "${file}". Run "codegraph build" first.`);
+    }
+    return;
+  }
+
+  if (data.results.length > 0) {
+    printExportHeader(data, opts);
+    printExportSymbols(data.results);
+  }
+
+  if (hasReexported) {
+    printReexportedSection(data, opts);
+  }
+
+  if (data.reexports.length > 0) {
+    console.log(`\n  Re-exported by: ${data.reexports.map((r) => r.file).join(', ')}`);
+  }
+  console.log();
+}

package/src/presentation/queries-cli/impact.ts

@@ -0,0 +1,340 @@
+import {
+  diffImpactData,
+  diffImpactMermaid,
+  fileDepsData,
+  fnDepsData,
+  fnImpactData,
+  impactAnalysisData,
+  kindIcon,
+} from '../../domain/queries.js';
+import { outputResult } from '../../infrastructure/result-formatter.js';
+
+interface SymbolRef {
+  kind: string;
+  name: string;
+  file: string;
+  line: number;
+}
+
+interface FileDepsImport {
+  file: string;
+  typeOnly?: boolean;
+}
+
+interface FileDepsResult {
+  file: string;
+  imports: FileDepsImport[];
+  importedBy: { file: string }[];
+  definitions: SymbolRef[];
+}
+
+interface FileDepsData {
+  results: FileDepsResult[];
+}
+
+interface CallerRef extends SymbolRef {
+  viaHierarchy?: string;
+}
+
+interface FnDepsResult extends SymbolRef {
+  callees: SymbolRef[];
+  callers: CallerRef[];
+  transitiveCallers: Record<string, SymbolRef[]>;
+}
+
+interface FnDepsData {
+  results: FnDepsResult[];
+}
+
+interface ImpactNode {
+  file: string;
+}
+
+interface ImpactData {
+  sources: string[];
+  levels: Record<string, ImpactNode[]>;
+  totalDependents: number;
+}
+
+interface FnImpactResult extends SymbolRef {
+  levels: Record<string, SymbolRef[]>;
+  totalDependents: number;
+}
+
+interface FnImpactData {
+  results: FnImpactResult[];
+}
+
+interface AffectedFunction extends SymbolRef {
+  transitiveCallers: number;
+}
+
+interface CoupledFile {
+  file: string;
+  coupledWith: string;
+  jaccard: number;
+  commitCount: number;
+}
+
+interface BoundaryViolation {
+  name: string;
+  file: string;
+  targetFile: string;
+  message?: string;
+}
+
+interface DiffSummary {
+  functionsChanged: number;
+  callersAffected: number;
+  filesAffected: number;
+  historicallyCoupledCount: number;
+  ownersAffected: number;
+  boundaryViolationCount: number;
+}
+
+interface DiffImpactData {
+  error?: string;
+  changedFiles: number;
+  affectedFunctions: AffectedFunction[];
+  historicallyCoupled?: CoupledFile[];
+  ownership?: {
+    affectedOwners: string[];
+    suggestedReviewers: string[];
+  };
+  boundaryViolations?: BoundaryViolation[];
+  boundaryViolationCount?: number;
+  summary?: DiffSummary;
+}
+
+interface OutputOpts {
+  json?: boolean;
+  ndjson?: boolean;
+  csv?: boolean;
+  table?: boolean;
+  noTests?: boolean;
+  limit?: number;
+  offset?: number;
+  depth?: number;
+  format?: string;
+  staged?: boolean;
+  ref?: string;
+  file?: string;
+  kind?: string;
+  [key: string]: unknown;
+}
+
+export function fileDeps(file: string, customDbPath: string, opts: OutputOpts = {}): void {
+  const data = fileDepsData(file, customDbPath, opts) as unknown as FileDepsData;
+  if (outputResult(data as unknown as Record<string, unknown>, 'results', opts)) return;
+
+  if (data.results.length === 0) {
+    console.log(`No file matching "${file}" in graph`);
+    return;
+  }
+
+  for (const r of data.results) {
+    console.log(`\n# ${r.file}\n`);
+    console.log(`  -> Imports (${r.imports.length}):`);
+    for (const i of r.imports) {
+      const typeTag = i.typeOnly ? ' (type-only)' : '';
+      console.log(`    -> ${i.file}${typeTag}`);
+    }
+    console.log(`\n  <- Imported by (${r.importedBy.length}):`);
+    for (const i of r.importedBy) console.log(`    <- ${i.file}`);
+    if (r.definitions.length > 0) {
+      console.log(`\n  Definitions (${r.definitions.length}):`);
+      for (const d of r.definitions.slice(0, 30))
+        console.log(`    ${kindIcon(d.kind)} ${d.name} :${d.line}`);
+      if (r.definitions.length > 30) console.log(`    ... and ${r.definitions.length - 30} more`);
+    }
+    console.log();
+  }
+}
+
+function printFnDepsCallees(callees: SymbolRef[]): void {
+  if (callees.length === 0) return;
+  console.log(`  -> Calls (${callees.length}):`);
+  for (const c of callees) console.log(`    -> ${kindIcon(c.kind)} ${c.name}  ${c.file}:${c.line}`);
+}
+
+function printFnDepsCallers(callers: CallerRef[]): void {
+  if (callers.length === 0) return;
+  console.log(`\n  <- Called by (${callers.length}):`);
+  for (const c of callers) {
+    const via = c.viaHierarchy ? ` (via ${c.viaHierarchy})` : '';
+    console.log(`    <- ${kindIcon(c.kind)} ${c.name}  ${c.file}:${c.line}${via}`);
+  }
+}
+
+function printFnDepsTransitive(transitiveCallers: Record<string, SymbolRef[]>): void {
+  for (const [d, fns] of Object.entries(transitiveCallers)) {
+    const depth = parseInt(d, 10);
+    console.log(`\n  ${'<-'.repeat(depth)} Transitive callers (depth ${d}, ${fns.length}):`);
+    for (const n of fns.slice(0, 20))
+      console.log(
+        `    ${'  '.repeat(depth - 1)}<- ${kindIcon(n.kind)} ${n.name}  ${n.file}:${n.line}`,
+      );
+    if (fns.length > 20) console.log(`    ... and ${fns.length - 20} more`);
+  }
+}
+
+export function fnDeps(name: string, customDbPath: string, opts: OutputOpts = {}): void {
+  const data = fnDepsData(name, customDbPath, opts) as unknown as FnDepsData;
+  if (outputResult(data as unknown as Record<string, unknown>, 'results', opts)) return;
+
+  if (data.results.length === 0) {
+    console.log(`No function/method/class matching "${name}"`);
+    return;
+  }
+
+  for (const r of data.results) {
+    console.log(`\n${kindIcon(r.kind)} ${r.name} (${r.kind}) -- ${r.file}:${r.line}\n`);
+    printFnDepsCallees(r.callees);
+    printFnDepsCallers(r.callers);
+    printFnDepsTransitive(r.transitiveCallers);
+    if (r.callees.length === 0 && r.callers.length === 0) {
+      console.log(`  (no call edges found -- may be invoked dynamically or via re-exports)`);
+    }
+    console.log();
+  }
+}
+
+export function impactAnalysis(file: string, customDbPath: string, opts: OutputOpts = {}): void {
+  const data = impactAnalysisData(file, customDbPath, opts) as unknown as ImpactData;
+  if (outputResult(data as unknown as Record<string, unknown>, 'sources', opts)) return;
+
+  if (data.sources.length === 0) {
+    console.log(`No file matching "${file}" in graph`);
+    return;
+  }
+
+  console.log(`\nImpact analysis for files matching "${file}":\n`);
+  for (const s of data.sources) console.log(`  # ${s} (source)`);
+
+  const levels = data.levels;
+  if (Object.keys(levels).length === 0) {
+    console.log(`  No dependents found.`);
+  } else {
+    for (const level of Object.keys(levels).sort((a, b) => Number(a) - Number(b))) {
+      const nodes = levels[level]!;
+      console.log(
+        `\n  ${'--'.repeat(parseInt(level, 10))} Level ${level} (${nodes.length} files):`,
+      );
+      for (const n of nodes.slice(0, 30))
+        console.log(`    ${'  '.repeat(parseInt(level, 10))}^ ${n.file}`);
+      if (nodes.length > 30) console.log(`    ... and ${nodes.length - 30} more`);
+    }
+  }
+  console.log(`\n  Total: ${data.totalDependents} files transitively depend on "${file}"\n`);
+}
+
+function printFnImpactLevels(levels: Record<string, SymbolRef[]>): void {
+  if (Object.keys(levels).length === 0) {
+    console.log(`  No callers found.`);
+    return;
+  }
+  for (const [level, fns] of Object.entries(levels).sort((a, b) => Number(a[0]) - Number(b[0]))) {
+    const l = parseInt(level, 10);
+    console.log(`  ${'--'.repeat(l)} Level ${level} (${fns.length} functions):`);
+    for (const f of fns.slice(0, 20))
+      console.log(`    ${'  '.repeat(l)}^ ${kindIcon(f.kind)} ${f.name}  ${f.file}:${f.line}`);
+    if (fns.length > 20) console.log(`    ... and ${fns.length - 20} more`);
+  }
+}
+
+export function fnImpact(name: string, customDbPath: string, opts: OutputOpts = {}): void {
+  const data = fnImpactData(name, customDbPath, opts) as unknown as FnImpactData;
+  if (outputResult(data as unknown as Record<string, unknown>, 'results', opts)) return;
+
+  if (data.results.length === 0) {
+    console.log(`No function/method/class matching "${name}"`);
+    return;
+  }
+
+  for (const r of data.results) {
+    console.log(`\nFunction impact: ${kindIcon(r.kind)} ${r.name} -- ${r.file}:${r.line}\n`);
+    printFnImpactLevels(r.levels);
+    console.log(`\n  Total: ${r.totalDependents} functions transitively depend on ${r.name}\n`);
+  }
+}
+
+function printDiffFunctions(data: DiffImpactData): void {
+  console.log(`\ndiff-impact: ${data.changedFiles} files changed\n`);
+  console.log(`  ${data.affectedFunctions.length} functions changed:\n`);
+  for (const fn of data.affectedFunctions) {
+    console.log(`  ${kindIcon(fn.kind)} ${fn.name} -- ${fn.file}:${fn.line}`);
+    if (fn.transitiveCallers > 0) console.log(`    ^ ${fn.transitiveCallers} transitive callers`);
+  }
+}
+
+function printDiffCoupled(data: DiffImpactData): void {
+  if (!data.historicallyCoupled?.length) return;
+  console.log('\n  Historically coupled (not in static graph):\n');
+  for (const c of data.historicallyCoupled) {
+    const pct = `${(c.jaccard * 100).toFixed(0)}%`;
+    console.log(
+      `    ${c.file}  <- coupled with ${c.coupledWith} (${pct}, ${c.commitCount} commits)`,
+    );
+  }
+}
+
+function printDiffOwnership(data: DiffImpactData): void {
+  if (!data.ownership) return;
+  console.log(`\n  Affected owners: ${data.ownership.affectedOwners.join(', ')}`);
+  console.log(`  Suggested reviewers: ${data.ownership.suggestedReviewers.join(', ')}`);
+}
+
+function printDiffBoundaries(data: DiffImpactData): void {
+  if (!data.boundaryViolations?.length) return;
+  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}`);
+  }
+}
+
+function printDiffSummary(summary: DiffSummary | undefined): void {
+  if (!summary) return;
+  let line = `\n  Summary: ${summary.functionsChanged} functions changed -> ${summary.callersAffected} callers affected across ${summary.filesAffected} files`;
+  if (summary.historicallyCoupledCount > 0) {
+    line += `, ${summary.historicallyCoupledCount} historically coupled`;
+  }
+  if (summary.ownersAffected > 0) {
+    line += `, ${summary.ownersAffected} owners affected`;
+  }
+  if (summary.boundaryViolationCount > 0) {
+    line += `, ${summary.boundaryViolationCount} boundary violations`;
+  }
+  console.log(`${line}\n`);
+}
+
+export function diffImpact(customDbPath: string, opts: OutputOpts = {}): void {
+  if (opts.format === 'mermaid') {
+    console.log(diffImpactMermaid(customDbPath, opts));
+    return;
+  }
+  const data = diffImpactData(customDbPath, opts) as unknown as DiffImpactData;
+  if (opts.format === 'json') opts = { ...opts, json: true };
+  if (outputResult(data as unknown as Record<string, unknown>, 'affectedFunctions', opts)) return;
+
+  if (data.error) {
+    console.log(data.error);
+    return;
+  }
+  if (data.changedFiles === 0) {
+    console.log('No changes detected.');
+    return;
+  }
+  if (data.affectedFunctions.length === 0) {
+    console.log(
+      '  No function-level changes detected (changes may be in imports, types, or config).',
+    );
+    return;
+  }
+
+  printDiffFunctions(data);
+  printDiffCoupled(data);
+  printDiffOwnership(data);
+  printDiffBoundaries(data);
+  printDiffSummary(data.summary);
+}

package/src/presentation/queries-cli/index.ts

@@ -0,0 +1,13 @@
+export { fileExports } from './exports.js';
+export { diffImpact, fileDeps, fnDeps, fnImpact, impactAnalysis } from './impact.js';
+export {
+  children,
+  context,
+  explain,
+  implementations,
+  interfaces,
+  queryName,
+  where,
+} from './inspect.js';
+export { dynamicCalls, moduleMap, roles, stats } from './overview.js';
+export { symbolPath } from './path.js';