@optave/codegraph 1.4.1 → 2.1.0

package/src/cli.js

@@ -18,14 +18,25 @@ import {
   impactAnalysis,
   moduleMap,
   queryName,
+  stats,
 } from './queries.js';
+import {
+  listRepos,
+  pruneRegistry,
+  REGISTRY_PATH,
+  registerRepo,
+  unregisterRepo,
+} from './registry.js';
 import { watchProject } from './watcher.js';
 
+const __cliDir = path.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/i, '$1'));
+const pkg = JSON.parse(fs.readFileSync(path.join(__cliDir, '..', 'package.json'), 'utf-8'));
+
 const program = new Command();
 program
   .name('codegraph')
   .description('Local code dependency graph tool')
-  .version('1.3.0')
+  .version(pkg.version)
   .option('-v, --verbose', 'Enable verbose/debug output')
   .option('--engine <engine>', 'Parser engine: native, wasm, or auto (default: auto)', 'auto')
   .hook('preAction', (thisCommand) => {
@@ -71,6 +82,15 @@ program
     moduleMap(opts.db, parseInt(opts.limit, 10), { json: opts.json });
   });
 
+program
+  .command('stats')
+  .description('Show graph health overview: nodes, edges, languages, cycles, hotspots, embeddings')
+  .option('-d, --db <path>', 'Path to graph.db')
+  .option('-j, --json', 'Output as JSON')
+  .action((opts) => {
+    stats(opts.db, { json: opts.json });
+  });
+
 program
   .command('deps <file>')
   .description('Show what this file imports and what imports it')
@@ -186,9 +206,84 @@ program
   .command('mcp')
   .description('Start MCP (Model Context Protocol) server for AI assistant integration')
   .option('-d, --db <path>', 'Path to graph.db')
+  .option('--multi-repo', 'Enable access to all registered repositories')
+  .option('--repos <names>', 'Comma-separated list of allowed repo names (restricts access)')
   .action(async (opts) => {
     const { startMCPServer } = await import('./mcp.js');
-    await startMCPServer(opts.db);
+    const mcpOpts = {};
+    mcpOpts.multiRepo = opts.multiRepo || !!opts.repos;
+    if (opts.repos) {
+      mcpOpts.allowedRepos = opts.repos.split(',').map((s) => s.trim());
+    }
+    await startMCPServer(opts.db, mcpOpts);
+  });
+
+// ─── Registry commands ──────────────────────────────────────────────────
+
+const registry = program.command('registry').description('Manage the multi-repo project registry');
+
+registry
+  .command('list')
+  .description('List all registered repositories')
+  .option('-j, --json', 'Output as JSON')
+  .action((opts) => {
+    pruneRegistry();
+    const repos = listRepos();
+    if (opts.json) {
+      console.log(JSON.stringify(repos, null, 2));
+    } else if (repos.length === 0) {
+      console.log(`No repositories registered.\nRegistry: ${REGISTRY_PATH}`);
+    } else {
+      console.log(`Registered repositories (${REGISTRY_PATH}):\n`);
+      for (const r of repos) {
+        const dbExists = fs.existsSync(r.dbPath);
+        const status = dbExists ? '' : ' [DB missing]';
+        console.log(`  ${r.name}${status}`);
+        console.log(`    Path: ${r.path}`);
+        console.log(`    DB:   ${r.dbPath}`);
+        console.log();
+      }
+    }
+  });
+
+registry
+  .command('add <dir>')
+  .description('Register a project directory')
+  .option('-n, --name <name>', 'Custom name (defaults to directory basename)')
+  .action((dir, opts) => {
+    const absDir = path.resolve(dir);
+    const { name, entry } = registerRepo(absDir, opts.name);
+    console.log(`Registered "${name}" → ${entry.path}`);
+  });
+
+registry
+  .command('remove <name>')
+  .description('Unregister a repository by name')
+  .action((name) => {
+    const removed = unregisterRepo(name);
+    if (removed) {
+      console.log(`Removed "${name}" from registry.`);
+    } else {
+      console.error(`Repository "${name}" not found in registry.`);
+      process.exit(1);
+    }
+  });
+
+registry
+  .command('prune')
+  .description('Remove stale registry entries (missing directories or idle beyond TTL)')
+  .option('--ttl <days>', 'Days of inactivity before pruning (default: 30)', '30')
+  .action((opts) => {
+    const pruned = pruneRegistry(undefined, parseInt(opts.ttl, 10));
+    if (pruned.length === 0) {
+      console.log('No stale entries found.');
+    } else {
+      for (const entry of pruned) {
+        const tag = entry.reason === 'expired' ? 'expired' : 'missing';
+        console.log(`Pruned "${entry.name}" (${entry.path}) [${tag}]`);
+      }
+      console.log(`\nRemoved ${pruned.length} stale ${pruned.length === 1 ? 'entry' : 'entries'}.`);
+    }
   });
 
 // ─── Embedding commands ─────────────────────────────────────────────────
@@ -199,7 +294,7 @@ program
   .action(() => {
     console.log('\nAvailable embedding models:\n');
     for (const [key, config] of Object.entries(MODELS)) {
-      const def = key === 'minilm' ? ' (default)' : '';
+      const def = key === 'jina-code' ? ' (default)' : '';
       console.log(`  ${key.padEnd(12)} ${String(config.dim).padStart(4)}d  ${config.desc}${def}`);
     }
     console.log('\nUsage: codegraph embed --model <name>');
@@ -213,8 +308,8 @@ program
   )
   .option(
     '-m, --model <name>',
-    'Embedding model: minilm (default), jina-small, jina-base, jina-code, nomic, nomic-v1.5, bge-large. Run `codegraph models` for details',
-    'minilm',
+    'Embedding model: minilm, jina-small, jina-base, jina-code (default), nomic, nomic-v1.5, bge-large. Run `codegraph models` for details',
+    'jina-code',
   )
   .action(async (dir, opts) => {
     const root = path.resolve(dir || '.');
@@ -244,6 +339,53 @@ program
     });
   });
 
+program
+  .command('structure [dir]')
+  .description(
+    'Show project directory structure with hierarchy, cohesion scores, and per-file metrics',
+  )
+  .option('-d, --db <path>', 'Path to graph.db')
+  .option('--depth <n>', 'Max directory depth')
+  .option('--sort <metric>', 'Sort by: cohesion | fan-in | fan-out | density | files', 'files')
+  .option('-j, --json', 'Output as JSON')
+  .action(async (dir, opts) => {
+    const { structureData, formatStructure } = await import('./structure.js');
+    const data = structureData(opts.db, {
+      directory: dir,
+      depth: opts.depth ? parseInt(opts.depth, 10) : undefined,
+      sort: opts.sort,
+    });
+    if (opts.json) {
+      console.log(JSON.stringify(data, null, 2));
+    } else {
+      console.log(formatStructure(data));
+    }
+  });
+
+program
+  .command('hotspots')
+  .description(
+    'Find structural hotspots: files or directories with extreme fan-in, fan-out, or symbol density',
+  )
+  .option('-d, --db <path>', 'Path to graph.db')
+  .option('-n, --limit <number>', 'Number of results', '10')
+  .option('--metric <metric>', 'fan-in | fan-out | density | coupling', 'fan-in')
+  .option('--level <level>', 'file | directory', 'file')
+  .option('-j, --json', 'Output as JSON')
+  .action(async (opts) => {
+    const { hotspotsData, formatHotspots } = await import('./structure.js');
+    const data = hotspotsData(opts.db, {
+      metric: opts.metric,
+      level: opts.level,
+      limit: parseInt(opts.limit, 10),
+    });
+    if (opts.json) {
+      console.log(JSON.stringify(data, null, 2));
+    } else {
+      console.log(formatHotspots(data));
+    }
+  });
+
 program
   .command('watch [dir]')
   .description('Watch project for file changes and incrementally update the graph')

package/src/config.js

@@ -19,7 +19,7 @@ export const DEFAULTS = {
     defaultDepth: 3,
     defaultLimit: 20,
   },
-  embeddings: { model: 'minilm', llmProvider: null },
+  embeddings: { model: 'jina-code', llmProvider: null },
   llm: { provider: null, model: null, baseUrl: null, apiKey: null, apiKeyCommand: null },
   search: { defaultMinScore: 0.2, rrfK: 60, topK: 15 },
   ci: { failOnCycles: false, impactThreshold: null },

package/src/constants.js

@@ -20,8 +20,6 @@ export const IGNORE_DIRS = new Set([
   '.env',
 ]);
 
-// Re-export as an indirect binding to avoid TDZ in the circular
-// parser.js ↔ constants.js import (no value read at evaluation time).
 export { SUPPORTED_EXTENSIONS as EXTENSIONS };
 
 export function shouldIgnore(dirName) {

package/src/cycles.js

@@ -31,8 +31,8 @@ export function findCycles(db, opts = {}) {
       FROM edges e
       JOIN nodes n1 ON e.source_id = n1.id
       JOIN nodes n2 ON e.target_id = n2.id
-      WHERE n1.kind IN ('function', 'method', 'class')
-        AND n2.kind IN ('function', 'method', 'class')
+      WHERE n1.kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module')
+        AND n2.kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module')
         AND e.kind = 'calls'
         AND n1.id != n2.id
     `)

package/src/db.js

@@ -33,6 +33,19 @@ export const MIGRATIONS = [
       CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source_id);
       CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target_id);
       CREATE INDEX IF NOT EXISTS idx_edges_kind ON edges(kind);
+      CREATE TABLE IF NOT EXISTS node_metrics (
+        node_id INTEGER PRIMARY KEY,
+        line_count INTEGER,
+        symbol_count INTEGER,
+        import_count INTEGER,
+        export_count INTEGER,
+        fan_in INTEGER,
+        fan_out INTEGER,
+        cohesion REAL,
+        file_count INTEGER,
+        FOREIGN KEY(node_id) REFERENCES nodes(id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_node_metrics_node ON node_metrics(node_id);
     `,
   },
   {

package/src/embedder.js

@@ -55,7 +55,7 @@ export const MODELS = {
   },
 };
 
-export const DEFAULT_MODEL = 'minilm';
+export const DEFAULT_MODEL = 'jina-code';
 const BATCH_SIZE_MAP = {
   minilm: 32,
   'jina-small': 16,
@@ -173,10 +173,10 @@ function initEmbeddingsSchema(db) {
 /**
  * Build embeddings for all functions/methods/classes in the graph.
  */
-export async function buildEmbeddings(rootDir, modelKey) {
+export async function buildEmbeddings(rootDir, modelKey, customDbPath) {
   // path already imported at top
   // fs already imported at top
-  const dbPath = findDbPath(null);
+  const dbPath = customDbPath || findDbPath(null);
 
   const db = new Database(dbPath);
   initEmbeddingsSchema(db);

package/src/export.js

@@ -24,25 +24,60 @@ export function exportDOT(db, opts = {}) {
     `)
       .all();
 
+    // Try to use directory nodes from DB (built by structure analysis)
+    const hasDirectoryNodes =
+      db.prepare("SELECT COUNT(*) as c FROM nodes WHERE kind = 'directory'").get().c > 0;
+
     const dirs = new Map();
     const allFiles = new Set();
     for (const { source, target } of edges) {
       allFiles.add(source);
       allFiles.add(target);
     }
-    for (const file of allFiles) {
-      const dir = path.dirname(file) || '.';
-      if (!dirs.has(dir)) dirs.set(dir, []);
-      dirs.get(dir).push(file);
+
+    if (hasDirectoryNodes) {
+      // Use DB directory structure with cohesion labels
+      const dbDirs = db
+        .prepare(`
+          SELECT n.id, n.name, nm.cohesion
+          FROM nodes n
+          LEFT JOIN node_metrics nm ON n.id = nm.node_id
+          WHERE n.kind = 'directory'
+        `)
+        .all();
+
+      for (const d of dbDirs) {
+        const containedFiles = 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 = 'file'
+          `)
+          .all(d.id)
+          .map((r) => r.name)
+          .filter((f) => allFiles.has(f));
+
+        if (containedFiles.length > 0) {
+          dirs.set(d.name, { files: containedFiles, cohesion: d.cohesion });
+        }
+      }
+    } else {
+      // Fallback: reconstruct from path.dirname()
+      for (const file of allFiles) {
+        const dir = path.dirname(file) || '.';
+        if (!dirs.has(dir)) dirs.set(dir, { files: [], cohesion: null });
+        dirs.get(dir).files.push(file);
+      }
     }
 
     let clusterIdx = 0;
-    for (const [dir, files] of [...dirs].sort()) {
+    for (const [dir, info] of [...dirs].sort((a, b) => a[0].localeCompare(b[0]))) {
       lines.push(`  subgraph cluster_${clusterIdx++} {`);
-      lines.push(`    label="${dir}";`);
+      const cohLabel = info.cohesion !== null ? ` (cohesion: ${info.cohesion.toFixed(2)})` : '';
+      lines.push(`    label="${dir}${cohLabel}";`);
       lines.push(`    style=dashed;`);
       lines.push(`    color="#999999";`);
-      for (const f of files) {
+      for (const f of info.files) {
         const label = path.basename(f);
         lines.push(`    "${f}" [label="${label}"];`);
       }
@@ -62,7 +97,7 @@ export function exportDOT(db, opts = {}) {
       FROM edges e
       JOIN nodes n1 ON e.source_id = n1.id
       JOIN nodes n2 ON e.target_id = n2.id
-      WHERE n1.kind IN ('function', 'method', 'class') AND n2.kind IN ('function', 'method', 'class')
+      WHERE n1.kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module') AND n2.kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module')
       AND e.kind = 'calls'
     `)
       .all();
@@ -111,7 +146,7 @@ export function exportMermaid(db, opts = {}) {
       FROM edges e
       JOIN nodes n1 ON e.source_id = n1.id
       JOIN nodes n2 ON e.target_id = n2.id
-      WHERE n1.kind IN ('function', 'method', 'class') AND n2.kind IN ('function', 'method', 'class')
+      WHERE n1.kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module') AND n2.kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module')
       AND e.kind = 'calls'
     `)
       .all();

package/src/extractors/csharp.js

@@ -0,0 +1,243 @@
+import { findChild, nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from C# files.
+ */
+export function extractCSharpSymbols(tree, _filePath) {
+  const definitions = [];
+  const calls = [];
+  const imports = [];
+  const classes = [];
+  const exports = [];
+
+  function findCSharpParentType(node) {
+    let current = node.parent;
+    while (current) {
+      if (
+        current.type === 'class_declaration' ||
+        current.type === 'struct_declaration' ||
+        current.type === 'interface_declaration' ||
+        current.type === 'enum_declaration' ||
+        current.type === 'record_declaration'
+      ) {
+        const nameNode = current.childForFieldName('name');
+        return nameNode ? nameNode.text : null;
+      }
+      current = current.parent;
+    }
+    return null;
+  }
+
+  function walkCSharpNode(node) {
+    switch (node.type) {
+      case 'class_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'class',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+          extractCSharpBaseTypes(node, nameNode.text, classes);
+        }
+        break;
+      }
+
+      case 'struct_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'struct',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+          extractCSharpBaseTypes(node, nameNode.text, classes);
+        }
+        break;
+      }
+
+      case 'record_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'record',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+          extractCSharpBaseTypes(node, nameNode.text, classes);
+        }
+        break;
+      }
+
+      case 'interface_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'interface',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+          const body = node.childForFieldName('body');
+          if (body) {
+            for (let i = 0; i < body.childCount; i++) {
+              const child = body.child(i);
+              if (child && child.type === 'method_declaration') {
+                const methName = child.childForFieldName('name');
+                if (methName) {
+                  definitions.push({
+                    name: `${nameNode.text}.${methName.text}`,
+                    kind: 'method',
+                    line: child.startPosition.row + 1,
+                    endLine: child.endPosition.row + 1,
+                  });
+                }
+              }
+            }
+          }
+        }
+        break;
+      }
+
+      case 'enum_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'enum',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        break;
+      }
+
+      case 'method_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          const parentType = findCSharpParentType(node);
+          const fullName = parentType ? `${parentType}.${nameNode.text}` : nameNode.text;
+          definitions.push({
+            name: fullName,
+            kind: 'method',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        break;
+      }
+
+      case 'constructor_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          const parentType = findCSharpParentType(node);
+          const fullName = parentType ? `${parentType}.${nameNode.text}` : nameNode.text;
+          definitions.push({
+            name: fullName,
+            kind: 'method',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        break;
+      }
+
+      case 'property_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          const parentType = findCSharpParentType(node);
+          const fullName = parentType ? `${parentType}.${nameNode.text}` : nameNode.text;
+          definitions.push({
+            name: fullName,
+            kind: 'method',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        break;
+      }
+
+      case 'using_directive': {
+        // using System.Collections.Generic;
+        const nameNode =
+          node.childForFieldName('name') ||
+          findChild(node, 'qualified_name') ||
+          findChild(node, 'identifier');
+        if (nameNode) {
+          const fullPath = nameNode.text;
+          const lastName = fullPath.split('.').pop();
+          imports.push({
+            source: fullPath,
+            names: [lastName],
+            line: node.startPosition.row + 1,
+            csharpUsing: true,
+          });
+        }
+        break;
+      }
+
+      case 'invocation_expression': {
+        const fn = node.childForFieldName('function') || node.child(0);
+        if (fn) {
+          if (fn.type === 'identifier') {
+            calls.push({ name: fn.text, line: node.startPosition.row + 1 });
+          } else if (fn.type === 'member_access_expression') {
+            const name = fn.childForFieldName('name');
+            if (name) calls.push({ name: name.text, line: node.startPosition.row + 1 });
+          } else if (fn.type === 'generic_name' || fn.type === 'member_binding_expression') {
+            const name = fn.childForFieldName('name') || fn.child(0);
+            if (name) calls.push({ name: name.text, line: node.startPosition.row + 1 });
+          }
+        }
+        break;
+      }
+
+      case 'object_creation_expression': {
+        const typeNode = node.childForFieldName('type');
+        if (typeNode) {
+          const typeName =
+            typeNode.type === 'generic_name'
+              ? typeNode.childForFieldName('name')?.text || typeNode.child(0)?.text
+              : typeNode.text;
+          if (typeName) calls.push({ name: typeName, line: node.startPosition.row + 1 });
+        }
+        break;
+      }
+    }
+
+    for (let i = 0; i < node.childCount; i++) walkCSharpNode(node.child(i));
+  }
+
+  walkCSharpNode(tree.rootNode);
+  return { definitions, calls, imports, classes, exports };
+}
+
+function extractCSharpBaseTypes(node, className, classes) {
+  const baseList = node.childForFieldName('bases');
+  if (!baseList) return;
+  for (let i = 0; i < baseList.childCount; i++) {
+    const child = baseList.child(i);
+    if (!child) continue;
+    if (child.type === 'identifier' || child.type === 'qualified_name') {
+      classes.push({ name: className, extends: child.text, line: node.startPosition.row + 1 });
+    } else if (child.type === 'generic_name') {
+      const name = child.childForFieldName('name') || child.child(0);
+      if (name)
+        classes.push({ name: className, extends: name.text, line: node.startPosition.row + 1 });
+    } else if (child.type === 'base_list') {
+      for (let j = 0; j < child.childCount; j++) {
+        const base = child.child(j);
+        if (base && (base.type === 'identifier' || base.type === 'qualified_name')) {
+          classes.push({ name: className, extends: base.text, line: node.startPosition.row + 1 });
+        } else if (base && base.type === 'generic_name') {
+          const name = base.childForFieldName('name') || base.child(0);
+          if (name)
+            classes.push({ name: className, extends: name.text, line: node.startPosition.row + 1 });
+        }
+      }
+    }
+  }
+}