@optave/codegraph 3.1.2 → 3.1.4

package/src/infrastructure/result-formatter.js

@@ -1,21 +1,2 @@
-import { printNdjson } from '../paginate.js';
-
-/**
- * Shared JSON / NDJSON output dispatch for CLI wrappers.
- *
- * @param {object} data   - Result object from a *Data() function
- * @param {string} field  - Array field name for NDJSON streaming (e.g. 'results')
- * @param {object} opts   - CLI options ({ json?, ndjson? })
- * @returns {boolean} true if output was handled (caller should return early)
- */
-export function outputResult(data, field, opts) {
-  if (opts.ndjson) {
-    printNdjson(data, field);
-    return true;
-  }
-  if (opts.json) {
-    console.log(JSON.stringify(data, null, 2));
-    return true;
-  }
-  return false;
-}
+// Re-export from presentation layer — this file exists for backward compatibility.
+export { outputResult } from '../presentation/result-formatter.js';

package/src/mcp/index.js

@@ -0,0 +1,2 @@
+export { startMCPServer } from './server.js';
+export { buildToolList, TOOLS } from './tool-registry.js';

package/src/mcp/middleware.js

@@ -0,0 +1,26 @@
+/**
+ * MCP middleware helpers — pagination defaults and limits.
+ */
+
+import { MCP_DEFAULTS, MCP_MAX_LIMIT } from '../paginate.js';
+
+export { MCP_DEFAULTS, MCP_MAX_LIMIT };
+
+/**
+ * Resolve effective limit for a tool call.
+ * @param {object} args - Tool arguments
+ * @param {string} toolName - Tool name (for default lookup)
+ * @returns {number}
+ */
+export function effectiveLimit(args, toolName) {
+  return Math.min(args.limit ?? MCP_DEFAULTS[toolName] ?? 100, MCP_MAX_LIMIT);
+}
+
+/**
+ * Resolve effective offset for a tool call.
+ * @param {object} args - Tool arguments
+ * @returns {number}
+ */
+export function effectiveOffset(args) {
+  return args.offset ?? 0;
+}

package/src/mcp/server.js

@@ -0,0 +1,128 @@
+/**
+ * MCP (Model Context Protocol) server for codegraph.
+ * Exposes codegraph queries as tools that AI coding assistants can call.
+ *
+ * Requires: npm install @modelcontextprotocol/sdk
+ */
+
+import { createRequire } from 'node:module';
+import { findDbPath } from '../db.js';
+import { CodegraphError, ConfigError } from '../errors.js';
+import { MCP_MAX_LIMIT } from '../paginate.js';
+import { buildToolList } from './tool-registry.js';
+import { TOOL_HANDLERS } from './tools/index.js';
+
+/**
+ * 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, options = {}) {
+  const { allowedRepos } = options;
+  const multiRepo = options.multiRepo || !!allowedRepos;
+  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 {
+    throw new ConfigError(
+      'MCP server requires @modelcontextprotocol/sdk.\nInstall it with: npm install @modelcontextprotocol/sdk',
+    );
+  }
+
+  // Connect transport FIRST so the server can receive the client's
+  // `initialize` request while heavy modules (queries, better-sqlite3)
+  // are still loading.  These are lazy-loaded on the first tool call
+  // and cached for subsequent calls.
+  let _queries;
+  let _Database;
+
+  async function getQueries() {
+    if (!_queries) {
+      _queries = await import('../queries.js');
+    }
+    return _queries;
+  }
+
+  function getDatabase() {
+    if (!_Database) {
+      const require = createRequire(import.meta.url);
+      _Database = require('better-sqlite3');
+    }
+    return _Database;
+  }
+
+  const server = new Server(
+    { name: 'codegraph', version: '1.0.0' },
+    { capabilities: { tools: {} } },
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: buildToolList(multiRepo),
+  }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      if (!multiRepo && args.repo) {
+        throw new ConfigError(
+          'Multi-repo access is disabled. Restart with `codegraph mcp --multi-repo` to access other repositories.',
+        );
+      }
+      if (!multiRepo && name === 'list_repos') {
+        throw new ConfigError(
+          '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 ConfigError(`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 ConfigError(
+            `Repository "${args.repo}" not found in registry or its database is missing.`,
+          );
+        dbPath = resolved;
+      }
+
+      const toolEntry = TOOL_HANDLERS.get(name);
+      if (!toolEntry) {
+        return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+      }
+
+      const ctx = {
+        dbPath,
+        getQueries,
+        getDatabase,
+        findDbPath,
+        allowedRepos,
+        MCP_MAX_LIMIT,
+      };
+
+      const result = await toolEntry.handler(args, ctx);
+      if (result?.content) return result; // pass-through MCP responses
+      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    } catch (err) {
+      const code = err instanceof CodegraphError ? err.code : 'UNKNOWN_ERROR';
+      const text =
+        err instanceof CodegraphError ? `[${code}] ${err.message}` : `Error: ${err.message}`;
+      return { content: [{ type: 'text', text }], isError: true };
+    }
+  });
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}