@optave/codegraph 3.0.4 → 3.1.1

package/src/triage.js

@@ -1,7 +1,8 @@
-import { openReadonlyOrFail } from './db.js';
+import { findNodesForTriage, openReadonlyOrFail } from './db.js';
 import { warn } from './logger.js';
-import { paginateResult, printNdjson } from './paginate.js';
-import { isTestFile } from './queries.js';
+import { paginateResult } from './paginate.js';
+import { outputResult } from './result-formatter.js';
+import { isTestFile } from './test-filter.js';
 
 // ─── Constants ────────────────────────────────────────────────────────
 
@@ -46,165 +47,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,
-  });
+    return paginateResult(result, 'items', {
+      limit: opts.limit,
+      offset: opts.offset,
+    });
+  } finally {
+    db.close();
+  }
 }
 
 // ─── CLI Formatter ────────────────────────────────────────────────────
@@ -218,14 +183,7 @@ export function triageData(customDbPath, 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 (outputResult(data, 'items', opts)) return;
 
   if (data.items.length === 0) {
     if (data.summary.total === 0) {

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 './test-filter.js';
 
 const DEFAULT_MIN_CONFIDENCE = 0.5;