@optave/codegraph 3.10.0 → 3.11.1

package/src/features/graph-enrichment.ts

@@ -336,13 +336,13 @@ interface FileLevelEdge {
   target: string;
 }
 
-function prepareFileLevelData(
+/** Load file-level import/call edges from the DB and optionally exclude test files. */
+function loadFileLevelEdges(
   db: BetterSqlite3Database,
   noTests: boolean,
   minConf: number,
-  cfg: PlotConfig,
-): GraphData {
-  let edges = db
+): FileLevelEdge[] {
+  const edges = db
     .prepare<FileLevelEdge>(
       `
       SELECT DISTINCT n1.file AS source, n2.file AS target
@@ -354,73 +354,118 @@ function prepareFileLevelData(
     `,
     )
     .all(minConf);
-  if (noTests) edges = edges.filter((e) => !isTestFile(e.source) && !isTestFile(e.target));
-
-  const files = new Set<string>();
-  for (const { source, target } of edges) {
-    files.add(source);
-    files.add(target);
-  }
-
-  const fileIds = new Map<string, number>();
-  let idx = 0;
-  for (const f of files) fileIds.set(f, idx++);
+  return noTests ? edges.filter((e) => !isTestFile(e.source) && !isTestFile(e.target)) : edges;
+}
 
-  // Fan-in/fan-out
+/** Compute fan-in and fan-out for each file from a list of edges. */
+function computeFileFanCounts(edges: FileLevelEdge[]): {
+  fanInCount: Map<string, number>;
+  fanOutCount: Map<string, number>;
+} {
   const fanInCount = new Map<string, number>();
   const fanOutCount = new Map<string, number>();
   for (const { source, target } of edges) {
     fanOutCount.set(source, (fanOutCount.get(source) || 0) + 1);
     fanInCount.set(target, (fanInCount.get(target) || 0) + 1);
   }
+  return { fanInCount, fanOutCount };
+}
 
-  // Communities via graph subsystem
+/** Run Louvain community detection on the file-level graph. Returns empty map on failure. */
+function detectFileCommunities(files: Set<string>, edges: FileLevelEdge[]): Map<string, number> {
   const communityMap = new Map<string, number>();
-  if (files.size > 0) {
-    try {
-      const fileGraph = new CodeGraph();
-      for (const f of files) fileGraph.addNode(f);
-      for (const { source, target } of edges) {
-        if (source !== target && !fileGraph.hasEdge(source, target))
-          fileGraph.addEdge(source, target);
-      }
-      const { assignments } = louvainCommunities(fileGraph);
-      for (const [file, cid] of assignments) communityMap.set(file, cid);
-    } catch {
-      // ignore
+  if (files.size === 0) return communityMap;
+  try {
+    const fileGraph = new CodeGraph();
+    for (const f of files) fileGraph.addNode(f);
+    for (const { source, target } of edges) {
+      if (source !== target && !fileGraph.hasEdge(source, target))
+        fileGraph.addEdge(source, target);
     }
+    const { assignments } = louvainCommunities(fileGraph);
+    for (const [file, cid] of assignments) communityMap.set(file, cid);
+  } catch {
+    // louvain can fail on disconnected graphs
   }
+  return communityMap;
+}
 
-  const visNodes: VisNode[] = [...files].map((f) => {
-    const id = fileIds.get(f)!;
-    const community = communityMap.get(f) ?? null;
-    const fanIn = fanInCount.get(f) || 0;
-    const fanOut = fanOutCount.get(f) || 0;
-    const directory = path.dirname(f);
-    const color: string =
-      cfg.colorBy === 'community' && community !== null
-        ? COMMUNITY_COLORS[community % COMMUNITY_COLORS.length] || '#ccc'
-        : cfg.nodeColors?.file || (DEFAULT_NODE_COLORS as Record<string, string>).file || '#ccc';
-
-    return {
-      id,
-      label: path.basename(f),
-      title: f,
-      color,
-      kind: 'file',
-      role: '',
-      file: f,
-      line: 0,
-      community,
-      cognitive: null,
-      cyclomatic: null,
-      maintainabilityIndex: null,
-      fanIn,
-      fanOut,
-      directory,
-      risk: [],
-    };
-  });
+/** Build a VisNode for a single file, applying color based on cfg.colorBy. */
+function buildFileVisNode(
+  file: string,
+  id: number,
+  community: number | null,
+  fanIn: number,
+  fanOut: number,
+  cfg: PlotConfig,
+): VisNode {
+  const color: string =
+    cfg.colorBy === 'community' && community !== null
+      ? COMMUNITY_COLORS[community % COMMUNITY_COLORS.length] || '#ccc'
+      : cfg.nodeColors?.file || (DEFAULT_NODE_COLORS as Record<string, string>).file || '#ccc';
+
+  return {
+    id,
+    label: path.basename(file),
+    title: file,
+    color,
+    kind: 'file',
+    role: '',
+    file,
+    line: 0,
+    community,
+    cognitive: null,
+    cyclomatic: null,
+    maintainabilityIndex: null,
+    fanIn,
+    fanOut,
+    directory: path.dirname(file),
+    risk: [],
+  };
+}
+
+/** Select seed node IDs for the file-level graph based on configured strategy. */
+function selectFileSeedNodes(visNodes: VisNode[], cfg: PlotConfig): (number | string)[] {
+  if (cfg.seedStrategy === 'top-fanin') {
+    const sorted = [...visNodes].sort((a, b) => b.fanIn - a.fanIn);
+    return sorted.slice(0, cfg.seedCount || 30).map((n) => n.id);
+  }
+  // Both 'entry' and the default fallback include every node — file-level graphs
+  // don't track per-file roles, so 'entry' has no meaningful filter.
+  return visNodes.map((n) => n.id);
+}
+
+function prepareFileLevelData(
+  db: BetterSqlite3Database,
+  noTests: boolean,
+  minConf: number,
+  cfg: PlotConfig,
+): GraphData {
+  const edges = loadFileLevelEdges(db, noTests, minConf);
+
+  const files = new Set<string>();
+  for (const { source, target } of edges) {
+    files.add(source);
+    files.add(target);
+  }
+
+  const fileIds = new Map<string, number>();
+  let idx = 0;
+  for (const f of files) fileIds.set(f, idx++);
+
+  const { fanInCount, fanOutCount } = computeFileFanCounts(edges);
+  const communityMap = detectFileCommunities(files, edges);
+
+  const visNodes: VisNode[] = [...files].map((f) =>
+    buildFileVisNode(
+      f,
+      fileIds.get(f)!,
+      communityMap.get(f) ?? null,
+      fanInCount.get(f) || 0,
+      fanOutCount.get(f) || 0,
+      cfg,
+    ),
+  );
 
   const visEdges: VisEdge[] = edges.map(({ source, target }, i) => ({
     id: `e${i}`,
@@ -428,17 +473,7 @@ function prepareFileLevelData(
     to: fileIds.get(target)!,
   }));
 
-  let seedNodeIds: (number | string)[];
-  if (cfg.seedStrategy === 'top-fanin') {
-    const sorted = [...visNodes].sort((a, b) => b.fanIn - a.fanIn);
-    seedNodeIds = sorted.slice(0, cfg.seedCount || 30).map((n) => n.id);
-  } else if (cfg.seedStrategy === 'entry') {
-    seedNodeIds = visNodes.map((n) => n.id);
-  } else {
-    seedNodeIds = visNodes.map((n) => n.id);
-  }
-
-  return { nodes: visNodes, edges: visEdges, seedNodeIds };
+  return { nodes: visNodes, edges: visEdges, seedNodeIds: selectFileSeedNodes(visNodes, cfg) };
 }
 
 // ─── HTML Generation (thin wrapper) ──────────────────────────────────

package/src/features/owners.ts

@@ -139,18 +139,25 @@ interface OwnersDataOpts {
   boundary?: boolean;
 }
 
-export function ownersData(
-  customDbPath?: string,
-  opts: OwnersDataOpts = {},
-): {
+interface OwnedSymbol {
+  name: string;
+  kind: string;
+  file: string;
+  line: number;
+  owners: string[];
+}
+
+interface OwnerBoundary {
+  from: OwnedSymbol;
+  to: OwnedSymbol;
+  edgeKind: string;
+}
+
+interface OwnersDataResult {
   codeownersFile: string | null;
   files: { file: string; owners: string[] }[];
-  symbols: { name: string; kind: string; file: string; line: number; owners: string[] }[];
-  boundaries: {
-    from: { name: string; kind: string; file: string; line: number; owners: string[] };
-    to: { name: string; kind: string; file: string; line: number; owners: string[] };
-    edgeKind: string;
-  }[];
+  symbols: OwnedSymbol[];
+  boundaries: OwnerBoundary[];
   summary: {
     totalFiles: number;
     ownedFiles: number;
@@ -159,160 +166,193 @@ export function ownersData(
     ownerCount: number;
     byOwner: { owner: string; fileCount: number }[];
   };
+}
+
+interface BetterSqlite3DatabaseLike {
+  prepare(sql: string): { all(...params: unknown[]): unknown[] };
+  close(): void;
+}
+
+function emptyOwnersResult(codeownersFile: string | null): OwnersDataResult {
+  return {
+    codeownersFile,
+    files: [],
+    symbols: [],
+    boundaries: [],
+    summary: {
+      totalFiles: 0,
+      ownedFiles: 0,
+      unownedFiles: 0,
+      coveragePercent: 0,
+      ownerCount: 0,
+      byOwner: [],
+    },
+  };
+}
+
+/** Load all distinct files from the DB and apply test/file filters. */
+function loadFilteredFiles(db: BetterSqlite3DatabaseLike, opts: OwnersDataOpts): string[] {
+  let allFiles = (db.prepare('SELECT DISTINCT file FROM nodes').all() as { file: string }[]).map(
+    (r) => r.file,
+  );
+  if (opts.noTests) allFiles = allFiles.filter((f) => !isTestFile(f));
+  const fileFilters = normalizeFileFilter(opts.file);
+  if (fileFilters.length > 0) {
+    allFiles = allFiles.filter((f) => fileFilters.some((filter) => f.includes(filter)));
+  }
+  return allFiles;
+}
+
+/** Build owner index (owner -> list of files) and count owned files. */
+function buildOwnerIndex(fileOwners: { file: string; owners: string[] }[]): {
+  ownerIndex: Map<string, string[]>;
+  ownedCount: number;
 } {
+  const ownerIndex = new Map<string, string[]>();
+  let ownedCount = 0;
+  for (const fo of fileOwners) {
+    if (fo.owners.length > 0) ownedCount++;
+    for (const o of fo.owners) {
+      if (!ownerIndex.has(o)) ownerIndex.set(o, []);
+      ownerIndex.get(o)!.push(fo.file);
+    }
+  }
+  return { ownerIndex, ownedCount };
+}
+
+/** Load symbols restricted to the given file set, applying noTests and kind filters. */
+function loadSymbolsForFiles(
+  db: BetterSqlite3DatabaseLike,
+  fileSet: Set<string>,
+  opts: OwnersDataOpts,
+  rules: CodeownersRule[],
+): OwnedSymbol[] {
+  let symbols = (
+    db.prepare('SELECT name, kind, file, line FROM nodes').all() as {
+      name: string;
+      kind: string;
+      file: string;
+      line: number;
+    }[]
+  ).filter((n) => fileSet.has(n.file));
+
+  if (opts.noTests) symbols = symbols.filter((s) => !isTestFile(s.file));
+  if (opts.kind) symbols = symbols.filter((s) => s.kind === opts.kind);
+
+  return symbols.map((s) => ({ ...s, owners: matchOwners(s.file, rules) }));
+}
+
+interface CallEdgeRow {
+  id: number;
+  edgeKind: string;
+  srcName: string;
+  srcKind: string;
+  srcFile: string;
+  srcLine: number;
+  tgtName: string;
+  tgtKind: string;
+  tgtFile: string;
+  tgtLine: number;
+}
+
+/** Compute cross-owner call boundaries. Returns empty array when boundary mode is off. */
+function computeOwnerBoundaries(
+  db: BetterSqlite3DatabaseLike,
+  rules: CodeownersRule[],
+  noTests: boolean,
+): OwnerBoundary[] {
+  const edges = db
+    .prepare(
+      `SELECT e.id, e.kind AS edgeKind,
+              s.name AS srcName, s.kind AS srcKind, s.file AS srcFile, s.line AS srcLine,
+              t.name AS tgtName, t.kind AS tgtKind, t.file AS tgtFile, t.line AS tgtLine
+       FROM edges e
+       JOIN nodes s ON e.source_id = s.id
+       JOIN nodes t ON e.target_id = t.id
+       WHERE e.kind = 'calls'`,
+    )
+    .all() as CallEdgeRow[];
+
+  const boundaries: OwnerBoundary[] = [];
+  for (const e of edges) {
+    if (noTests && (isTestFile(e.srcFile) || isTestFile(e.tgtFile))) continue;
+    const srcOwners = matchOwners(e.srcFile, rules);
+    const tgtOwners = matchOwners(e.tgtFile, rules);
+    // Cross-boundary: different owner sets (sort for deterministic comparison + output)
+    const sortedSrc = [...srcOwners].sort();
+    const sortedTgt = [...tgtOwners].sort();
+    const srcKey = sortedSrc.join(',');
+    const tgtKey = sortedTgt.join(',');
+    if (srcKey === tgtKey) continue;
+    boundaries.push({
+      from: {
+        name: e.srcName,
+        kind: e.srcKind,
+        file: e.srcFile,
+        line: e.srcLine,
+        owners: sortedSrc,
+      },
+      to: { name: e.tgtName, kind: e.tgtKind, file: e.tgtFile, line: e.tgtLine, owners: sortedTgt },
+      edgeKind: e.edgeKind,
+    });
+  }
+  return boundaries;
+}
+
+/** Build summary stats (totals, coverage, by-owner counts). */
+function buildOwnersSummary(
+  totalFiles: number,
+  ownedCount: number,
+  ownerIndex: Map<string, string[]>,
+): OwnersDataResult['summary'] {
+  const byOwner = [...ownerIndex.entries()]
+    .map(([owner, files]) => ({ owner, fileCount: files.length }))
+    .sort((a, b) => b.fileCount - a.fileCount);
+
+  return {
+    totalFiles,
+    ownedFiles: ownedCount,
+    unownedFiles: totalFiles - ownedCount,
+    coveragePercent: totalFiles > 0 ? Math.round((ownedCount / totalFiles) * 100) : 0,
+    ownerCount: ownerIndex.size,
+    byOwner,
+  };
+}
+
+export function ownersData(customDbPath?: string, opts: OwnersDataOpts = {}): OwnersDataResult {
   const db = openReadonlyOrFail(customDbPath);
   try {
     const dbPath = findDbPath(customDbPath);
     const repoRoot = path.resolve(path.dirname(dbPath), '..');
 
     const parsed = parseCodeowners(repoRoot);
-    if (!parsed) {
-      return {
-        codeownersFile: null,
-        files: [],
-        symbols: [],
-        boundaries: [],
-        summary: {
-          totalFiles: 0,
-          ownedFiles: 0,
-          unownedFiles: 0,
-          coveragePercent: 0,
-          ownerCount: 0,
-          byOwner: [],
-        },
-      };
-    }
-
-    // Get all distinct files from nodes
-    let allFiles = (db.prepare('SELECT DISTINCT file FROM nodes').all() as { file: string }[]).map(
-      (r) => r.file,
-    );
+    if (!parsed) return emptyOwnersResult(null);
 
-    if (opts.noTests) allFiles = allFiles.filter((f) => !isTestFile(f));
-    const fileFilters = normalizeFileFilter(opts.file);
-    if (fileFilters.length > 0) {
-      allFiles = allFiles.filter((f) => fileFilters.some((filter) => f.includes(filter)));
-    }
-
-    // Map files to owners
-    const fileOwners = allFiles.map((file) => ({
-      file,
-      owners: matchOwners(file, parsed.rules),
-    }));
-
-    // Build owner-to-files index
-    const ownerIndex = new Map<string, string[]>();
-    let ownedCount = 0;
-    for (const fo of fileOwners) {
-      if (fo.owners.length > 0) ownedCount++;
-      for (const o of fo.owners) {
-        if (!ownerIndex.has(o)) ownerIndex.set(o, []);
-        ownerIndex.get(o)!.push(fo.file);
-      }
-    }
+    // Stage 1: load files and bucket them by owner
+    const allFiles = loadFilteredFiles(db, opts);
+    const fileOwners = allFiles.map((file) => ({ file, owners: matchOwners(file, parsed.rules) }));
+    const { ownerIndex, ownedCount } = buildOwnerIndex(fileOwners);
 
-    // Filter files if --owner specified
-    let filteredFiles = fileOwners;
-    if (opts.owner) {
-      filteredFiles = fileOwners.filter((fo) => fo.owners.includes(opts.owner!));
-    }
+    // Stage 2: apply optional --owner filter
+    const filteredFiles = opts.owner
+      ? fileOwners.filter((fo) => fo.owners.includes(opts.owner!))
+      : fileOwners;
 
-    // Get symbols for filtered files
+    // Stage 3: load symbols for filtered files
     const fileSet = new Set(filteredFiles.map((fo) => fo.file));
-    let symbols = (
-      db.prepare('SELECT name, kind, file, line FROM nodes').all() as {
-        name: string;
-        kind: string;
-        file: string;
-        line: number;
-      }[]
-    ).filter((n) => fileSet.has(n.file));
-
-    if (opts.noTests) symbols = symbols.filter((s) => !isTestFile(s.file));
-    if (opts.kind) symbols = symbols.filter((s) => s.kind === opts.kind);
-
-    const symbolsWithOwners = symbols.map((s) => ({
-      ...s,
-      owners: matchOwners(s.file, parsed.rules),
-    }));
-
-    // Boundary analysis — cross-owner call edges
-    const boundaries: {
-      from: { name: string; kind: string; file: string; line: number; owners: string[] };
-      to: { name: string; kind: string; file: string; line: number; owners: string[] };
-      edgeKind: string;
-    }[] = [];
-    if (opts.boundary) {
-      const edges = db
-        .prepare(
-          `SELECT e.id, e.kind AS edgeKind,
-                  s.name AS srcName, s.kind AS srcKind, s.file AS srcFile, s.line AS srcLine,
-                  t.name AS tgtName, t.kind AS tgtKind, t.file AS tgtFile, t.line AS tgtLine
-           FROM edges e
-           JOIN nodes s ON e.source_id = s.id
-           JOIN nodes t ON e.target_id = t.id
-           WHERE e.kind = 'calls'`,
-        )
-        .all() as {
-        id: number;
-        edgeKind: string;
-        srcName: string;
-        srcKind: string;
-        srcFile: string;
-        srcLine: number;
-        tgtName: string;
-        tgtKind: string;
-        tgtFile: string;
-        tgtLine: number;
-      }[];
-
-      for (const e of edges) {
-        if (opts.noTests && (isTestFile(e.srcFile) || isTestFile(e.tgtFile))) continue;
-        const srcOwners = matchOwners(e.srcFile, parsed.rules);
-        const tgtOwners = matchOwners(e.tgtFile, parsed.rules);
-        // Cross-boundary: different owner sets
-        const srcKey = srcOwners.sort().join(',');
-        const tgtKey = tgtOwners.sort().join(',');
-        if (srcKey !== tgtKey) {
-          boundaries.push({
-            from: {
-              name: e.srcName,
-              kind: e.srcKind,
-              file: e.srcFile,
-              line: e.srcLine,
-              owners: srcOwners,
-            },
-            to: {
-              name: e.tgtName,
-              kind: e.tgtKind,
-              file: e.tgtFile,
-              line: e.tgtLine,
-              owners: tgtOwners,
-            },
-            edgeKind: e.edgeKind,
-          });
-        }
-      }
-    }
+    const symbolsWithOwners = loadSymbolsForFiles(db, fileSet, opts, parsed.rules);
 
-    // Summary
-    const byOwner = [...ownerIndex.entries()]
-      .map(([owner, files]) => ({ owner, fileCount: files.length }))
-      .sort((a, b) => b.fileCount - a.fileCount);
+    // Stage 4: optional boundary analysis (cross-owner call edges)
+    const boundaries = opts.boundary
+      ? computeOwnerBoundaries(db, parsed.rules, opts.noTests ?? false)
+      : [];
 
     return {
       codeownersFile: parsed.path,
       files: filteredFiles,
       symbols: symbolsWithOwners,
       boundaries,
-      summary: {
-        totalFiles: allFiles.length,
-        ownedFiles: ownedCount,
-        unownedFiles: allFiles.length - ownedCount,
-        coveragePercent: allFiles.length > 0 ? Math.round((ownedCount / allFiles.length) * 100) : 0,
-        ownerCount: ownerIndex.size,
-        byOwner,
-      },
+      summary: buildOwnersSummary(allFiles.length, ownedCount, ownerIndex),
     };
   } finally {
     db.close();