optave-codegraph 3.13.0

package/src/presentation/complexity.ts

@@ -0,0 +1,127 @@
+import { complexityData } from '../features/complexity.js';
+import { outputResult } from '../infrastructure/result-formatter.js';
+
+interface ComplexityCliOpts {
+  json?: boolean;
+  ndjson?: boolean;
+  noTests?: boolean;
+  target?: string;
+  limit?: number;
+  sort?: string;
+  aboveThreshold?: boolean;
+  health?: boolean;
+  file?: string;
+  kind?: string;
+  offset?: number;
+  config?: unknown;
+}
+
+interface ComplexityFunction {
+  name: string;
+  file: string;
+  cognitive: number;
+  cyclomatic: number;
+  maxNesting: number;
+  maintainabilityIndex: number;
+  loc: number;
+  sloc: number;
+  exceeds?: string[];
+  halstead: {
+    volume: number;
+    difficulty: number;
+    effort: number;
+    bugs: number;
+  };
+}
+
+interface ComplexitySummary {
+  analyzed: number;
+  avgCognitive: number;
+  avgCyclomatic: number;
+  avgMI?: number;
+  aboveWarn: number;
+}
+
+interface ComplexityResult {
+  functions: ComplexityFunction[];
+  summary: ComplexitySummary | null;
+  hasGraph: boolean;
+}
+
+/** Render health-focused table with Halstead + MI columns. */
+function renderHealthTable(functions: ComplexityFunction[]): void {
+  console.log(
+    `  ${'Function'.padEnd(35)} ${'File'.padEnd(25)} ${'MI'.padStart(5)} ${'Vol'.padStart(7)} ${'Diff'.padStart(6)} ${'Effort'.padStart(9)} ${'Bugs'.padStart(6)} ${'LOC'.padStart(5)} ${'SLOC'.padStart(5)}`,
+  );
+  console.log(
+    `  ${'─'.repeat(35)} ${'─'.repeat(25)} ${'─'.repeat(5)} ${'─'.repeat(7)} ${'─'.repeat(6)} ${'─'.repeat(9)} ${'─'.repeat(6)} ${'─'.repeat(5)} ${'─'.repeat(5)}`,
+  );
+  for (const fn of functions) {
+    const name = fn.name.length > 33 ? `${fn.name.slice(0, 32)}…` : fn.name;
+    const file = fn.file.length > 23 ? `…${fn.file.slice(-22)}` : fn.file;
+    const miWarn = fn.exceeds?.includes('maintainabilityIndex') ? '!' : ' ';
+    console.log(
+      `  ${name.padEnd(35)} ${file.padEnd(25)} ${String(fn.maintainabilityIndex).padStart(5)}${miWarn}${String(fn.halstead.volume).padStart(7)} ${String(fn.halstead.difficulty).padStart(6)} ${String(fn.halstead.effort).padStart(9)} ${String(fn.halstead.bugs).padStart(6)} ${String(fn.loc).padStart(5)} ${String(fn.sloc).padStart(5)}`,
+    );
+  }
+}
+
+/** Render default complexity table with MI column. */
+function renderDefaultTable(functions: ComplexityFunction[]): void {
+  console.log(
+    `  ${'Function'.padEnd(40)} ${'File'.padEnd(30)} ${'Cog'.padStart(4)} ${'Cyc'.padStart(4)} ${'Nest'.padStart(5)} ${'MI'.padStart(5)}`,
+  );
+  console.log(
+    `  ${'─'.repeat(40)} ${'─'.repeat(30)} ${'─'.repeat(4)} ${'─'.repeat(4)} ${'─'.repeat(5)} ${'─'.repeat(5)}`,
+  );
+  for (const fn of functions) {
+    const name = fn.name.length > 38 ? `${fn.name.slice(0, 37)}…` : fn.name;
+    const file = fn.file.length > 28 ? `…${fn.file.slice(-27)}` : fn.file;
+    const warn = fn.exceeds ? ' !' : '';
+    const mi = fn.maintainabilityIndex > 0 ? String(fn.maintainabilityIndex) : '-';
+    console.log(
+      `  ${name.padEnd(40)} ${file.padEnd(30)} ${String(fn.cognitive).padStart(4)} ${String(fn.cyclomatic).padStart(4)} ${String(fn.maxNesting).padStart(5)} ${mi.padStart(5)}${warn}`,
+    );
+  }
+}
+
+export function complexity(customDbPath: string | undefined, opts: ComplexityCliOpts = {}): void {
+  const data = complexityData(customDbPath, opts as any) as unknown as ComplexityResult;
+
+  if (outputResult(data, 'functions', opts)) return;
+
+  if (data.functions.length === 0) {
+    if (data.summary === null) {
+      if (data.hasGraph) {
+        console.log(
+          '\nNo complexity data found, but a graph exists. Run "codegraph build --no-incremental" to populate complexity metrics.\n',
+        );
+      } else {
+        console.log(
+          '\nNo complexity data found. Run "codegraph build" first to analyze your codebase.\n',
+        );
+      }
+    } else {
+      console.log('\nNo functions match the given filters.\n');
+    }
+    return;
+  }
+
+  const header = opts.aboveThreshold ? 'Functions Above Threshold' : 'Function Complexity';
+  console.log(`\n# ${header}\n`);
+
+  if (opts.health) {
+    renderHealthTable(data.functions);
+  } else {
+    renderDefaultTable(data.functions);
+  }
+
+  if (data.summary) {
+    const s = data.summary;
+    const miPart = s.avgMI != null ? ` | avg MI: ${s.avgMI}` : '';
+    console.log(
+      `\n  ${s.analyzed} functions analyzed | avg cognitive: ${s.avgCognitive} | avg cyclomatic: ${s.avgCyclomatic}${miPart} | ${s.aboveWarn} above threshold`,
+    );
+  }
+  console.log();
+}

package/src/presentation/dataflow.ts

@@ -0,0 +1,179 @@
+import { dataflowData, dataflowImpactData } from '../features/dataflow.js';
+import { outputResult } from '../infrastructure/result-formatter.js';
+
+interface DataflowCliOpts {
+  json?: boolean;
+  ndjson?: boolean;
+  noTests?: boolean;
+  file?: string;
+  kind?: string;
+  impact?: boolean;
+  depth?: string | number;
+  limit?: number;
+  offset?: number;
+}
+
+interface DataflowFlow {
+  target?: string;
+  source?: string;
+  file: string;
+  line: number;
+  paramIndex: number;
+  confidence: number;
+}
+
+interface DataflowReturn {
+  consumer?: string;
+  producer?: string;
+  file: string;
+  line: number;
+  expression: string;
+}
+
+interface DataflowMutation {
+  source?: string;
+  expression: string;
+  line: number;
+}
+
+interface DataflowResultEntry {
+  kind: string;
+  name: string;
+  file: string;
+  line: number;
+  flowsTo: DataflowFlow[];
+  flowsFrom: DataflowFlow[];
+  returns: DataflowReturn[];
+  returnedBy: DataflowReturn[];
+  mutates: DataflowMutation[];
+  mutatedBy: DataflowMutation[];
+}
+
+interface DataflowImpactEntry {
+  kind: string;
+  name: string;
+  file: string;
+  line: number;
+  totalAffected: number;
+  levels: Record<string, Array<{ name: string; file: string; line: number }>>;
+}
+
+function printDataflowFlows(r: DataflowResultEntry): void {
+  if (r.flowsTo.length > 0) {
+    console.log('\n  Data flows TO:');
+    for (const f of r.flowsTo) {
+      const conf = f.confidence < 1.0 ? ` [${(f.confidence * 100).toFixed(0)}%]` : '';
+      console.log(`    \u2192 ${f.target} (${f.file}:${f.line}) arg[${f.paramIndex}]${conf}`);
+    }
+  }
+  if (r.flowsFrom.length > 0) {
+    console.log('\n  Data flows FROM:');
+    for (const f of r.flowsFrom) {
+      const conf = f.confidence < 1.0 ? ` [${(f.confidence * 100).toFixed(0)}%]` : '';
+      console.log(`    \u2190 ${f.source} (${f.file}:${f.line}) arg[${f.paramIndex}]${conf}`);
+    }
+  }
+}
+
+function printDataflowReturns(r: DataflowResultEntry): void {
+  if (r.returns.length > 0) {
+    console.log('\n  Return value consumed by:');
+    for (const c of r.returns) {
+      console.log(`    \u2192 ${c.consumer} (${c.file}:${c.line})  ${c.expression}`);
+    }
+  }
+  if (r.returnedBy.length > 0) {
+    console.log('\n  Uses return value of:');
+    for (const p of r.returnedBy) {
+      console.log(`    \u2190 ${p.producer} (${p.file}:${p.line})  ${p.expression}`);
+    }
+  }
+}
+
+function printDataflowMutations(r: DataflowResultEntry): void {
+  if (r.mutates.length > 0) {
+    console.log('\n  Mutates:');
+    for (const m of r.mutates) {
+      console.log(`    \u270E ${m.expression}  (line ${m.line})`);
+    }
+  }
+  if (r.mutatedBy.length > 0) {
+    console.log('\n  Mutated by:');
+    for (const m of r.mutatedBy) {
+      console.log(`    \u270E ${m.source} \u2014 ${m.expression}  (line ${m.line})`);
+    }
+  }
+}
+
+export function dataflow(
+  name: string,
+  customDbPath: string | undefined,
+  opts: DataflowCliOpts = {},
+): void {
+  if (opts.impact) {
+    dataflowImpact(name, customDbPath, opts);
+    return;
+  }
+
+  const data = dataflowData(name, customDbPath, opts) as {
+    warning?: string;
+    results: DataflowResultEntry[];
+  };
+
+  if (outputResult(data, 'results', opts)) return;
+
+  if (data.warning) {
+    console.log(`\u26A0  ${data.warning}`);
+    return;
+  }
+  if (data.results.length === 0) {
+    console.log(`No symbols matching "${name}".`);
+    return;
+  }
+
+  for (const r of data.results) {
+    console.log(`\n${r.kind} ${r.name}  (${r.file}:${r.line})`);
+    console.log('\u2500'.repeat(60));
+    printDataflowFlows(r);
+    printDataflowReturns(r);
+    printDataflowMutations(r);
+  }
+}
+
+function dataflowImpact(
+  name: string,
+  customDbPath: string | undefined,
+  opts: DataflowCliOpts = {},
+): void {
+  const data = dataflowImpactData(name, customDbPath, {
+    noTests: opts.noTests,
+    depth: opts.depth ? Number(opts.depth) : 5,
+    file: opts.file,
+    kind: opts.kind,
+    limit: opts.limit,
+    offset: opts.offset,
+  }) as { warning?: string; results: DataflowImpactEntry[] };
+
+  if (outputResult(data, 'results', opts)) return;
+
+  if (data.warning) {
+    console.log(`\u26A0  ${data.warning}`);
+    return;
+  }
+  if (data.results.length === 0) {
+    console.log(`No symbols matching "${name}".`);
+    return;
+  }
+
+  for (const r of data.results) {
+    console.log(
+      `\n${r.kind} ${r.name}  (${r.file}:${r.line})  \u2014 ${r.totalAffected} data-dependent consumer${r.totalAffected !== 1 ? 's' : ''}`,
+    );
+    for (const [level, items] of Object.entries(r.levels)) {
+      console.log(`  Level ${level}:`);
+      for (const item of items) {
+        console.log(`    ${item.name} (${item.file}:${item.line})`);
+      }
+    }
+  }
+}

package/src/presentation/diff-impact-mermaid.ts

@@ -0,0 +1,169 @@
+import { diffImpactData } from '../domain/analysis/diff-impact.js';
+
+interface MermaidNodeRegistry {
+  nodeIdMap: Map<string, string>;
+  nodeLabels: Map<string, string>;
+  counter: number;
+}
+
+interface ImpactEdgeSets {
+  allEdges: Set<string>;
+  edgeFromNodes: Set<string>;
+  edgeToNodes: Set<string>;
+  changedKeys: Set<string>;
+}
+
+function createNodeRegistry(): MermaidNodeRegistry {
+  return { nodeIdMap: new Map(), nodeLabels: new Map(), counter: 0 };
+}
+
+function registerNode(reg: MermaidNodeRegistry, key: string, label?: string): string {
+  if (!reg.nodeIdMap.has(key)) {
+    reg.nodeIdMap.set(key, `n${reg.counter++}`);
+    if (label) reg.nodeLabels.set(key, label);
+  }
+  return reg.nodeIdMap.get(key)!;
+}
+
+function registerAllNodes(reg: MermaidNodeRegistry, affectedFunctions: any[]): void {
+  for (const fn of affectedFunctions) {
+    registerNode(reg, `${fn.file}::${fn.name}:${fn.line}`, fn.name);
+    for (const callers of Object.values(fn.levels || {})) {
+      for (const c of callers as Array<{ name: string; file: string; line: number }>) {
+        registerNode(reg, `${c.file}::${c.name}:${c.line}`, c.name);
+      }
+    }
+  }
+}
+
+function collectEdges(affectedFunctions: any[]): ImpactEdgeSets {
+  const allEdges = new Set<string>();
+  const edgeFromNodes = new Set<string>();
+  const edgeToNodes = new Set<string>();
+  const changedKeys = new Set<string>();
+
+  for (const fn of affectedFunctions) {
+    changedKeys.add(`${fn.file}::${fn.name}:${fn.line}`);
+    for (const edge of fn.edges || []) {
+      const edgeKey = `${edge.from}|${edge.to}`;
+      if (!allEdges.has(edgeKey)) {
+        allEdges.add(edgeKey);
+        edgeFromNodes.add(edge.from);
+        edgeToNodes.add(edge.to);
+      }
+    }
+  }
+
+  return { allEdges, edgeFromNodes, edgeToNodes, changedKeys };
+}
+
+function classifyCallerNodes(edges: ImpactEdgeSets): {
+  blastRadiusKeys: Set<string>;
+  intermediateKeys: Set<string>;
+} {
+  const blastRadiusKeys = new Set<string>();
+  for (const key of edges.edgeToNodes) {
+    if (!edges.edgeFromNodes.has(key) && !edges.changedKeys.has(key)) {
+      blastRadiusKeys.add(key);
+    }
+  }
+
+  const intermediateKeys = new Set<string>();
+  for (const key of edges.edgeToNodes) {
+    if (!edges.changedKeys.has(key) && !blastRadiusKeys.has(key)) {
+      intermediateKeys.add(key);
+    }
+  }
+
+  return { blastRadiusKeys, intermediateKeys };
+}
+
+function emitFileSubgraphs(
+  lines: string[],
+  affectedFunctions: any[],
+  newFileSet: Set<string>,
+  reg: MermaidNodeRegistry,
+): number {
+  const fileGroups = new Map<string, any[]>();
+  for (const fn of affectedFunctions) {
+    if (!fileGroups.has(fn.file)) fileGroups.set(fn.file, []);
+    fileGroups.get(fn.file)!.push(fn);
+  }
+
+  let sgCounter = 0;
+  for (const [file, fns] of fileGroups) {
+    const isNew = newFileSet.has(file);
+    const tag = isNew ? 'new' : 'modified';
+    const sgId = `sg${sgCounter++}`;
+    lines.push(`    subgraph ${sgId}["${file} **(${tag})**"]`);
+    for (const fn of fns) {
+      const key = `${fn.file}::${fn.name}:${fn.line}`;
+      lines.push(`        ${reg.nodeIdMap.get(key)}["${fn.name}"]`);
+    }
+    lines.push('    end');
+    const style = isNew ? 'fill:#e8f5e9,stroke:#4caf50' : 'fill:#fff3e0,stroke:#ff9800';
+    lines.push(`    style ${sgId} ${style}`);
+  }
+
+  return sgCounter;
+}
+
+function emitBlastRadiusSubgraph(
+  lines: string[],
+  blastRadiusKeys: Set<string>,
+  reg: MermaidNodeRegistry,
+  sgCounter: number,
+): void {
+  if (blastRadiusKeys.size === 0) return;
+  const sgId = `sg${sgCounter}`;
+  lines.push(`    subgraph ${sgId}["Callers **(blast radius)**"]`);
+  for (const key of blastRadiusKeys) {
+    lines.push(`        ${reg.nodeIdMap.get(key)}["${reg.nodeLabels.get(key)}"]`);
+  }
+  lines.push('    end');
+  lines.push(`    style ${sgId} fill:#f3e5f5,stroke:#9c27b0`);
+}
+
+export function diffImpactMermaid(
+  customDbPath: string,
+  opts: {
+    noTests?: boolean;
+    depth?: number;
+    staged?: boolean;
+    ref?: string;
+    includeImplementors?: boolean;
+    limit?: number;
+    offset?: number;
+    config?: any;
+  } = {},
+): string {
+  const data: any = diffImpactData(customDbPath, opts);
+  if ('error' in data) return data.error as string;
+  if (data.changedFiles === 0 || data.affectedFunctions.length === 0) {
+    return 'flowchart TB\n    none["No impacted functions detected"]';
+  }
+
+  const newFileSet = new Set<string>(data.newFiles || []);
+  const lines = ['flowchart TB'];
+
+  const reg = createNodeRegistry();
+  registerAllNodes(reg, data.affectedFunctions);
+
+  const edges = collectEdges(data.affectedFunctions);
+  const { blastRadiusKeys, intermediateKeys } = classifyCallerNodes(edges);
+
+  const sgCounter = emitFileSubgraphs(lines, data.affectedFunctions, newFileSet, reg);
+
+  for (const key of intermediateKeys) {
+    lines.push(`    ${reg.nodeIdMap.get(key)}["${reg.nodeLabels.get(key)}"]`);
+  }
+
+  emitBlastRadiusSubgraph(lines, blastRadiusKeys, reg, sgCounter);
+
+  for (const edgeKey of edges.allEdges) {
+    const [from, to] = edgeKey.split('|') as [string, string];
+    lines.push(`    ${reg.nodeIdMap.get(from)} --> ${reg.nodeIdMap.get(to)}`);
+  }
+
+  return lines.join('\n');
+}