@optave/codegraph 3.7.0 → 3.8.1

package/src/features/structure-query.ts

@@ -68,6 +68,67 @@ interface DirectoryEntry {
   subdirectories: string[];
 }
 
+function buildDirectoryEntry(
+  d: DirRow,
+  filesStmt: { all(...params: unknown[]): unknown[] },
+  subdirsStmt: { all(...params: unknown[]): unknown[] },
+  noTests: boolean,
+): DirectoryEntry {
+  let files = filesStmt.all(d.id) as FileMetricRow[];
+  if (noTests) files = files.filter((f) => !isTestFile(f.name));
+
+  const subdirs = subdirsStmt.all(d.id) as { name: string }[];
+
+  const fileCount = noTests ? files.length : d.file_count || 0;
+  return {
+    directory: d.name,
+    fileCount,
+    symbolCount: d.symbol_count || 0,
+    fanIn: d.fan_in || 0,
+    fanOut: d.fan_out || 0,
+    cohesion: d.cohesion,
+    density: fileCount > 0 ? (d.symbol_count || 0) / fileCount : 0,
+    files: files.map((f) => ({
+      file: f.name,
+      lineCount: f.line_count || 0,
+      symbolCount: f.symbol_count || 0,
+      importCount: f.import_count || 0,
+      exportCount: f.export_count || 0,
+      fanIn: f.fan_in || 0,
+      fanOut: f.fan_out || 0,
+    })),
+    subdirectories: subdirs.map((s) => s.name),
+  };
+}
+
+function applyFileLimit(
+  result: DirectoryEntry[],
+  fileLimit: number,
+): { directories: DirectoryEntry[]; count: number; suppressed: number; warning: string } | null {
+  const totalFiles = result.reduce((sum, d) => sum + d.files.length, 0);
+  if (totalFiles <= fileLimit) return null;
+
+  let shown = 0;
+  for (const d of result) {
+    const remaining = fileLimit - shown;
+    if (remaining <= 0) {
+      d.files = [];
+    } else if (d.files.length > remaining) {
+      d.files = d.files.slice(0, remaining);
+      shown = fileLimit;
+    } else {
+      shown += d.files.length;
+    }
+  }
+  const suppressed = totalFiles - fileLimit;
+  return {
+    directories: result,
+    count: result.length,
+    suppressed,
+    warning: `${suppressed} files omitted (showing ${fileLimit}/${totalFiles}). Use --full to show all files, or narrow with --directory.`,
+  };
+}
+
 export function structureData(
   customDbPath?: string,
   opts: StructureDataOpts = {},
@@ -115,73 +176,27 @@ export function structureData(
     dirs.sort(sortFn);
 
     // Get file metrics for each directory
-    const result: DirectoryEntry[] = dirs.map((d) => {
-      let files = db
-        .prepare(`
-          SELECT n.name, nm.line_count, nm.symbol_count, nm.import_count, nm.export_count, nm.fan_in, nm.fan_out
-          FROM edges e
-          JOIN nodes n ON e.target_id = n.id
-          LEFT JOIN node_metrics nm ON n.id = nm.node_id
-          WHERE e.source_id = ? AND e.kind = 'contains' AND n.kind = 'file'
-        `)
-        .all(d.id) as FileMetricRow[];
-      if (noTests) files = files.filter((f) => !isTestFile(f.name));
-
-      const subdirs = db
-        .prepare(`
-          SELECT n.name
-          FROM edges e
-          JOIN nodes n ON e.target_id = n.id
-          WHERE e.source_id = ? AND e.kind = 'contains' AND n.kind = 'directory'
-        `)
-        .all(d.id) as { name: string }[];
-
-      const fileCount = noTests ? files.length : d.file_count || 0;
-      return {
-        directory: d.name,
-        fileCount,
-        symbolCount: d.symbol_count || 0,
-        fanIn: d.fan_in || 0,
-        fanOut: d.fan_out || 0,
-        cohesion: d.cohesion,
-        density: fileCount > 0 ? (d.symbol_count || 0) / fileCount : 0,
-        files: files.map((f) => ({
-          file: f.name,
-          lineCount: f.line_count || 0,
-          symbolCount: f.symbol_count || 0,
-          importCount: f.import_count || 0,
-          exportCount: f.export_count || 0,
-          fanIn: f.fan_in || 0,
-          fanOut: f.fan_out || 0,
-        })),
-        subdirectories: subdirs.map((s) => s.name),
-      };
-    });
+    const filesStmt = db.prepare(`
+      SELECT n.name, nm.line_count, nm.symbol_count, nm.import_count, nm.export_count, nm.fan_in, nm.fan_out
+      FROM edges e
+      JOIN nodes n ON e.target_id = n.id
+      LEFT JOIN node_metrics nm ON n.id = nm.node_id
+      WHERE e.source_id = ? AND e.kind = 'contains' AND n.kind = 'file'
+    `);
+    const subdirsStmt = db.prepare(`
+      SELECT n.name
+      FROM edges e
+      JOIN nodes n ON e.target_id = n.id
+      WHERE e.source_id = ? AND e.kind = 'contains' AND n.kind = 'directory'
+    `);
+    const result: DirectoryEntry[] = dirs.map((d) =>
+      buildDirectoryEntry(d, filesStmt, subdirsStmt, noTests),
+    );
 
     // Apply global file limit unless full mode
     if (!full) {
-      const totalFiles = result.reduce((sum, d) => sum + d.files.length, 0);
-      if (totalFiles > fileLimit) {
-        let shown = 0;
-        for (const d of result) {
-          const remaining = fileLimit - shown;
-          if (remaining <= 0) {
-            d.files = [];
-          } else if (d.files.length > remaining) {
-            d.files = d.files.slice(0, remaining);
-            shown = fileLimit;
-          } else {
-            shown += d.files.length;
-          }
-        }
-        const suppressed = totalFiles - fileLimit;
-        return {
-          directories: result,
-          count: result.length,
-          suppressed,
-          warning: `${suppressed} files omitted (showing ${fileLimit}/${totalFiles}). Use --full to show all files, or narrow with --directory.`,
-        };
-      }
+      const limited = applyFileLimit(result, fileLimit);
+      if (limited) return limited;
     }
 
     const base = { directories: result, count: result.length };

package/src/graph/algorithms/bfs.ts

@@ -1,3 +1,4 @@
+import { loadNative } from '../../infrastructure/native.js';
 import type { CodeGraph } from '../model.js';
 
 export interface BfsOpts {
@@ -8,6 +9,8 @@ export interface BfsOpts {
 /**
  * Breadth-first traversal on a CodeGraph.
  *
+ * Tries the native Rust implementation first, falls back to JS.
+ *
  * @returns nodeId → depth from nearest start node
  */
 export function bfs(
@@ -19,6 +22,37 @@ export function bfs(
   const direction = opts.direction ?? 'forward';
   const starts = Array.isArray(startIds) ? startIds : [startIds];
 
+  const native = loadNative();
+  if (native?.bfsTraversal) {
+    const edges = graph.toEdgeArray();
+    const nativeMaxDepth = maxDepth === Infinity ? null : maxDepth;
+    // Undirected graphs deduplicate edges to one canonical direction in toEdgeArray(),
+    // so the Rust side must traverse both directions to preserve symmetry.
+    const nativeDirection = !graph.directed ? 'both' : direction;
+    const result = native.bfsTraversal(edges, starts, nativeMaxDepth, nativeDirection);
+    const depths = new Map<string, number>();
+    for (const entry of result) {
+      depths.set(entry.node, entry.depth);
+    }
+    // The Rust side only knows nodes referenced by edges; restore any isolated start nodes.
+    for (const startId of starts) {
+      if (graph.hasNode(startId) && !depths.has(startId)) {
+        depths.set(startId, 0);
+      }
+    }
+    return depths;
+  }
+
+  return bfsJS(graph, starts, maxDepth, direction);
+}
+
+/** Pure JS fallback for BFS (used when native addon is unavailable). */
+function bfsJS(
+  graph: CodeGraph,
+  starts: string[],
+  maxDepth: number,
+  direction: string,
+): Map<string, number> {
   const depths = new Map<string, number>();
   const queue: string[] = [];
 

package/src/graph/algorithms/centrality.ts

@@ -1,3 +1,4 @@
+import { loadNative } from '../../infrastructure/native.js';
 import type { CodeGraph } from '../model.js';
 
 export interface FanInOut {
@@ -7,8 +8,37 @@ export interface FanInOut {
 
 /**
  * Fan-in / fan-out centrality for all nodes in a CodeGraph.
+ *
+ * Tries the native Rust implementation first, falls back to JS.
  */
 export function fanInOut(graph: CodeGraph): Map<string, FanInOut> {
+  const native = loadNative();
+  if (native?.fanInOut) {
+    let edges = graph.toEdgeArray();
+    if (!graph.directed) {
+      // Undirected: toEdgeArray() deduplicates to one canonical direction;
+      // mirror each edge so the Rust side counts symmetric in/out degrees.
+      edges = [...edges, ...edges.map((e) => ({ source: e.target, target: e.source }))];
+    }
+    const nativeResult = native.fanInOut(edges);
+    const result = new Map<string, FanInOut>();
+    for (const entry of nativeResult) {
+      result.set(entry.node, { fanIn: entry.fanIn, fanOut: entry.fanOut });
+    }
+    // Ensure isolated nodes (no edges) are included
+    for (const id of graph.nodeIds()) {
+      if (!result.has(id)) {
+        result.set(id, { fanIn: 0, fanOut: 0 });
+      }
+    }
+    return result;
+  }
+
+  return fanInOutJS(graph);
+}
+
+/** Pure JS fallback for fan-in/out. */
+function fanInOutJS(graph: CodeGraph): Map<string, FanInOut> {
   const result = new Map<string, FanInOut>();
   for (const id of graph.nodeIds()) {
     result.set(id, {

package/src/graph/algorithms/leiden/optimiser.ts

@@ -18,6 +18,13 @@ const DEFAULT_MAX_LEVELS: number = 50;
 const DEFAULT_MAX_LOCAL_PASSES: number = 20;
 const GAIN_EPSILON: number = 1e-12;
 
+/** Pre-allocated scratch buffers for refinement candidate collection. */
+interface RefinementScratch {
+  candC: Int32Array;
+  candGain: Float64Array;
+  candWeight: Float64Array;
+}
+
 const CandidateStrategy = {
   Neighbors: 0,
   All: 1,
@@ -335,6 +342,79 @@ function buildCoarseGraph(g: GraphAdapter, p: Partition): CodeGraph {
   return coarse;
 }
 
+/**
+ * Collect eligible candidate communities for node `v` during refinement.
+ * A candidate must: (a) be in the same macro-community, (b) respect the size
+ * limit, and (c) produce a positive quality gain above GAIN_EPSILON.
+ * Returns the number of collected candidates written into `scratch`.
+ */
+function collectRefinementCandidates(
+  p: Partition,
+  g: GraphAdapter,
+  v: number,
+  touchedCount: number,
+  macroV: number,
+  commMacro: Int32Array,
+  maxSize: number,
+  opts: NormalizedOptions,
+  scratch: RefinementScratch,
+): number {
+  let candLen: number = 0;
+  for (let t = 0; t < touchedCount; t++) {
+    const c: number = p.getCandidateCommunityAt(t);
+    if (c === p.nodeCommunity[v]!) continue;
+    if (commMacro[c]! !== macroV) continue;
+    if (maxSize < Infinity) {
+      const nextSize: number = p.getCommunityTotalSize(c) + g.size[v]!;
+      if (nextSize > maxSize) continue;
+    }
+    const gain: number = computeQualityGain(p, v, c, opts);
+    if (gain > GAIN_EPSILON) {
+      scratch.candC[candLen] = c;
+      scratch.candGain[candLen] = gain;
+      candLen++;
+    }
+  }
+  return candLen;
+}
+
+/**
+ * Boltzmann probabilistic selection from collected candidates (Algorithm 3).
+ * Returns the chosen community ID, or -1 if the node should stay as singleton.
+ *
+ * p(v, C) is proportional to exp(deltaH / theta), with the "stay as singleton"
+ * option (deltaH = 0) included. For numerical stability, the max gain is
+ * subtracted before exponentiation.
+ */
+function boltzmannSelectCandidate(
+  candLen: number,
+  theta: number,
+  rng: () => number,
+  scratch: RefinementScratch,
+): number {
+  let maxGain: number = 0;
+  for (let i = 0; i < candLen; i++) {
+    if (scratch.candGain[i]! > maxGain) maxGain = scratch.candGain[i]!;
+  }
+  // "Stay as singleton" weight: exp((0 - maxGain) / theta)
+  const stayWeight: number = Math.exp((0 - maxGain) / theta);
+  let totalWeight: number = stayWeight;
+  for (let i = 0; i < candLen; i++) {
+    scratch.candWeight[i] = Math.exp((scratch.candGain[i]! - maxGain) / theta);
+    totalWeight += scratch.candWeight[i]!;
+  }
+
+  const r: number = rng() * totalWeight;
+  if (r < stayWeight) return -1; // node stays as singleton
+
+  let cumulative: number = stayWeight;
+  for (let i = 0; i < candLen; i++) {
+    cumulative += scratch.candWeight[i]!;
+    if (r < cumulative) return scratch.candC[i]!;
+  }
+  return scratch.candC[candLen - 1]!; // fallback
+}
+
 /**
  * True Leiden refinement phase (Algorithm 3, Traag et al. 2019).
  *
@@ -380,10 +460,12 @@ function refineWithinCoarseCommunities(
   shuffleArrayInPlace(order, rng);
 
   // Pre-allocate flat arrays for candidate collection to avoid per-node GC pressure.
-  // Maximum possible candidates per node is bounded by g.n (community count).
-  const candC = new Int32Array(g.n);
-  const candGain = new Float64Array(g.n);
-  const candWeight = new Float64Array(g.n);
+  const scratch: RefinementScratch = {
+    candC: new Int32Array(g.n),
+    candGain: new Float64Array(g.n),
+    candWeight: new Float64Array(g.n),
+  };
+  const maxSize: number = Number.isFinite(opts.maxCommunitySize) ? opts.maxCommunitySize : Infinity;
 
   for (let idx = 0; idx < order.length; idx++) {
     const v: number = order[idx]!;
@@ -394,59 +476,21 @@ function refineWithinCoarseCommunities(
 
     const macroV: number = macro[v]!;
     const touchedCount: number = p.accumulateNeighborCommunityEdgeWeights(v);
-    const maxSize: number = Number.isFinite(opts.maxCommunitySize)
-      ? opts.maxCommunitySize
-      : Infinity;
-
-    // Collect eligible communities and their quality gains.
-    let candLen: number = 0;
-    for (let t = 0; t < touchedCount; t++) {
-      const c: number = p.getCandidateCommunityAt(t);
-      if (c === p.nodeCommunity[v]!) continue;
-      if (commMacro[c]! !== macroV) continue;
-      if (maxSize < Infinity) {
-        const nextSize: number = p.getCommunityTotalSize(c) + g.size[v]!;
-        if (nextSize > maxSize) continue;
-      }
-      const gain: number = computeQualityGain(p, v, c, opts);
-      if (gain > GAIN_EPSILON) {
-        candC[candLen] = c;
-        candGain[candLen] = gain;
-        candLen++;
-      }
-    }
-
+    const candLen: number = collectRefinementCandidates(
+      p,
+      g,
+      v,
+      touchedCount,
+      macroV,
+      commMacro,
+      maxSize,
+      opts,
+      scratch,
+    );
     if (candLen === 0) continue;
 
-    // Probabilistic selection: p(v, C) proportional to exp(deltaH / theta),
-    // with the "stay" option (deltaH = 0) included per Algorithm 3.
-    // For numerical stability, subtract the max gain before exponentiation.
-    let maxGain: number = 0;
-    for (let i = 0; i < candLen; i++) {
-      if (candGain[i]! > maxGain) maxGain = candGain[i]!;
-    }
-    // "Stay as singleton" weight: exp((0 - maxGain) / theta)
-    const stayWeight: number = Math.exp((0 - maxGain) / theta);
-    let totalWeight: number = stayWeight;
-    for (let i = 0; i < candLen; i++) {
-      candWeight[i] = Math.exp((candGain[i]! - maxGain) / theta);
-      totalWeight += candWeight[i]!;
-    }
-
-    const r: number = rng() * totalWeight;
-    if (r < stayWeight) continue; // node stays as singleton
-
-    let cumulative: number = stayWeight;
-    let chosenC: number = candC[candLen - 1]!; // fallback
-    for (let i = 0; i < candLen; i++) {
-      cumulative += candWeight[i]!;
-      if (r < cumulative) {
-        chosenC = candC[i]!;
-        break;
-      }
-    }
-
-    p.moveNodeToCommunity(v, chosenC);
+    const chosenC: number = boltzmannSelectCandidate(candLen, theta, rng, scratch);
+    if (chosenC >= 0) p.moveNodeToCommunity(v, chosenC);
   }
   return p;
 }