@optave/codegraph 1.3.0 → 2.0.0

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/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/index.js

@@ -46,5 +46,26 @@ export {
   moduleMapData,
   queryNameData,
 } from './queries.js';
+// Registry (multi-repo)
+export {
+  listRepos,
+  loadRegistry,
+  pruneRegistry,
+  REGISTRY_PATH,
+  registerRepo,
+  resolveRepoDbPath,
+  saveRegistry,
+  unregisterRepo,
+} from './registry.js';
+// Structure analysis
+export {
+  buildStructure,
+  formatHotspots,
+  formatModuleBoundaries,
+  formatStructure,
+  hotspotsData,
+  moduleBoundariesData,
+  structureData,
+} from './structure.js';
 // Watch mode
 export { watchProject } from './watcher.js';

package/src/mcp.js

@@ -9,7 +9,14 @@ import { createRequire } from 'node:module';
 import { findCycles } from './cycles.js';
 import { findDbPath } from './db.js';
 
-const TOOLS = [
+const REPO_PROP = {
+  repo: {
+    type: 'string',
+    description: 'Repository name from the registry (omit for local project)',
+  },
+};
+
+const BASE_TOOLS = [
   {
     name: 'query_function',
     description: 'Find callers and callees of a function by name',
@@ -66,15 +73,178 @@ const TOOLS = [
       },
     },
   },
+  {
+    name: 'fn_deps',
+    description: 'Show function-level dependency chain: what a function calls and what calls it',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Function/method/class name (partial match)' },
+        depth: { type: 'number', description: 'Transitive caller depth', default: 3 },
+        no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
+      },
+      required: ['name'],
+    },
+  },
+  {
+    name: 'fn_impact',
+    description:
+      'Show function-level blast radius: all functions transitively affected by changes to a function',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Function/method/class name (partial match)' },
+        depth: { type: 'number', description: 'Max traversal depth', default: 5 },
+        no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
+      },
+      required: ['name'],
+    },
+  },
+  {
+    name: 'diff_impact',
+    description: 'Analyze git diff to find which functions changed and their transitive callers',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        staged: { type: 'boolean', description: 'Analyze staged changes only', default: false },
+        ref: { type: 'string', description: 'Git ref to diff against (default: HEAD)' },
+        depth: { type: 'number', description: 'Transitive caller depth', default: 3 },
+        no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
+      },
+    },
+  },
+  {
+    name: 'semantic_search',
+    description:
+      'Search code symbols by meaning using embeddings (requires prior `codegraph embed`)',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Natural language search query' },
+        limit: { type: 'number', description: 'Max results to return', default: 15 },
+        min_score: { type: 'number', description: 'Minimum similarity score (0-1)', default: 0.2 },
+      },
+      required: ['query'],
+    },
+  },
+  {
+    name: 'export_graph',
+    description: 'Export the dependency graph in DOT (Graphviz), Mermaid, or JSON format',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        format: {
+          type: 'string',
+          enum: ['dot', 'mermaid', 'json'],
+          description: 'Export format',
+        },
+        file_level: {
+          type: 'boolean',
+          description: 'File-level graph (true) or function-level (false)',
+          default: true,
+        },
+      },
+      required: ['format'],
+    },
+  },
+  {
+    name: 'list_functions',
+    description:
+      'List functions, methods, classes, structs, enums, traits, records, and modules in the codebase, optionally filtered by file or name pattern',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        file: { type: 'string', description: 'Filter by file path (partial match)' },
+        pattern: { type: 'string', description: 'Filter by function name (partial match)' },
+        no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
+      },
+    },
+  },
+  {
+    name: 'structure',
+    description:
+      'Show project structure with directory hierarchy, cohesion scores, and per-file metrics',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        directory: { type: 'string', description: 'Filter to a specific directory path' },
+        depth: { type: 'number', description: 'Max directory depth to show' },
+        sort: {
+          type: 'string',
+          enum: ['cohesion', 'fan-in', 'fan-out', 'density', 'files'],
+          description: 'Sort directories by metric',
+        },
+      },
+    },
+  },
+  {
+    name: 'hotspots',
+    description:
+      'Find structural hotspots: files or directories with extreme fan-in, fan-out, or symbol density',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        metric: {
+          type: 'string',
+          enum: ['fan-in', 'fan-out', 'density', 'coupling'],
+          description: 'Metric to rank by',
+        },
+        level: {
+          type: 'string',
+          enum: ['file', 'directory'],
+          description: 'Rank files or directories',
+        },
+        limit: { type: 'number', description: 'Number of results to return', default: 10 },
+      },
+    },
+  },
 ];
 
-export { TOOLS };
+const LIST_REPOS_TOOL = {
+  name: 'list_repos',
+  description: 'List all repositories registered in the codegraph registry',
+  inputSchema: {
+    type: 'object',
+    properties: {},
+  },
+};
+
+/**
+ * Build the tool list based on multi-repo mode.
+ * @param {boolean} multiRepo - If true, inject `repo` prop into each tool and append `list_repos`
+ * @returns {object[]}
+ */
+function buildToolList(multiRepo) {
+  if (!multiRepo) return BASE_TOOLS;
+  return [
+    ...BASE_TOOLS.map((tool) => ({
+      ...tool,
+      inputSchema: {
+        ...tool.inputSchema,
+        properties: { ...tool.inputSchema.properties, ...REPO_PROP },
+      },
+    })),
+    LIST_REPOS_TOOL,
+  ];
+}
+
+// Backward-compatible export: full multi-repo tool list
+const TOOLS = buildToolList(true);
+
+export { TOOLS, buildToolList };
 
 /**
  * Start the MCP server.
  * This function requires @modelcontextprotocol/sdk to be installed.
+ *
+ * @param {string} [customDbPath] - Path to a specific graph.db
+ * @param {object} [options]
+ * @param {boolean} [options.multiRepo] - Enable multi-repo access (default: false)
+ * @param {string[]} [options.allowedRepos] - Restrict access to these repo names only
  */
-export async function startMCPServer(customDbPath) {
+export async function startMCPServer(customDbPath, options = {}) {
+  const { allowedRepos } = options;
+  const multiRepo = options.multiRepo || !!allowedRepos;
   let Server, StdioServerTransport;
   try {
     const sdk = await import('@modelcontextprotocol/sdk/server/index.js');
@@ -90,9 +260,16 @@ export async function startMCPServer(customDbPath) {
   }
 
   // Lazy import query functions to avoid circular deps at module load
-  const { queryNameData, impactAnalysisData, moduleMapData, fileDepsData } = await import(
-    './queries.js'
-  );
+  const {
+    queryNameData,
+    impactAnalysisData,
+    moduleMapData,
+    fileDepsData,
+    fnDepsData,
+    fnImpactData,
+    diffImpactData,
+    listFunctionsData,
+  } = await import('./queries.js');
 
   const require = createRequire(import.meta.url);
   const Database = require('better-sqlite3');
@@ -102,13 +279,37 @@ export async function startMCPServer(customDbPath) {
     { capabilities: { tools: {} } },
   );
 
-  server.setRequestHandler('tools/list', async () => ({ tools: TOOLS }));
+  server.setRequestHandler('tools/list', async () => ({ tools: buildToolList(multiRepo) }));
 
   server.setRequestHandler('tools/call', async (request) => {
     const { name, arguments: args } = request.params;
-    const dbPath = customDbPath || undefined;
 
     try {
+      if (!multiRepo && args.repo) {
+        throw new Error(
+          'Multi-repo access is disabled. Restart with `codegraph mcp --multi-repo` to access other repositories.',
+        );
+      }
+      if (!multiRepo && name === 'list_repos') {
+        throw new Error(
+          'Multi-repo access is disabled. Restart with `codegraph mcp --multi-repo` to list repositories.',
+        );
+      }
+
+      let dbPath = customDbPath || undefined;
+      if (args.repo) {
+        if (allowedRepos && !allowedRepos.includes(args.repo)) {
+          throw new Error(`Repository "${args.repo}" is not in the allowed repos list.`);
+        }
+        const { resolveRepoDbPath } = await import('./registry.js');
+        const resolved = resolveRepoDbPath(args.repo);
+        if (!resolved)
+          throw new Error(
+            `Repository "${args.repo}" not found in registry or its database is missing.`,
+          );
+        dbPath = resolved;
+      }
+
       let result;
       switch (name) {
         case 'query_function':
@@ -130,6 +331,105 @@ export async function startMCPServer(customDbPath) {
         case 'module_map':
           result = moduleMapData(dbPath, args.limit || 20);
           break;
+        case 'fn_deps':
+          result = fnDepsData(args.name, dbPath, {
+            depth: args.depth,
+            noTests: args.no_tests,
+          });
+          break;
+        case 'fn_impact':
+          result = fnImpactData(args.name, dbPath, {
+            depth: args.depth,
+            noTests: args.no_tests,
+          });
+          break;
+        case 'diff_impact':
+          result = diffImpactData(dbPath, {
+            staged: args.staged,
+            ref: args.ref,
+            depth: args.depth,
+            noTests: args.no_tests,
+          });
+          break;
+        case 'semantic_search': {
+          const { searchData } = await import('./embedder.js');
+          result = await searchData(args.query, dbPath, {
+            limit: args.limit,
+            minScore: args.min_score,
+          });
+          if (result === null) {
+            return {
+              content: [
+                { type: 'text', text: 'Semantic search unavailable. Run `codegraph embed` first.' },
+              ],
+              isError: true,
+            };
+          }
+          break;
+        }
+        case 'export_graph': {
+          const { exportDOT, exportMermaid, exportJSON } = await import('./export.js');
+          const db = new Database(findDbPath(dbPath), { readonly: true });
+          const fileLevel = args.file_level !== false;
+          switch (args.format) {
+            case 'dot':
+              result = exportDOT(db, { fileLevel });
+              break;
+            case 'mermaid':
+              result = exportMermaid(db, { fileLevel });
+              break;
+            case 'json':
+              result = exportJSON(db);
+              break;
+            default:
+              db.close();
+              return {
+                content: [
+                  {
+                    type: 'text',
+                    text: `Unknown format: ${args.format}. Use dot, mermaid, or json.`,
+                  },
+                ],
+                isError: true,
+              };
+          }
+          db.close();
+          break;
+        }
+        case 'list_functions':
+          result = listFunctionsData(dbPath, {
+            file: args.file,
+            pattern: args.pattern,
+            noTests: args.no_tests,
+          });
+          break;
+        case 'structure': {
+          const { structureData } = await import('./structure.js');
+          result = structureData(dbPath, {
+            directory: args.directory,
+            depth: args.depth,
+            sort: args.sort,
+          });
+          break;
+        }
+        case 'hotspots': {
+          const { hotspotsData } = await import('./structure.js');
+          result = hotspotsData(dbPath, {
+            metric: args.metric,
+            level: args.level,
+            limit: args.limit,
+          });
+          break;
+        }
+        case 'list_repos': {
+          const { listRepos } = await import('./registry.js');
+          let repos = listRepos();
+          if (allowedRepos) {
+            repos = repos.filter((r) => allowedRepos.includes(r.name));
+          }
+          result = { repos };
+          break;
+        }
         default:
           return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
       }

package/src/parser.js

@@ -2,7 +2,6 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { Language, Parser } from 'web-tree-sitter';
-import { normalizePath } from './constants.js';
 import { warn } from './logger.js';
 import { loadNative } from './native.js';
 
@@ -731,7 +730,7 @@ export function extractGoSymbols(tree, _filePath) {
             if (typeNode.type === 'struct_type') {
               definitions.push({
                 name: nameNode.text,
-                kind: 'class',
+                kind: 'struct',
                 line: node.startPosition.row + 1,
                 endLine: nodeEndLine(node),
               });
@@ -876,7 +875,7 @@ export function extractRustSymbols(tree, _filePath) {
         if (nameNode) {
           definitions.push({
             name: nameNode.text,
-            kind: 'class',
+            kind: 'struct',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
           });
@@ -889,7 +888,7 @@ export function extractRustSymbols(tree, _filePath) {
         if (nameNode) {
           definitions.push({
             name: nameNode.text,
-            kind: 'class',
+            kind: 'enum',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
           });
@@ -902,7 +901,7 @@ export function extractRustSymbols(tree, _filePath) {
         if (nameNode) {
           definitions.push({
             name: nameNode.text,
-            kind: 'interface',
+            kind: 'trait',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
           });
@@ -1186,7 +1185,7 @@ export function extractJavaSymbols(tree, _filePath) {
         if (nameNode) {
           definitions.push({
             name: nameNode.text,
-            kind: 'class',
+            kind: 'enum',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
           });
@@ -1320,7 +1319,7 @@ export function extractCSharpSymbols(tree, _filePath) {
         if (nameNode) {
           definitions.push({
             name: nameNode.text,
-            kind: 'class',
+            kind: 'struct',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
           });
@@ -1334,7 +1333,7 @@ export function extractCSharpSymbols(tree, _filePath) {
         if (nameNode) {
           definitions.push({
             name: nameNode.text,
-            kind: 'class',
+            kind: 'record',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
           });
@@ -1378,7 +1377,7 @@ export function extractCSharpSymbols(tree, _filePath) {
         if (nameNode) {
           definitions.push({
             name: nameNode.text,
-            kind: 'class',
+            kind: 'enum',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
           });
@@ -1588,7 +1587,7 @@ export function extractRubySymbols(tree, _filePath) {
         if (nameNode) {
           definitions.push({
             name: nameNode.text,
-            kind: 'class',
+            kind: 'module',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
           });
@@ -1818,7 +1817,7 @@ export function extractPHPSymbols(tree, _filePath) {
         if (nameNode) {
           definitions.push({
             name: nameNode.text,
-            kind: 'interface',
+            kind: 'trait',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
           });
@@ -1831,7 +1830,7 @@ export function extractPHPSymbols(tree, _filePath) {
         if (nameNode) {
           definitions.push({
             name: nameNode.text,
-            kind: 'class',
+            kind: 'enum',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
           });
@@ -2145,7 +2144,7 @@ export async function parseFilesAuto(filePaths, rootDir, opts = {}) {
     const nativeResults = native.parseFiles(filePaths, rootDir);
     for (const r of nativeResults) {
       if (!r) continue;
-      const relPath = normalizePath(path.relative(rootDir, r.file));
+      const relPath = path.relative(rootDir, r.file).split(path.sep).join('/');
       result.set(relPath, normalizeNativeSymbols(r));
     }
     return result;
@@ -2163,7 +2162,7 @@ export async function parseFilesAuto(filePaths, rootDir, opts = {}) {
     }
     const symbols = wasmExtractSymbols(parsers, filePath, code);
     if (symbols) {
-      const relPath = normalizePath(path.relative(rootDir, filePath));
+      const relPath = path.relative(rootDir, filePath).split(path.sep).join('/');
       result.set(relPath, symbols);
     }
   }

package/src/queries.js

@@ -566,6 +566,36 @@ export function diffImpactData(customDbPath, opts = {}) {
   };
 }
 
+export function listFunctionsData(customDbPath, opts = {}) {
+  const db = openReadonlyOrFail(customDbPath);
+  const noTests = opts.noTests || false;
+  const kinds = ['function', 'method', 'class'];
+  const placeholders = kinds.map(() => '?').join(', ');
+
+  const conditions = [`kind IN (${placeholders})`];
+  const params = [...kinds];
+
+  if (opts.file) {
+    conditions.push('file LIKE ?');
+    params.push(`%${opts.file}%`);
+  }
+  if (opts.pattern) {
+    conditions.push('name LIKE ?');
+    params.push(`%${opts.pattern}%`);
+  }
+
+  let rows = db
+    .prepare(
+      `SELECT name, kind, file, line FROM nodes WHERE ${conditions.join(' AND ')} ORDER BY file, line`,
+    )
+    .all(...params);
+
+  if (noTests) rows = rows.filter((r) => !isTestFile(r.file));
+
+  db.close();
+  return { count: rows.length, functions: rows };
+}
+
 // ─── Human-readable output (original formatting) ───────────────────────
 
 export function queryName(name, customDbPath, opts = {}) {