@optave/codegraph 3.1.3 → 3.1.5

package/src/{triage.js → features/triage.js}

@@ -1,39 +1,8 @@
-import { findNodesForTriage, openReadonlyOrFail } from './db.js';
-import { isTestFile } from './infrastructure/test-filter.js';
-import { warn } from './logger.js';
-import { paginateResult } from './paginate.js';
-
-// ─── Constants ────────────────────────────────────────────────────────
-
-const DEFAULT_WEIGHTS = {
-  fanIn: 0.25,
-  complexity: 0.3,
-  churn: 0.2,
-  role: 0.15,
-  mi: 0.1,
-};
-
-const ROLE_WEIGHTS = {
-  core: 1.0,
-  utility: 0.9,
-  entry: 0.8,
-  adapter: 0.5,
-  leaf: 0.2,
-  dead: 0.1,
-};
-
-const DEFAULT_ROLE_WEIGHT = 0.5;
-
-// ─── Helpers ──────────────────────────────────────────────────────────
-
-/** Min-max normalize an array of numbers. All-equal → all zeros. */
-function minMaxNormalize(values) {
-  const min = Math.min(...values);
-  const max = Math.max(...values);
-  if (max === min) return values.map(() => 0);
-  const range = max - min;
-  return values.map((v) => (v - min) / range);
-}
+import { openRepo } from '../db/index.js';
+import { DEFAULT_WEIGHTS, scoreRisk } from '../graph/classifiers/risk.js';
+import { warn } from '../infrastructure/logger.js';
+import { isTestFile } from '../infrastructure/test-filter.js';
+import { paginateResult } from '../shared/paginate.js';
 
 // ─── Data Function ────────────────────────────────────────────────────
 
@@ -45,7 +14,7 @@ function minMaxNormalize(values) {
  * @returns {{ items: object[], summary: object, _pagination?: object }}
  */
 export function triageData(customDbPath, opts = {}) {
-  const db = openReadonlyOrFail(customDbPath);
+  const { repo, close } = openRepo(customDbPath, opts);
   try {
     const noTests = opts.noTests || false;
     const fileFilter = opts.file || null;
@@ -57,7 +26,7 @@ export function triageData(customDbPath, opts = {}) {
 
     let rows;
     try {
-      rows = findNodesForTriage(db, {
+      rows = repo.findNodesForTriage({
         noTests,
         file: fileFilter,
         kind: kindFilter,
@@ -81,48 +50,27 @@ export function triageData(customDbPath, opts = {}) {
       };
     }
 
-    // Extract raw signal arrays
-    const fanIns = filtered.map((r) => r.fan_in);
-    const cognitives = filtered.map((r) => r.cognitive);
-    const churns = filtered.map((r) => r.churn);
-    const mis = filtered.map((r) => r.mi);
-
-    // Min-max normalize
-    const normFanIns = minMaxNormalize(fanIns);
-    const normCognitives = minMaxNormalize(cognitives);
-    const normChurns = minMaxNormalize(churns);
-    // MI: higher is better, so invert: 1 - norm(mi)
-    const normMIsRaw = minMaxNormalize(mis);
-    const normMIs = normMIsRaw.map((v) => round4(1 - v));
+    // Delegate scoring to classifier
+    const riskMetrics = scoreRisk(filtered, weights);
 
     // Compute risk scores
-    const items = filtered.map((r, i) => {
-      const roleWeight = ROLE_WEIGHTS[r.role] ?? DEFAULT_ROLE_WEIGHT;
-      const riskScore =
-        weights.fanIn * normFanIns[i] +
-        weights.complexity * normCognitives[i] +
-        weights.churn * normChurns[i] +
-        weights.role * roleWeight +
-        weights.mi * normMIs[i];
-
-      return {
-        name: r.name,
-        kind: r.kind,
-        file: r.file,
-        line: r.line,
-        role: r.role || null,
-        fanIn: r.fan_in,
-        cognitive: r.cognitive,
-        churn: r.churn,
-        maintainabilityIndex: r.mi,
-        normFanIn: round4(normFanIns[i]),
-        normComplexity: round4(normCognitives[i]),
-        normChurn: round4(normChurns[i]),
-        normMI: round4(normMIs[i]),
-        roleWeight,
-        riskScore: round4(riskScore),
-      };
-    });
+    const items = filtered.map((r, i) => ({
+      name: r.name,
+      kind: r.kind,
+      file: r.file,
+      line: r.line,
+      role: r.role || null,
+      fanIn: r.fan_in,
+      cognitive: r.cognitive,
+      churn: r.churn,
+      maintainabilityIndex: r.mi,
+      normFanIn: riskMetrics[i].normFanIn,
+      normComplexity: riskMetrics[i].normComplexity,
+      normChurn: riskMetrics[i].normChurn,
+      normMI: riskMetrics[i].normMI,
+      roleWeight: riskMetrics[i].roleWeight,
+      riskScore: riskMetrics[i].riskScore,
+    }));
 
     // Apply minScore filter
     const scored = minScore != null ? items.filter((it) => it.riskScore >= minScore) : items;
@@ -167,7 +115,7 @@ export function triageData(customDbPath, opts = {}) {
       offset: opts.offset,
     });
   } finally {
-    db.close();
+    close();
   }
 }
 

package/src/graph/algorithms/bfs.js

@@ -0,0 +1,49 @@
+/**
+ * Breadth-first traversal on a CodeGraph.
+ *
+ * @param {import('../model.js').CodeGraph} graph
+ * @param {string|string[]} startIds - One or more starting node IDs
+ * @param {{ maxDepth?: number, direction?: 'forward'|'backward'|'both' }} [opts]
+ * @returns {Map<string, number>} nodeId → depth from nearest start node
+ */
+export function bfs(graph, startIds, opts = {}) {
+  const maxDepth = opts.maxDepth ?? Infinity;
+  const direction = opts.direction ?? 'forward';
+  const starts = Array.isArray(startIds) ? startIds : [startIds];
+
+  const depths = new Map();
+  const queue = [];
+
+  for (const id of starts) {
+    const key = String(id);
+    if (graph.hasNode(key)) {
+      depths.set(key, 0);
+      queue.push(key);
+    }
+  }
+
+  let head = 0;
+  while (head < queue.length) {
+    const current = queue[head++];
+    const depth = depths.get(current);
+    if (depth >= maxDepth) continue;
+
+    let neighbors;
+    if (direction === 'forward') {
+      neighbors = graph.successors(current);
+    } else if (direction === 'backward') {
+      neighbors = graph.predecessors(current);
+    } else {
+      neighbors = graph.neighbors(current);
+    }
+
+    for (const n of neighbors) {
+      if (!depths.has(n)) {
+        depths.set(n, depth + 1);
+        queue.push(n);
+      }
+    }
+  }
+
+  return depths;
+}

package/src/graph/algorithms/centrality.js

@@ -0,0 +1,16 @@
+/**
+ * Fan-in / fan-out centrality for all nodes in a CodeGraph.
+ *
+ * @param {import('../model.js').CodeGraph} graph
+ * @returns {Map<string, { fanIn: number, fanOut: number }>}
+ */
+export function fanInOut(graph) {
+  const result = new Map();
+  for (const id of graph.nodeIds()) {
+    result.set(id, {
+      fanIn: graph.inDegree(id),
+      fanOut: graph.outDegree(id),
+    });
+  }
+  return result;
+}

package/src/graph/algorithms/index.js

@@ -0,0 +1,5 @@
+export { bfs } from './bfs.js';
+export { fanInOut } from './centrality.js';
+export { louvainCommunities } from './louvain.js';
+export { shortestPath } from './shortest-path.js';
+export { tarjan } from './tarjan.js';

package/src/graph/algorithms/louvain.js

@@ -0,0 +1,26 @@
+/**
+ * Louvain community detection via graphology.
+ *
+ * @param {import('../model.js').CodeGraph} graph
+ * @param {{ resolution?: number }} [opts]
+ * @returns {{ assignments: Map<string, number>, modularity: number }}
+ */
+import graphologyLouvain from 'graphology-communities-louvain';
+
+export function louvainCommunities(graph, opts = {}) {
+  const gy = graph.toGraphology({ type: 'undirected' });
+
+  if (gy.order === 0 || gy.size === 0) {
+    return { assignments: new Map(), modularity: 0 };
+  }
+
+  const resolution = opts.resolution ?? 1.0;
+  const details = graphologyLouvain.detailed(gy, { resolution });
+
+  const assignments = new Map();
+  for (const [nodeId, communityId] of Object.entries(details.communities)) {
+    assignments.set(nodeId, communityId);
+  }
+
+  return { assignments, modularity: details.modularity };
+}

package/src/graph/algorithms/shortest-path.js

@@ -0,0 +1,41 @@
+/**
+ * BFS-based shortest path on a CodeGraph.
+ *
+ * @param {import('../model.js').CodeGraph} graph
+ * @param {string} fromId
+ * @param {string} toId
+ * @returns {string[]|null} Path from fromId to toId (inclusive), or null if unreachable
+ */
+export function shortestPath(graph, fromId, toId) {
+  const from = String(fromId);
+  const to = String(toId);
+
+  if (!graph.hasNode(from) || !graph.hasNode(to)) return null;
+  if (from === to) return [from];
+
+  const parent = new Map();
+  parent.set(from, null);
+  const queue = [from];
+  let head = 0;
+
+  while (head < queue.length) {
+    const current = queue[head++];
+    for (const neighbor of graph.successors(current)) {
+      if (parent.has(neighbor)) continue;
+      parent.set(neighbor, current);
+      if (neighbor === to) {
+        // Reconstruct path
+        const path = [];
+        let node = to;
+        while (node !== null) {
+          path.push(node);
+          node = parent.get(node);
+        }
+        return path.reverse();
+      }
+      queue.push(neighbor);
+    }
+  }
+
+  return null;
+}

package/src/graph/algorithms/tarjan.js

@@ -0,0 +1,49 @@
+/**
+ * Tarjan's strongly connected components algorithm.
+ * Operates on a CodeGraph instance.
+ *
+ * @param {import('../model.js').CodeGraph} graph
+ * @returns {string[][]} SCCs with length > 1 (cycles)
+ */
+export function tarjan(graph) {
+  let index = 0;
+  const stack = [];
+  const onStack = new Set();
+  const indices = new Map();
+  const lowlinks = new Map();
+  const sccs = [];
+
+  function strongconnect(v) {
+    indices.set(v, index);
+    lowlinks.set(v, index);
+    index++;
+    stack.push(v);
+    onStack.add(v);
+
+    for (const w of graph.successors(v)) {
+      if (!indices.has(w)) {
+        strongconnect(w);
+        lowlinks.set(v, Math.min(lowlinks.get(v), lowlinks.get(w)));
+      } else if (onStack.has(w)) {
+        lowlinks.set(v, Math.min(lowlinks.get(v), indices.get(w)));
+      }
+    }
+
+    if (lowlinks.get(v) === indices.get(v)) {
+      const scc = [];
+      let w;
+      do {
+        w = stack.pop();
+        onStack.delete(w);
+        scc.push(w);
+      } while (w !== v);
+      if (scc.length > 1) sccs.push(scc);
+    }
+  }
+
+  for (const id of graph.nodeIds()) {
+    if (!indices.has(id)) strongconnect(id);
+  }
+
+  return sccs;
+}

package/src/graph/builders/dependency.js

@@ -0,0 +1,110 @@
+/**
+ * Build a CodeGraph from the SQLite database.
+ * Replaces inline graph construction in cycles.js, communities.js, viewer.js, export.js.
+ */
+
+import {
+  getCallableNodes,
+  getCallEdges,
+  getFileNodesAll,
+  getImportEdges,
+  Repository,
+} from '../../db/index.js';
+import { isTestFile } from '../../infrastructure/test-filter.js';
+import { CodeGraph } from '../model.js';
+
+/**
+ * @param {object} dbOrRepo - Open better-sqlite3 database (readonly) or a Repository instance
+ * @param {object} [opts]
+ * @param {boolean} [opts.fileLevel=true] - File-level (imports) or function-level (calls)
+ * @param {boolean} [opts.noTests=false] - Exclude test files
+ * @param {number}  [opts.minConfidence] - Minimum edge confidence (function-level only)
+ * @returns {CodeGraph}
+ */
+export function buildDependencyGraph(dbOrRepo, opts = {}) {
+  const fileLevel = opts.fileLevel !== false;
+  const noTests = opts.noTests || false;
+
+  if (fileLevel) {
+    return buildFileLevelGraph(dbOrRepo, noTests);
+  }
+  return buildFunctionLevelGraph(dbOrRepo, noTests, opts.minConfidence);
+}
+
+function buildFileLevelGraph(dbOrRepo, noTests) {
+  const graph = new CodeGraph();
+  const isRepo = dbOrRepo instanceof Repository;
+
+  let nodes = isRepo ? dbOrRepo.getFileNodesAll() : getFileNodesAll(dbOrRepo);
+  if (noTests) nodes = nodes.filter((n) => !isTestFile(n.file));
+
+  const nodeIds = new Set();
+  for (const n of nodes) {
+    graph.addNode(String(n.id), { label: n.file, file: n.file, dbId: n.id });
+    nodeIds.add(n.id);
+  }
+
+  const edges = isRepo ? dbOrRepo.getImportEdges() : getImportEdges(dbOrRepo);
+  for (const e of edges) {
+    if (!nodeIds.has(e.source_id) || !nodeIds.has(e.target_id)) continue;
+    const src = String(e.source_id);
+    const tgt = String(e.target_id);
+    if (src === tgt) continue;
+    if (!graph.hasEdge(src, tgt)) {
+      graph.addEdge(src, tgt, { kind: 'imports' });
+    }
+  }
+
+  return graph;
+}
+
+function buildFunctionLevelGraph(dbOrRepo, noTests, minConfidence) {
+  const graph = new CodeGraph();
+  const isRepo = dbOrRepo instanceof Repository;
+
+  let nodes = isRepo ? dbOrRepo.getCallableNodes() : getCallableNodes(dbOrRepo);
+  if (noTests) nodes = nodes.filter((n) => !isTestFile(n.file));
+
+  const nodeIds = new Set();
+  for (const n of nodes) {
+    graph.addNode(String(n.id), {
+      label: n.name,
+      file: n.file,
+      kind: n.kind,
+      dbId: n.id,
+    });
+    nodeIds.add(n.id);
+  }
+
+  let edges;
+  if (minConfidence != null) {
+    if (isRepo) {
+      // Trade-off: Repository.getCallEdges() returns all call edges, so we
+      // filter in JS. This is O(all call edges) rather than the SQL path's
+      // indexed WHERE clause. Acceptable for current data sizes; a dedicated
+      // getCallEdgesByMinConfidence(threshold) method on the Repository
+      // interface would be the proper fix if this becomes a bottleneck.
+      edges = dbOrRepo
+        .getCallEdges()
+        .filter((e) => e.confidence != null && e.confidence >= minConfidence);
+    } else {
+      edges = dbOrRepo
+        .prepare("SELECT source_id, target_id FROM edges WHERE kind = 'calls' AND confidence >= ?")
+        .all(minConfidence);
+    }
+  } else {
+    edges = isRepo ? dbOrRepo.getCallEdges() : getCallEdges(dbOrRepo);
+  }
+
+  for (const e of edges) {
+    if (!nodeIds.has(e.source_id) || !nodeIds.has(e.target_id)) continue;
+    const src = String(e.source_id);
+    const tgt = String(e.target_id);
+    if (src === tgt) continue;
+    if (!graph.hasEdge(src, tgt)) {
+      graph.addEdge(src, tgt, { kind: 'calls' });
+    }
+  }
+
+  return graph;
+}

package/src/graph/builders/index.js

@@ -0,0 +1,3 @@
+export { buildDependencyGraph } from './dependency.js';
+export { buildStructureGraph } from './structure.js';
+export { buildTemporalGraph } from './temporal.js';

package/src/graph/builders/structure.js

@@ -0,0 +1,40 @@
+/**
+ * Build a containment graph (directory → file) from the SQLite database.
+ */
+
+import { CodeGraph } from '../model.js';
+
+/**
+ * @param {object} db - Open better-sqlite3 database (readonly)
+ * @returns {CodeGraph} Directed graph with directory→file containment edges
+ */
+export function buildStructureGraph(db) {
+  const graph = new CodeGraph();
+
+  const dirs = db.prepare("SELECT id, name FROM nodes WHERE kind = 'directory'").all();
+
+  for (const d of dirs) {
+    graph.addNode(String(d.id), { label: d.name, kind: 'directory' });
+  }
+
+  const files = db.prepare("SELECT id, name, file FROM nodes WHERE kind = 'file'").all();
+
+  for (const f of files) {
+    graph.addNode(String(f.id), { label: f.name, kind: 'file', file: f.file });
+  }
+
+  const containsEdges = db
+    .prepare(`
+      SELECT e.source_id, e.target_id
+      FROM edges e
+      JOIN nodes n ON e.source_id = n.id
+      WHERE e.kind = 'contains' AND n.kind = 'directory'
+    `)
+    .all();
+
+  for (const e of containsEdges) {
+    graph.addEdge(String(e.source_id), String(e.target_id), { kind: 'contains' });
+  }
+
+  return graph;
+}

package/src/graph/builders/temporal.js

@@ -0,0 +1,33 @@
+/**
+ * Build a co-change (temporal) graph weighted by Jaccard similarity.
+ */
+
+import { CodeGraph } from '../model.js';
+
+/**
+ * @param {object} db - Open better-sqlite3 database (readonly)
+ * @param {{ minJaccard?: number }} [opts]
+ * @returns {CodeGraph} Undirected graph weighted by Jaccard similarity
+ */
+export function buildTemporalGraph(db, opts = {}) {
+  const minJaccard = opts.minJaccard ?? 0.0;
+  const graph = new CodeGraph({ directed: false });
+
+  // Check if co_changes table exists
+  const tableCheck = db
+    .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='co_changes'")
+    .get();
+  if (!tableCheck) return graph;
+
+  const rows = db
+    .prepare('SELECT file_a, file_b, jaccard FROM co_changes WHERE jaccard >= ?')
+    .all(minJaccard);
+
+  for (const r of rows) {
+    if (!graph.hasNode(r.file_a)) graph.addNode(r.file_a, { label: r.file_a });
+    if (!graph.hasNode(r.file_b)) graph.addNode(r.file_b, { label: r.file_b });
+    graph.addEdge(r.file_a, r.file_b, { jaccard: r.jaccard });
+  }
+
+  return graph;
+}

package/src/graph/classifiers/index.js

@@ -0,0 +1,2 @@
+export { DEFAULT_WEIGHTS, minMaxNormalize, ROLE_WEIGHTS, scoreRisk } from './risk.js';
+export { classifyRoles, FRAMEWORK_ENTRY_PREFIXES } from './roles.js';

package/src/graph/classifiers/risk.js

@@ -0,0 +1,85 @@
+/**
+ * Risk scoring — pure logic, no DB.
+ */
+
+// Weights sum to 1.0. Complexity gets the highest weight because cognitive load
+// is the strongest predictor of defect density. Fan-in and churn are next as
+// they reflect coupling and volatility. Role adds architectural context, and MI
+// (maintainability index) is a weaker composite signal, so it gets the least.
+export const DEFAULT_WEIGHTS = {
+  fanIn: 0.25,
+  complexity: 0.3,
+  churn: 0.2,
+  role: 0.15,
+  mi: 0.1,
+};
+
+// Role weights reflect structural importance: core modules are central to the
+// dependency graph, utilities are widely imported, entry points are API
+// surfaces. Adapters bridge subsystems but are replaceable. Leaves and dead
+// code have minimal downstream impact.
+export const ROLE_WEIGHTS = {
+  core: 1.0,
+  utility: 0.9,
+  entry: 0.8,
+  adapter: 0.5,
+  leaf: 0.2,
+  dead: 0.1,
+};
+
+const DEFAULT_ROLE_WEIGHT = 0.5;
+
+/** Min-max normalize an array of numbers. All-equal → all zeros. */
+export function minMaxNormalize(values) {
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  if (max === min) return values.map(() => 0);
+  const range = max - min;
+  return values.map((v) => (v - min) / range);
+}
+
+function round4(n) {
+  return Math.round(n * 10000) / 10000;
+}
+
+/**
+ * Score risk for a list of items.
+ *
+ * @param {{ fan_in: number, cognitive: number, churn: number, mi: number, role: string|null }[]} items
+ * @param {object} [weights] - Override DEFAULT_WEIGHTS
+ * @returns {{ normFanIn: number, normComplexity: number, normChurn: number, normMI: number, roleWeight: number, riskScore: number }[]}
+ *   Parallel array with risk metrics for each input item.
+ */
+export function scoreRisk(items, weights = {}) {
+  const w = { ...DEFAULT_WEIGHTS, ...weights };
+
+  const fanIns = items.map((r) => r.fan_in);
+  const cognitives = items.map((r) => r.cognitive);
+  const churns = items.map((r) => r.churn);
+  const mis = items.map((r) => r.mi);
+
+  const normFanIns = minMaxNormalize(fanIns);
+  const normCognitives = minMaxNormalize(cognitives);
+  const normChurns = minMaxNormalize(churns);
+  const normMIsRaw = minMaxNormalize(mis);
+  const normMIs = normMIsRaw.map((v) => round4(1 - v));
+
+  return items.map((r, i) => {
+    const roleWeight = ROLE_WEIGHTS[r.role] ?? DEFAULT_ROLE_WEIGHT;
+    const riskScore =
+      w.fanIn * normFanIns[i] +
+      w.complexity * normCognitives[i] +
+      w.churn * normChurns[i] +
+      w.role * roleWeight +
+      w.mi * normMIs[i];
+
+    return {
+      normFanIn: round4(normFanIns[i]),
+      normComplexity: round4(normCognitives[i]),
+      normChurn: round4(normChurns[i]),
+      normMI: round4(normMIs[i]),
+      roleWeight,
+      riskScore: round4(riskScore),
+    };
+  });
+}

package/src/graph/classifiers/roles.js

@@ -0,0 +1,64 @@
+/**
+ * Node role classification — pure logic, no DB.
+ *
+ * Roles: entry, core, utility, adapter, leaf, dead
+ */
+
+export const FRAMEWORK_ENTRY_PREFIXES = ['route:', 'event:', 'command:'];
+
+function median(sorted) {
+  if (sorted.length === 0) return 0;
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+
+/**
+ * Classify nodes into architectural roles based on fan-in/fan-out metrics.
+ *
+ * @param {{ id: string, name: string, fanIn: number, fanOut: number, isExported: boolean }[]} nodes
+ * @returns {Map<string, string>} nodeId → role
+ */
+export function classifyRoles(nodes) {
+  if (nodes.length === 0) return new Map();
+
+  const nonZeroFanIn = nodes
+    .filter((n) => n.fanIn > 0)
+    .map((n) => n.fanIn)
+    .sort((a, b) => a - b);
+  const nonZeroFanOut = nodes
+    .filter((n) => n.fanOut > 0)
+    .map((n) => n.fanOut)
+    .sort((a, b) => a - b);
+
+  const medFanIn = median(nonZeroFanIn);
+  const medFanOut = median(nonZeroFanOut);
+
+  const result = new Map();
+
+  for (const node of nodes) {
+    const highIn = node.fanIn >= medFanIn && node.fanIn > 0;
+    const highOut = node.fanOut >= medFanOut && node.fanOut > 0;
+
+    let role;
+    const isFrameworkEntry = FRAMEWORK_ENTRY_PREFIXES.some((p) => node.name.startsWith(p));
+    if (isFrameworkEntry) {
+      role = 'entry';
+    } else if (node.fanIn === 0 && !node.isExported) {
+      role = 'dead';
+    } else if (node.fanIn === 0 && node.isExported) {
+      role = 'entry';
+    } else if (highIn && !highOut) {
+      role = 'core';
+    } else if (highIn && highOut) {
+      role = 'utility';
+    } else if (!highIn && highOut) {
+      role = 'adapter';
+    } else {
+      role = 'leaf';
+    }
+
+    result.set(node.id, role);
+  }
+
+  return result;
+}

package/src/graph/index.js

@@ -0,0 +1,13 @@
+// Graph subsystem barrel export
+
+export { bfs, fanInOut, louvainCommunities, shortestPath, tarjan } from './algorithms/index.js';
+export { buildDependencyGraph, buildStructureGraph, buildTemporalGraph } from './builders/index.js';
+export {
+  classifyRoles,
+  DEFAULT_WEIGHTS,
+  FRAMEWORK_ENTRY_PREFIXES,
+  minMaxNormalize,
+  ROLE_WEIGHTS,
+  scoreRisk,
+} from './classifiers/index.js';
+export { CodeGraph } from './model.js';