@optave/codegraph 2.0.0 → 2.1.1-dev.00f091c

package/src/extractors/rust.js

@@ -0,0 +1,225 @@
+import { nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from Rust files.
+ */
+export function extractRustSymbols(tree, _filePath) {
+  const definitions = [];
+  const calls = [];
+  const imports = [];
+  const classes = [];
+  const exports = [];
+
+  function findCurrentImpl(node) {
+    let current = node.parent;
+    while (current) {
+      if (current.type === 'impl_item') {
+        const typeNode = current.childForFieldName('type');
+        return typeNode ? typeNode.text : null;
+      }
+      current = current.parent;
+    }
+    return null;
+  }
+
+  function walkRustNode(node) {
+    switch (node.type) {
+      case 'function_item': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          const implType = findCurrentImpl(node);
+          const fullName = implType ? `${implType}.${nameNode.text}` : nameNode.text;
+          const kind = implType ? 'method' : 'function';
+          definitions.push({
+            name: fullName,
+            kind,
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        break;
+      }
+
+      case 'struct_item': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'struct',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        break;
+      }
+
+      case 'enum_item': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'enum',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        break;
+      }
+
+      case 'trait_item': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'trait',
+            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 === 'function_signature_item' || child.type === 'function_item')
+              ) {
+                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 'impl_item': {
+        const typeNode = node.childForFieldName('type');
+        const traitNode = node.childForFieldName('trait');
+        if (typeNode && traitNode) {
+          classes.push({
+            name: typeNode.text,
+            implements: traitNode.text,
+            line: node.startPosition.row + 1,
+          });
+        }
+        break;
+      }
+
+      case 'use_declaration': {
+        const argNode = node.child(1);
+        if (argNode) {
+          const usePaths = extractRustUsePath(argNode);
+          for (const imp of usePaths) {
+            imports.push({
+              source: imp.source,
+              names: imp.names,
+              line: node.startPosition.row + 1,
+              rustUse: true,
+            });
+          }
+        }
+        break;
+      }
+
+      case 'call_expression': {
+        const fn = node.childForFieldName('function');
+        if (fn) {
+          if (fn.type === 'identifier') {
+            calls.push({ name: fn.text, line: node.startPosition.row + 1 });
+          } else if (fn.type === 'field_expression') {
+            const field = fn.childForFieldName('field');
+            if (field) {
+              const value = fn.childForFieldName('value');
+              const call = { name: field.text, line: node.startPosition.row + 1 };
+              if (value) call.receiver = value.text;
+              calls.push(call);
+            }
+          } else if (fn.type === 'scoped_identifier') {
+            const name = fn.childForFieldName('name');
+            if (name) {
+              const path = fn.childForFieldName('path');
+              const call = { name: name.text, line: node.startPosition.row + 1 };
+              if (path) call.receiver = path.text;
+              calls.push(call);
+            }
+          }
+        }
+        break;
+      }
+
+      case 'macro_invocation': {
+        const macroNode = node.child(0);
+        if (macroNode) {
+          calls.push({ name: `${macroNode.text}!`, line: node.startPosition.row + 1 });
+        }
+        break;
+      }
+    }
+
+    for (let i = 0; i < node.childCount; i++) walkRustNode(node.child(i));
+  }
+
+  walkRustNode(tree.rootNode);
+  return { definitions, calls, imports, classes, exports };
+}
+
+function extractRustUsePath(node) {
+  if (!node) return [];
+
+  if (node.type === 'use_list') {
+    const results = [];
+    for (let i = 0; i < node.childCount; i++) {
+      results.push(...extractRustUsePath(node.child(i)));
+    }
+    return results;
+  }
+
+  if (node.type === 'scoped_use_list') {
+    const pathNode = node.childForFieldName('path');
+    const listNode = node.childForFieldName('list');
+    const prefix = pathNode ? pathNode.text : '';
+    if (listNode) {
+      const names = [];
+      for (let i = 0; i < listNode.childCount; i++) {
+        const child = listNode.child(i);
+        if (
+          child &&
+          (child.type === 'identifier' || child.type === 'use_as_clause' || child.type === 'self')
+        ) {
+          const name =
+            child.type === 'use_as_clause'
+              ? (child.childForFieldName('alias') || child.childForFieldName('name'))?.text
+              : child.text;
+          if (name) names.push(name);
+        }
+      }
+      return [{ source: prefix, names }];
+    }
+    return [{ source: prefix, names: [] }];
+  }
+
+  if (node.type === 'use_as_clause') {
+    const name = node.childForFieldName('alias') || node.childForFieldName('name');
+    return [{ source: node.text, names: name ? [name.text] : [] }];
+  }
+
+  if (node.type === 'use_wildcard') {
+    const pathNode = node.childForFieldName('path');
+    return [{ source: pathNode ? pathNode.text : '*', names: ['*'] }];
+  }
+
+  if (node.type === 'scoped_identifier' || node.type === 'identifier') {
+    const text = node.text;
+    const lastName = text.split('::').pop();
+    return [{ source: text, names: [lastName] }];
+  }
+
+  return [];
+}

package/src/index.js

@@ -38,6 +38,7 @@ export { isNativeAvailable } from './native.js';
 export { getActiveEngine, parseFileAuto, parseFilesAuto } from './parser.js';
 // Query functions (data-returning)
 export {
+  contextData,
   diffImpactData,
   fileDepsData,
   fnDepsData,
@@ -45,6 +46,7 @@ export {
   impactAnalysisData,
   moduleMapData,
   queryNameData,
+  statsData,
 } from './queries.js';
 // Registry (multi-repo)
 export {

package/src/journal.js

@@ -0,0 +1,109 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { debug, warn } from './logger.js';
+
+export const JOURNAL_FILENAME = 'changes.journal';
+const HEADER_PREFIX = '# codegraph-journal v1 ';
+
+/**
+ * Read and validate the change journal.
+ * Returns { valid, timestamp, changed[], removed[] } or { valid: false }.
+ */
+export function readJournal(rootDir) {
+  const journalPath = path.join(rootDir, '.codegraph', JOURNAL_FILENAME);
+  let content;
+  try {
+    content = fs.readFileSync(journalPath, 'utf-8');
+  } catch {
+    return { valid: false };
+  }
+
+  const lines = content.split('\n');
+  if (lines.length === 0 || !lines[0].startsWith(HEADER_PREFIX)) {
+    debug('Journal has malformed or missing header');
+    return { valid: false };
+  }
+
+  const timestamp = Number(lines[0].slice(HEADER_PREFIX.length).trim());
+  if (!Number.isFinite(timestamp) || timestamp <= 0) {
+    debug('Journal has invalid timestamp');
+    return { valid: false };
+  }
+
+  const changed = [];
+  const removed = [];
+  const seenChanged = new Set();
+  const seenRemoved = new Set();
+
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line || line.startsWith('#')) continue;
+
+    if (line.startsWith('DELETED ')) {
+      const filePath = line.slice(8);
+      if (filePath && !seenRemoved.has(filePath)) {
+        seenRemoved.add(filePath);
+        removed.push(filePath);
+      }
+    } else {
+      if (!seenChanged.has(line)) {
+        seenChanged.add(line);
+        changed.push(line);
+      }
+    }
+  }
+
+  return { valid: true, timestamp, changed, removed };
+}
+
+/**
+ * Append changed/deleted paths to the journal.
+ * Creates the journal with a header if it doesn't exist.
+ */
+export function appendJournalEntries(rootDir, entries) {
+  const dir = path.join(rootDir, '.codegraph');
+  const journalPath = path.join(dir, JOURNAL_FILENAME);
+
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  // If journal doesn't exist, create with a placeholder header
+  if (!fs.existsSync(journalPath)) {
+    fs.writeFileSync(journalPath, `${HEADER_PREFIX}0\n`);
+  }
+
+  const lines = entries.map((e) => {
+    if (e.deleted) return `DELETED ${e.file}`;
+    return e.file;
+  });
+
+  fs.appendFileSync(journalPath, `${lines.join('\n')}\n`);
+}
+
+/**
+ * Write a fresh journal header after a successful build.
+ * Atomic: write to temp file then rename.
+ */
+export function writeJournalHeader(rootDir, timestamp) {
+  const dir = path.join(rootDir, '.codegraph');
+  const journalPath = path.join(dir, JOURNAL_FILENAME);
+  const tmpPath = `${journalPath}.tmp`;
+
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  try {
+    fs.writeFileSync(tmpPath, `${HEADER_PREFIX}${timestamp}\n`);
+    fs.renameSync(tmpPath, journalPath);
+  } catch (err) {
+    warn(`Failed to write journal header: ${err.message}`);
+    // Clean up temp file if rename failed
+    try {
+      fs.unlinkSync(tmpPath);
+    } catch {
+      /* ignore */
+    }
+  }
+}

package/src/mcp.js

@@ -100,6 +100,34 @@ const BASE_TOOLS = [
       required: ['name'],
     },
   },
+  {
+    name: 'context',
+    description:
+      'Full context for a function: source code, dependencies with summaries, callers, signature, and related tests — everything needed to understand or modify a function in one call',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Function/method/class name (partial match)' },
+        depth: {
+          type: 'number',
+          description: 'Include callee source up to N levels deep (0=no source, 1=direct)',
+          default: 0,
+        },
+        no_source: {
+          type: 'boolean',
+          description: 'Skip source extraction (metadata only)',
+          default: false,
+        },
+        no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
+        include_tests: {
+          type: 'boolean',
+          description: 'Include test file source code',
+          default: false,
+        },
+      },
+      required: ['name'],
+    },
+  },
   {
     name: 'diff_impact',
     description: 'Analyze git diff to find which functions changed and their transitive callers',
@@ -245,12 +273,15 @@ export { TOOLS, buildToolList };
 export async function startMCPServer(customDbPath, options = {}) {
   const { allowedRepos } = options;
   const multiRepo = options.multiRepo || !!allowedRepos;
-  let Server, StdioServerTransport;
+  let Server, StdioServerTransport, ListToolsRequestSchema, CallToolRequestSchema;
   try {
     const sdk = await import('@modelcontextprotocol/sdk/server/index.js');
     Server = sdk.Server;
     const transport = await import('@modelcontextprotocol/sdk/server/stdio.js');
     StdioServerTransport = transport.StdioServerTransport;
+    const types = await import('@modelcontextprotocol/sdk/types.js');
+    ListToolsRequestSchema = types.ListToolsRequestSchema;
+    CallToolRequestSchema = types.CallToolRequestSchema;
   } catch {
     console.error(
       'MCP server requires @modelcontextprotocol/sdk.\n' +
@@ -267,6 +298,7 @@ export async function startMCPServer(customDbPath, options = {}) {
     fileDepsData,
     fnDepsData,
     fnImpactData,
+    contextData,
     diffImpactData,
     listFunctionsData,
   } = await import('./queries.js');
@@ -279,9 +311,11 @@ export async function startMCPServer(customDbPath, options = {}) {
     { capabilities: { tools: {} } },
   );
 
-  server.setRequestHandler('tools/list', async () => ({ tools: buildToolList(multiRepo) }));
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: buildToolList(multiRepo),
+  }));
 
-  server.setRequestHandler('tools/call', async (request) => {
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
 
     try {
@@ -343,6 +377,14 @@ export async function startMCPServer(customDbPath, options = {}) {
             noTests: args.no_tests,
           });
           break;
+        case 'context':
+          result = contextData(args.name, dbPath, {
+            depth: args.depth,
+            noSource: args.no_source,
+            noTests: args.no_tests,
+            includeTests: args.include_tests,
+          });
+          break;
         case 'diff_impact':
           result = diffImpactData(dbPath, {
             staged: args.staged,
@@ -422,7 +464,8 @@ export async function startMCPServer(customDbPath, options = {}) {
           break;
         }
         case 'list_repos': {
-          const { listRepos } = await import('./registry.js');
+          const { listRepos, pruneRegistry } = await import('./registry.js');
+          pruneRegistry();
           let repos = listRepos();
           if (allowedRepos) {
             repos = repos.filter((r) => allowedRepos.includes(r.name));