@optave/codegraph 3.8.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/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;
 }