@optave/codegraph 2.3.1-dev.1aeea34 → 2.5.0

package/src/config.js

@@ -24,6 +24,20 @@ export const DEFAULTS = {
   llm: { provider: null, model: null, baseUrl: null, apiKey: null, apiKeyCommand: null },
   search: { defaultMinScore: 0.2, rrfK: 60, topK: 15 },
   ci: { failOnCycles: false, impactThreshold: null },
+  manifesto: {
+    rules: {
+      cognitive: { warn: 15 },
+      cyclomatic: { warn: 10 },
+      maxNesting: { warn: 4 },
+      maintainabilityIndex: { warn: 20, fail: null },
+      importCount: { warn: null, fail: null },
+      exportCount: { warn: null, fail: null },
+      lineCount: { warn: null, fail: null },
+      fanIn: { warn: null, fail: null },
+      fanOut: { warn: null, fail: null },
+      noCycles: { warn: null, fail: null },
+    },
+  },
   coChange: {
     since: '1 year ago',
     minSupport: 3,
@@ -45,7 +59,12 @@ export function loadConfig(cwd) {
         const raw = fs.readFileSync(filePath, 'utf-8');
         const config = JSON.parse(raw);
         debug(`Loaded config from ${filePath}`);
-        return resolveSecrets(applyEnvOverrides(mergeConfig(DEFAULTS, config)));
+        const merged = mergeConfig(DEFAULTS, config);
+        if ('excludeTests' in config && !(config.query && 'excludeTests' in config.query)) {
+          merged.query.excludeTests = Boolean(config.excludeTests);
+        }
+        delete merged.excludeTests;
+        return resolveSecrets(applyEnvOverrides(merged));
       } catch (err) {
         debug(`Failed to parse config ${filePath}: ${err.message}`);
       }

package/src/db.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import Database from 'better-sqlite3';
-import { debug } from './logger.js';
+import { debug, warn } from './logger.js';
 
 // ─── Schema Migrations ─────────────────────────────────────────────────
 export const MIGRATIONS = [
@@ -101,16 +101,126 @@ export const MIGRATIONS = [
       );
     `,
   },
+  {
+    version: 7,
+    up: `
+      CREATE TABLE IF NOT EXISTS build_meta (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+    `,
+  },
+  {
+    version: 8,
+    up: `
+      CREATE TABLE IF NOT EXISTS function_complexity (
+        node_id INTEGER PRIMARY KEY,
+        cognitive INTEGER NOT NULL,
+        cyclomatic INTEGER NOT NULL,
+        max_nesting INTEGER NOT NULL,
+        FOREIGN KEY(node_id) REFERENCES nodes(id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_fc_cognitive ON function_complexity(cognitive DESC);
+      CREATE INDEX IF NOT EXISTS idx_fc_cyclomatic ON function_complexity(cyclomatic DESC);
+    `,
+  },
+  {
+    version: 9,
+    up: `
+      ALTER TABLE function_complexity ADD COLUMN loc INTEGER DEFAULT 0;
+      ALTER TABLE function_complexity ADD COLUMN sloc INTEGER DEFAULT 0;
+      ALTER TABLE function_complexity ADD COLUMN comment_lines INTEGER DEFAULT 0;
+      ALTER TABLE function_complexity ADD COLUMN halstead_n1 INTEGER DEFAULT 0;
+      ALTER TABLE function_complexity ADD COLUMN halstead_n2 INTEGER DEFAULT 0;
+      ALTER TABLE function_complexity ADD COLUMN halstead_big_n1 INTEGER DEFAULT 0;
+      ALTER TABLE function_complexity ADD COLUMN halstead_big_n2 INTEGER DEFAULT 0;
+      ALTER TABLE function_complexity ADD COLUMN halstead_vocabulary INTEGER DEFAULT 0;
+      ALTER TABLE function_complexity ADD COLUMN halstead_length INTEGER DEFAULT 0;
+      ALTER TABLE function_complexity ADD COLUMN halstead_volume REAL DEFAULT 0;
+      ALTER TABLE function_complexity ADD COLUMN halstead_difficulty REAL DEFAULT 0;
+      ALTER TABLE function_complexity ADD COLUMN halstead_effort REAL DEFAULT 0;
+      ALTER TABLE function_complexity ADD COLUMN halstead_bugs REAL DEFAULT 0;
+      ALTER TABLE function_complexity ADD COLUMN maintainability_index REAL DEFAULT 0;
+      CREATE INDEX IF NOT EXISTS idx_fc_mi ON function_complexity(maintainability_index ASC);
+    `,
+  },
 ];
 
+export function getBuildMeta(db, key) {
+  try {
+    const row = db.prepare('SELECT value FROM build_meta WHERE key = ?').get(key);
+    return row ? row.value : null;
+  } catch {
+    return null;
+  }
+}
+
+export function setBuildMeta(db, entries) {
+  const upsert = db.prepare('INSERT OR REPLACE INTO build_meta (key, value) VALUES (?, ?)');
+  const tx = db.transaction(() => {
+    for (const [key, value] of Object.entries(entries)) {
+      upsert.run(key, String(value));
+    }
+  });
+  tx();
+}
+
 export function openDb(dbPath) {
   const dir = path.dirname(dbPath);
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  acquireAdvisoryLock(dbPath);
   const db = new Database(dbPath);
   db.pragma('journal_mode = WAL');
+  db.pragma('busy_timeout = 5000');
+  db.__lockPath = `${dbPath}.lock`;
   return db;
 }
 
+export function closeDb(db) {
+  db.close();
+  if (db.__lockPath) releaseAdvisoryLock(db.__lockPath);
+}
+
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function acquireAdvisoryLock(dbPath) {
+  const lockPath = `${dbPath}.lock`;
+  try {
+    if (fs.existsSync(lockPath)) {
+      const content = fs.readFileSync(lockPath, 'utf-8').trim();
+      const pid = Number(content);
+      if (pid && pid !== process.pid && isProcessAlive(pid)) {
+        warn(`Another process (PID ${pid}) may be using this database. Proceeding with caution.`);
+      }
+    }
+  } catch {
+    /* ignore read errors */
+  }
+  try {
+    fs.writeFileSync(lockPath, String(process.pid), 'utf-8');
+  } catch {
+    /* best-effort */
+  }
+}
+
+function releaseAdvisoryLock(lockPath) {
+  try {
+    const content = fs.readFileSync(lockPath, 'utf-8').trim();
+    if (Number(content) === process.pid) {
+      fs.unlinkSync(lockPath);
+    }
+  } catch {
+    /* ignore */
+  }
+}
+
 export function initSchema(db) {
   db.exec(`CREATE TABLE IF NOT EXISTS schema_version (version INTEGER NOT NULL DEFAULT 0)`);
 

package/src/embedder.js

@@ -1,8 +1,9 @@
+import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import Database from 'better-sqlite3';
-import { findDbPath, openReadonlyOrFail } from './db.js';
-import { warn } from './logger.js';
+import { createInterface } from 'node:readline';
+import { closeDb, findDbPath, openDb, openReadonlyOrFail } from './db.js';
+import { info, warn } from './logger.js';
 
 /**
  * Split an identifier into readable words.
@@ -133,8 +134,10 @@ export function estimateTokens(text) {
  * Returns the cleaned comment text or null if none found.
  */
 function extractLeadingComment(lines, fnLineIndex) {
+  if (fnLineIndex > lines.length) return null;
   const raw = [];
   for (let i = fnLineIndex - 1; i >= Math.max(0, fnLineIndex - 15); i--) {
+    if (i >= lines.length) continue;
     const trimmed = lines[i].trim();
     if (/^(\/\/|\/\*|\*\/|\*|#|\/\/\/)/.test(trimmed)) {
       raw.unshift(trimmed);
@@ -222,18 +225,52 @@ function buildSourceText(node, file, lines) {
   return `${node.kind} ${node.name} (${readable}) in ${file}\n${context}`;
 }
 
+/**
+ * Prompt the user to install a missing package interactively.
+ * Returns true if the package was installed, false otherwise.
+ * Skips the prompt entirely in non-TTY environments (CI, piped stdin).
+ */
+function promptInstall(packageName) {
+  if (!process.stdin.isTTY) return Promise.resolve(false);
+
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    rl.question(`Semantic search requires ${packageName}. Install it now? [y/N] `, (answer) => {
+      rl.close();
+      if (answer.trim().toLowerCase() !== 'y') return resolve(false);
+      try {
+        execFileSync('npm', ['install', packageName], {
+          stdio: 'inherit',
+          timeout: 300_000,
+        });
+        resolve(true);
+      } catch {
+        resolve(false);
+      }
+    });
+  });
+}
+
 /**
  * Lazy-load @huggingface/transformers.
- * This is an optional dependency — gives a clear error if not installed.
+ * If the package is missing, prompts the user to install it interactively.
+ * In non-TTY environments, prints an error and exits.
  */
 async function loadTransformers() {
   try {
     return await import('@huggingface/transformers');
   } catch {
-    console.error(
-      'Semantic search requires @huggingface/transformers.\n' +
-        'Install it with: npm install @huggingface/transformers',
-    );
+    const pkg = '@huggingface/transformers';
+    const installed = await promptInstall(pkg);
+    if (installed) {
+      try {
+        return await import(pkg);
+      } catch {
+        console.error(`\n${pkg} was installed but failed to load. Please check your environment.`);
+        process.exit(1);
+      }
+    }
+    console.error(`Semantic search requires ${pkg}.\n` + `Install it with: npm install ${pkg}`);
     process.exit(1);
   }
 }
@@ -262,7 +299,7 @@ async function loadModel(modelKey) {
   pipeline = transformers.pipeline;
   _cos_sim = transformers.cos_sim;
 
-  console.log(`Loading embedding model: ${config.name} (${config.dim}d)...`);
+  info(`Loading embedding model: ${config.name} (${config.dim}d)...`);
   const pipelineOpts = config.quantized ? { quantized: true } : {};
   try {
     extractor = await pipeline('feature-extraction', config.name, pipelineOpts);
@@ -285,7 +322,7 @@ async function loadModel(modelKey) {
     process.exit(1);
   }
   activeModel = config.name;
-  console.log('Model loaded.');
+  info('Model loaded.');
   return { extractor, config };
 }
 
@@ -369,7 +406,7 @@ export async function buildEmbeddings(rootDir, modelKey, customDbPath, options =
     process.exit(1);
   }
 
-  const db = new Database(dbPath);
+  const db = openDb(dbPath);
   initEmbeddingsSchema(db);
 
   db.exec('DELETE FROM embeddings');
@@ -474,7 +511,7 @@ export async function buildEmbeddings(rootDir, modelKey, customDbPath, options =
   console.log(
     `\nStored ${vectors.length} embeddings (${dim}d, ${config.name}, strategy: ${strategy}) in graph.db`,
   );
-  db.close();
+  closeDb(db);
 }
 
 /**

package/src/export.js

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { paginateResult } from './paginate.js';
 import { isTestFile } from './queries.js';
 
 const DEFAULT_MIN_CONFIDENCE = 0.5;
@@ -10,6 +11,7 @@ export function exportDOT(db, opts = {}) {
   const fileLevel = opts.fileLevel !== false;
   const noTests = opts.noTests || false;
   const minConf = opts.minConfidence ?? DEFAULT_MIN_CONFIDENCE;
+  const edgeLimit = opts.limit;
   const lines = [
     'digraph codegraph {',
     '  rankdir=LR;',
@@ -30,6 +32,8 @@ export function exportDOT(db, opts = {}) {
     `)
       .all(minConf);
     if (noTests) edges = edges.filter((e) => !isTestFile(e.source) && !isTestFile(e.target));
+    const totalFileEdges = edges.length;
+    if (edgeLimit && edges.length > edgeLimit) edges = edges.slice(0, edgeLimit);
 
     // Try to use directory nodes from DB (built by structure analysis)
     const hasDirectoryNodes =
@@ -95,6 +99,9 @@ export function exportDOT(db, opts = {}) {
     for (const { source, target } of edges) {
       lines.push(`  "${source}" -> "${target}";`);
     }
+    if (edgeLimit && totalFileEdges > edgeLimit) {
+      lines.push(`  // Truncated: showing ${edges.length} of ${totalFileEdges} edges`);
+    }
   } else {
     let edges = db
       .prepare(`
@@ -111,6 +118,8 @@ export function exportDOT(db, opts = {}) {
       .all(minConf);
     if (noTests)
       edges = edges.filter((e) => !isTestFile(e.source_file) && !isTestFile(e.target_file));
+    const totalFnEdges = edges.length;
+    if (edgeLimit && edges.length > edgeLimit) edges = edges.slice(0, edgeLimit);
 
     for (const e of edges) {
       const sId = `${e.source_file}:${e.source_name}`.replace(/[^a-zA-Z0-9_]/g, '_');
@@ -119,6 +128,9 @@ export function exportDOT(db, opts = {}) {
       lines.push(`  ${tId} [label="${e.target_name}\\n${path.basename(e.target_file)}"];`);
       lines.push(`  ${sId} -> ${tId};`);
     }
+    if (edgeLimit && totalFnEdges > edgeLimit) {
+      lines.push(`  // Truncated: showing ${edges.length} of ${totalFnEdges} edges`);
+    }
   }
 
   lines.push('}');
@@ -169,6 +181,7 @@ export function exportMermaid(db, opts = {}) {
   const noTests = opts.noTests || false;
   const minConf = opts.minConfidence ?? DEFAULT_MIN_CONFIDENCE;
   const direction = opts.direction || 'LR';
+  const edgeLimit = opts.limit;
   const lines = [`flowchart ${direction}`];
 
   let nodeCounter = 0;
@@ -190,6 +203,8 @@ export function exportMermaid(db, opts = {}) {
     `)
       .all(minConf);
     if (noTests) edges = edges.filter((e) => !isTestFile(e.source) && !isTestFile(e.target));
+    const totalMermaidFileEdges = edges.length;
+    if (edgeLimit && edges.length > edgeLimit) edges = edges.slice(0, edgeLimit);
 
     // Collect all files referenced in edges
     const allFiles = new Set();
@@ -248,6 +263,9 @@ export function exportMermaid(db, opts = {}) {
     for (const { source, target, labels } of edgeMap.values()) {
       lines.push(`  ${nodeId(source)} -->|${[...labels].join(', ')}| ${nodeId(target)}`);
     }
+    if (edgeLimit && totalMermaidFileEdges > edgeLimit) {
+      lines.push(`  %% Truncated: showing ${edges.length} of ${totalMermaidFileEdges} edges`);
+    }
   } else {
     let edges = db
       .prepare(`
@@ -265,6 +283,8 @@ export function exportMermaid(db, opts = {}) {
       .all(minConf);
     if (noTests)
       edges = edges.filter((e) => !isTestFile(e.source_file) && !isTestFile(e.target_file));
+    const totalMermaidFnEdges = edges.length;
+    if (edgeLimit && edges.length > edgeLimit) edges = edges.slice(0, edgeLimit);
 
     // Group nodes by file for subgraphs
     const fileNodes = new Map();
@@ -301,6 +321,9 @@ export function exportMermaid(db, opts = {}) {
       const tId = nodeId(`${e.target_file}::${e.target_name}`);
       lines.push(`  ${sId} -->|${e.edge_kind}| ${tId}`);
     }
+    if (edgeLimit && totalMermaidFnEdges > edgeLimit) {
+      lines.push(`  %% Truncated: showing ${edges.length} of ${totalMermaidFnEdges} edges`);
+    }
 
     // Role styling — query roles for all referenced nodes
     const allKeys = [...nodeIdMap.keys()];
@@ -348,5 +371,6 @@ export function exportJSON(db, opts = {}) {
     .all(minConf);
   if (noTests) edges = edges.filter((e) => !isTestFile(e.source) && !isTestFile(e.target));
 
-  return { nodes, edges };
+  const base = { nodes, edges };
+  return paginateResult(base, 'edges', { limit: opts.limit, offset: opts.offset });
 }