@optave/codegraph 3.11.0 → 3.11.1

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();

package/src/features/sequence.ts

@@ -91,6 +91,40 @@ interface BfsResult {
   truncated: boolean;
 }
 
+type CalleeNode = { id: number; name: string; file: string; kind: string; line: number };
+
+interface BfsFrame {
+  visited: Set<number>;
+  messages: SequenceMessage[];
+  fileSet: Set<string>;
+  idToNode: Map<number, CalleeNode>;
+  nextFrontier: number[];
+}
+
+function processCallee(
+  c: CalleeNode,
+  caller: CalleeNode,
+  depth: number,
+  noTests: boolean,
+  frame: BfsFrame,
+): void {
+  if (noTests && isTestFile(c.file)) return;
+
+  frame.fileSet.add(c.file);
+  frame.messages.push({
+    from: caller.file,
+    to: c.file,
+    label: c.name,
+    type: 'call',
+    depth,
+  });
+
+  if (frame.visited.has(c.id)) return;
+  frame.visited.add(c.id);
+  frame.nextFrontier.push(c.id);
+  frame.idToNode.set(c.id, c);
+}
+
 function bfsCallees(
   repo: Repository,
   matchNode: MatchNode,
@@ -101,46 +135,25 @@ function bfsCallees(
   let frontier = [matchNode.id];
   const messages: SequenceMessage[] = [];
   const fileSet = new Set<string>([matchNode.file]);
-  const idToNode = new Map<
-    number,
-    { id: number; name: string; file: string; kind: string; line: number }
-  >();
+  const idToNode = new Map<number, CalleeNode>();
   idToNode.set(matchNode.id, matchNode);
   let truncated = false;
 
   for (let d = 1; d <= maxDepth; d++) {
-    const nextFrontier: number[] = [];
+    const frame: BfsFrame = { visited, messages, fileSet, idToNode, nextFrontier: [] };
 
     for (const fid of frontier) {
-      const callees = repo.findCallees(fid);
       const caller = idToNode.get(fid)!;
-
-      for (const c of callees) {
-        if (noTests && isTestFile(c.file)) continue;
-
-        fileSet.add(c.file);
-        messages.push({
-          from: caller.file,
-          to: c.file,
-          label: c.name,
-          type: 'call',
-          depth: d,
-        });
-
-        if (visited.has(c.id)) continue;
-
-        visited.add(c.id);
-        nextFrontier.push(c.id);
-        idToNode.set(c.id, c);
+      for (const c of repo.findCallees(fid)) {
+        processCallee(c, caller, d, noTests, frame);
       }
     }
 
-    frontier = nextFrontier;
+    frontier = frame.nextFrontier;
     if (frontier.length === 0) break;
 
-    if (d === maxDepth && frontier.length > 0) {
-      const hasMoreCalls = frontier.some((fid) => repo.findCallees(fid).length > 0);
-      if (hasMoreCalls) truncated = true;
+    if (d === maxDepth && frontier.some((fid) => repo.findCallees(fid).length > 0)) {
+      truncated = true;
     }
   }
 
@@ -174,26 +187,16 @@ function annotateDataflow(
   }
 }
 
-function _annotateDataflowImpl(
-  db: BetterSqlite3Database,
+type DataflowStmts = {
+  getReturns: ReturnType<BetterSqlite3Database['prepare']>;
+  getFlowsTo: ReturnType<BetterSqlite3Database['prepare']>;
+};
+
+function appendReturnMessages(
   messages: SequenceMessage[],
-  idToNode: Map<number, { id: number; name: string; file: string; kind: string; line: number }>,
+  nodeByNameFile: Map<string, { id: number; name: string; file: string }>,
+  stmts: DataflowStmts,
 ): void {
-  const nodeByNameFile = new Map<string, { id: number; name: string; file: string }>();
-  for (const n of idToNode.values()) {
-    nodeByNameFile.set(`${n.name}|${n.file}`, n);
-  }
-
-  const getReturns = db.prepare(
-    `SELECT d.expression FROM dataflow d
-         WHERE d.source_id = ? AND d.kind = 'returns'`,
-  );
-  const getFlowsTo = db.prepare(
-    `SELECT d.expression FROM dataflow d
-         WHERE d.target_id = ? AND d.kind = 'flows_to'
-         ORDER BY d.param_index`,
-  );
-
   const seenReturns = new Set<string>();
   for (const msg of [...messages]) {
     if (msg.type !== 'call') continue;
@@ -203,40 +206,67 @@ function _annotateDataflowImpl(
     const returnKey = `${msg.to}->${msg.from}:${msg.label}`;
     if (seenReturns.has(returnKey)) continue;
 
-    const returns = getReturns.all(targetNode.id) as { expression: string }[];
-
-    if (returns.length > 0) {
-      seenReturns.add(returnKey);
-      const expr = returns[0]!.expression || 'result';
-      messages.push({
-        from: msg.to,
-        to: msg.from,
-        label: expr,
-        type: 'return',
-        depth: msg.depth,
-      });
-    }
+    const returns = stmts.getReturns.all(targetNode.id) as { expression: string }[];
+    if (returns.length === 0) continue;
+
+    seenReturns.add(returnKey);
+    messages.push({
+      from: msg.to,
+      to: msg.from,
+      label: returns[0]!.expression || 'result',
+      type: 'return',
+      depth: msg.depth,
+    });
   }
+}
 
+function annotateCallParams(
+  messages: SequenceMessage[],
+  nodeByNameFile: Map<string, { id: number; name: string; file: string }>,
+  stmts: DataflowStmts,
+): void {
   for (const msg of messages) {
     if (msg.type !== 'call') continue;
     const targetNode = nodeByNameFile.get(`${msg.label}|${msg.to}`);
     if (!targetNode) continue;
 
-    const params = getFlowsTo.all(targetNode.id) as { expression: string }[];
-
-    if (params.length > 0) {
-      const paramNames = params
-        .map((p) => p.expression)
-        .filter(Boolean)
-        .slice(0, 3);
-      if (paramNames.length > 0) {
-        msg.label = `${msg.label}(${paramNames.join(', ')})`;
-      }
+    const params = stmts.getFlowsTo.all(targetNode.id) as { expression: string }[];
+    const paramNames = params
+      .map((p) => p.expression)
+      .filter(Boolean)
+      .slice(0, 3);
+    if (paramNames.length > 0) {
+      msg.label = `${msg.label}(${paramNames.join(', ')})`;
     }
   }
 }
 
+function _annotateDataflowImpl(
+  db: BetterSqlite3Database,
+  messages: SequenceMessage[],
+  idToNode: Map<number, { id: number; name: string; file: string; kind: string; line: number }>,
+): void {
+  const nodeByNameFile = new Map<string, { id: number; name: string; file: string }>();
+  for (const n of idToNode.values()) {
+    nodeByNameFile.set(`${n.name}|${n.file}`, n);
+  }
+
+  const stmts: DataflowStmts = {
+    getReturns: db.prepare(
+      `SELECT d.expression FROM dataflow d
+         WHERE d.source_id = ? AND d.kind = 'returns'`,
+    ),
+    getFlowsTo: db.prepare(
+      `SELECT d.expression FROM dataflow d
+         WHERE d.target_id = ? AND d.kind = 'flows_to'
+         ORDER BY d.param_index`,
+    ),
+  };
+
+  appendReturnMessages(messages, nodeByNameFile, stmts);
+  annotateCallParams(messages, nodeByNameFile, stmts);
+}
+
 interface Participant {
   id: string;
   label: string;