@optave/codegraph 3.1.0 → 3.1.2

package/src/triage.js

@@ -1,7 +1,7 @@
-import { openReadonlyOrFail } from './db.js';
+import { findNodesForTriage, openReadonlyOrFail } from './db.js';
+import { isTestFile } from './infrastructure/test-filter.js';
 import { warn } from './logger.js';
-import { paginateResult, printNdjson } from './paginate.js';
-import { isTestFile } from './queries.js';
+import { paginateResult } from './paginate.js';
 
 // ─── Constants ────────────────────────────────────────────────────────
 
@@ -46,224 +46,129 @@ function minMaxNormalize(values) {
  */
 export function triageData(customDbPath, opts = {}) {
   const db = openReadonlyOrFail(customDbPath);
-  const noTests = opts.noTests || false;
-  const fileFilter = opts.file || null;
-  const kindFilter = opts.kind || null;
-  const roleFilter = opts.role || null;
-  const minScore = opts.minScore != null ? Number(opts.minScore) : null;
-  const sort = opts.sort || 'risk';
-  const weights = { ...DEFAULT_WEIGHTS, ...(opts.weights || {}) };
+  try {
+    const noTests = opts.noTests || false;
+    const fileFilter = opts.file || null;
+    const kindFilter = opts.kind || null;
+    const roleFilter = opts.role || null;
+    const minScore = opts.minScore != null ? Number(opts.minScore) : null;
+    const sort = opts.sort || 'risk';
+    const weights = { ...DEFAULT_WEIGHTS, ...(opts.weights || {}) };
+
+    let rows;
+    try {
+      rows = findNodesForTriage(db, {
+        noTests,
+        file: fileFilter,
+        kind: kindFilter,
+        role: roleFilter,
+      });
+    } catch (err) {
+      warn(`triage query failed: ${err.message}`);
+      return {
+        items: [],
+        summary: { total: 0, analyzed: 0, avgScore: 0, maxScore: 0, weights, signalCoverage: {} },
+      };
+    }
 
-  // Build WHERE clause
-  let where = "WHERE n.kind IN ('function','method','class')";
-  const params = [];
+    // Post-filter test files (belt-and-suspenders)
+    const filtered = noTests ? rows.filter((r) => !isTestFile(r.file)) : rows;
 
-  if (noTests) {
-    where += ` AND n.file NOT LIKE '%.test.%'
-       AND n.file NOT LIKE '%.spec.%'
-       AND n.file NOT LIKE '%__test__%'
-       AND n.file NOT LIKE '%__tests__%'
-       AND n.file NOT LIKE '%.stories.%'`;
-  }
-  if (fileFilter) {
-    where += ' AND n.file LIKE ?';
-    params.push(`%${fileFilter}%`);
-  }
-  if (kindFilter) {
-    where += ' AND n.kind = ?';
-    params.push(kindFilter);
-  }
-  if (roleFilter) {
-    where += ' AND n.role = ?';
-    params.push(roleFilter);
-  }
+    if (filtered.length === 0) {
+      return {
+        items: [],
+        summary: { total: 0, analyzed: 0, avgScore: 0, maxScore: 0, weights, signalCoverage: {} },
+      };
+    }
 
-  let rows;
-  try {
-    rows = db
-      .prepare(
-        `SELECT n.id, n.name, n.kind, n.file, n.line, n.end_line, n.role,
-              COALESCE(fi.cnt, 0) AS fan_in,
-              COALESCE(fc.cognitive, 0) AS cognitive,
-              COALESCE(fc.maintainability_index, 0) AS mi,
-              COALESCE(fc.cyclomatic, 0) AS cyclomatic,
-              COALESCE(fc.max_nesting, 0) AS max_nesting,
-              COALESCE(fcc.commit_count, 0) AS churn
-       FROM nodes n
-       LEFT JOIN (SELECT target_id, COUNT(*) AS cnt FROM edges WHERE kind='calls' GROUP BY target_id) fi
-         ON n.id = fi.target_id
-       LEFT JOIN function_complexity fc ON fc.node_id = n.id
-       LEFT JOIN file_commit_counts fcc ON n.file = fcc.file
-       ${where}
-       ORDER BY n.file, n.line`,
-      )
-      .all(...params);
-  } catch (err) {
-    warn(`triage query failed: ${err.message}`);
-    db.close();
-    return {
-      items: [],
-      summary: { total: 0, analyzed: 0, avgScore: 0, maxScore: 0, weights, signalCoverage: {} },
+    // 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));
+
+    // 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),
+      };
+    });
+
+    // Apply minScore filter
+    const scored = minScore != null ? items.filter((it) => it.riskScore >= minScore) : items;
+
+    // Sort
+    const sortFns = {
+      risk: (a, b) => b.riskScore - a.riskScore,
+      complexity: (a, b) => b.cognitive - a.cognitive,
+      churn: (a, b) => b.churn - a.churn,
+      'fan-in': (a, b) => b.fanIn - a.fanIn,
+      mi: (a, b) => a.maintainabilityIndex - b.maintainabilityIndex,
     };
-  }
-
-  // Post-filter test files (belt-and-suspenders)
-  const filtered = noTests ? rows.filter((r) => !isTestFile(r.file)) : rows;
-
-  if (filtered.length === 0) {
-    db.close();
-    return {
-      items: [],
-      summary: { total: 0, analyzed: 0, avgScore: 0, maxScore: 0, weights, signalCoverage: {} },
+    scored.sort(sortFns[sort] || sortFns.risk);
+
+    // Signal coverage: % of items with non-zero signal
+    const signalCoverage = {
+      complexity: round4(filtered.filter((r) => r.cognitive > 0).length / filtered.length),
+      churn: round4(filtered.filter((r) => r.churn > 0).length / filtered.length),
+      fanIn: round4(filtered.filter((r) => r.fan_in > 0).length / filtered.length),
+      mi: round4(filtered.filter((r) => r.mi > 0).length / filtered.length),
     };
-  }
-
-  // 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));
 
-  // 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 scores = scored.map((it) => it.riskScore);
+    const avgScore =
+      scores.length > 0 ? round4(scores.reduce((a, b) => a + b, 0) / scores.length) : 0;
+    const maxScore = scores.length > 0 ? round4(Math.max(...scores)) : 0;
+
+    const result = {
+      items: scored,
+      summary: {
+        total: filtered.length,
+        analyzed: scored.length,
+        avgScore,
+        maxScore,
+        weights,
+        signalCoverage,
+      },
     };
-  });
-
-  // Apply minScore filter
-  const scored = minScore != null ? items.filter((it) => it.riskScore >= minScore) : items;
-
-  // Sort
-  const sortFns = {
-    risk: (a, b) => b.riskScore - a.riskScore,
-    complexity: (a, b) => b.cognitive - a.cognitive,
-    churn: (a, b) => b.churn - a.churn,
-    'fan-in': (a, b) => b.fanIn - a.fanIn,
-    mi: (a, b) => a.maintainabilityIndex - b.maintainabilityIndex,
-  };
-  scored.sort(sortFns[sort] || sortFns.risk);
-
-  // Signal coverage: % of items with non-zero signal
-  const signalCoverage = {
-    complexity: round4(filtered.filter((r) => r.cognitive > 0).length / filtered.length),
-    churn: round4(filtered.filter((r) => r.churn > 0).length / filtered.length),
-    fanIn: round4(filtered.filter((r) => r.fan_in > 0).length / filtered.length),
-    mi: round4(filtered.filter((r) => r.mi > 0).length / filtered.length),
-  };
-
-  const scores = scored.map((it) => it.riskScore);
-  const avgScore =
-    scores.length > 0 ? round4(scores.reduce((a, b) => a + b, 0) / scores.length) : 0;
-  const maxScore = scores.length > 0 ? round4(Math.max(...scores)) : 0;
 
-  const result = {
-    items: scored,
-    summary: {
-      total: filtered.length,
-      analyzed: scored.length,
-      avgScore,
-      maxScore,
-      weights,
-      signalCoverage,
-    },
-  };
-
-  db.close();
-
-  return paginateResult(result, 'items', {
-    limit: opts.limit,
-    offset: opts.offset,
-  });
-}
-
-// ─── CLI Formatter ────────────────────────────────────────────────────
-
-/**
- * Print triage results to console.
- *
- * @param {string} [customDbPath]
- * @param {object} [opts]
- */
-export function triage(customDbPath, opts = {}) {
-  const data = triageData(customDbPath, opts);
-
-  if (opts.ndjson) {
-    printNdjson(data, 'items');
-    return;
-  }
-  if (opts.json) {
-    console.log(JSON.stringify(data, null, 2));
-    return;
-  }
-
-  if (data.items.length === 0) {
-    if (data.summary.total === 0) {
-      console.log('\nNo symbols found. Run "codegraph build" first.\n');
-    } else {
-      console.log('\nNo symbols match the given filters.\n');
-    }
-    return;
-  }
-
-  console.log('\n# Risk Audit Queue\n');
-
-  console.log(
-    `  ${'Symbol'.padEnd(35)} ${'File'.padEnd(28)} ${'Role'.padEnd(8)} ${'Score'.padStart(6)} ${'Fan-In'.padStart(7)} ${'Cog'.padStart(4)} ${'Churn'.padStart(6)} ${'MI'.padStart(5)}`,
-  );
-  console.log(
-    `  ${'─'.repeat(35)} ${'─'.repeat(28)} ${'─'.repeat(8)} ${'─'.repeat(6)} ${'─'.repeat(7)} ${'─'.repeat(4)} ${'─'.repeat(6)} ${'─'.repeat(5)}`,
-  );
-
-  for (const it of data.items) {
-    const name = it.name.length > 33 ? `${it.name.slice(0, 32)}…` : it.name;
-    const file = it.file.length > 26 ? `…${it.file.slice(-25)}` : it.file;
-    const role = (it.role || '-').padEnd(8);
-    const score = it.riskScore.toFixed(2).padStart(6);
-    const fanIn = String(it.fanIn).padStart(7);
-    const cog = String(it.cognitive).padStart(4);
-    const churn = String(it.churn).padStart(6);
-    const mi = it.maintainabilityIndex > 0 ? String(it.maintainabilityIndex).padStart(5) : '    -';
-    console.log(
-      `  ${name.padEnd(35)} ${file.padEnd(28)} ${role} ${score} ${fanIn} ${cog} ${churn} ${mi}`,
-    );
+    return paginateResult(result, 'items', {
+      limit: opts.limit,
+      offset: opts.offset,
+    });
+  } finally {
+    db.close();
   }
-
-  const s = data.summary;
-  console.log(
-    `\n  ${s.analyzed} symbols scored (of ${s.total} total) | avg: ${s.avgScore.toFixed(2)} | max: ${s.maxScore.toFixed(2)} | sort: ${opts.sort || 'risk'}`,
-  );
-  console.log();
 }
 
 // ─── Utilities ────────────────────────────────────────────────────────

package/src/viewer.js

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import Graph from 'graphology';
 import louvain from 'graphology-communities-louvain';
-import { isTestFile } from './queries.js';
+import { isTestFile } from './infrastructure/test-filter.js';
 
 const DEFAULT_MIN_CONFIDENCE = 0.5;
 

package/src/watcher.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { readFileSafe } from './builder.js';
 import { appendChangeEvents, buildChangeEvent, diffSymbols } from './change-journal.js';
 import { EXTENSIONS, IGNORE_DIRS, normalizePath } from './constants.js';
-import { closeDb, initSchema, openDb } from './db.js';
+import { closeDb, getNodeId as getNodeIdQuery, initSchema, openDb } from './db.js';
 import { appendJournalEntries } from './journal.js';
 import { info, warn } from './logger.js';
 import { createParseTreeCache, getActiveEngine, parseFileIncremental } from './parser.js';
@@ -185,9 +185,12 @@ export async function watchProject(rootDir, opts = {}) {
     insertNode: db.prepare(
       'INSERT OR IGNORE INTO nodes (name, kind, file, line, end_line) VALUES (?, ?, ?, ?, ?)',
     ),
-    getNodeId: db.prepare(
-      'SELECT id FROM nodes WHERE name = ? AND kind = ? AND file = ? AND line = ?',
-    ),
+    getNodeId: {
+      get: (name, kind, file, line) => {
+        const id = getNodeIdQuery(db, name, kind, file, line);
+        return id != null ? { id } : undefined;
+      },
+    },
     insertEdge: db.prepare(
       'INSERT INTO edges (source_id, target_id, kind, confidence, dynamic) VALUES (?, ?, ?, ?, ?)',
     ),