neuronlayer 0.1.0

package/src/server/mcp.ts

@@ -0,0 +1,154 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { MemoryLayerEngine } from '../core/engine.js';
+import {
+  allToolDefinitions,
+  handleGatewayCall,
+  isGatewayTool,
+} from './gateways/index.js';
+import { handleToolCall } from './tools.js';
+import { resourceDefinitions, handleResourceRead } from './resources.js';
+import type { MemoryLayerConfig } from '../types/index.js';
+
+export class MCPServer {
+  private server: Server;
+  private engine: MemoryLayerEngine;
+
+  constructor(config: MemoryLayerConfig) {
+    this.engine = new MemoryLayerEngine(config);
+
+    this.server = new Server(
+      {
+        name: 'memorylayer',
+        version: '0.1.0'
+      },
+      {
+        capabilities: {
+          tools: {},
+          resources: {}
+        }
+      }
+    );
+
+    this.setupHandlers();
+  }
+
+  private setupHandlers(): void {
+    // List available tools - now using gateway pattern (10 tools instead of 51)
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: allToolDefinitions.map(t => ({
+          name: t.name,
+          description: t.description,
+          inputSchema: t.inputSchema
+        }))
+      };
+    });
+
+    // Handle tool calls - route to gateways or standalone handlers
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+
+      try {
+        let result;
+
+        // Check if it's a gateway tool
+        if (isGatewayTool(name)) {
+          result = await handleGatewayCall(this.engine, name, args || {});
+        } else {
+          // Standalone tools route to existing handler
+          result = await handleToolCall(this.engine, name, args || {});
+        }
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({ error: errorMessage })
+            }
+          ],
+          isError: true
+        };
+      }
+    });
+
+    // List available resources
+    this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
+      return {
+        resources: resourceDefinitions.map(r => ({
+          uri: r.uri,
+          name: r.name,
+          description: r.description,
+          mimeType: r.mimeType
+        }))
+      };
+    });
+
+    // Read resource content
+    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+      const { uri } = request.params;
+
+      try {
+        const result = await handleResourceRead(this.engine, uri);
+
+        return {
+          contents: [
+            {
+              uri,
+              mimeType: result.mimeType,
+              text: result.contents
+            }
+          ]
+        };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(errorMessage);
+      }
+    });
+  }
+
+  async start(): Promise<void> {
+    // Connect to stdio transport FIRST (so we can respond to MCP immediately)
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+
+    console.error('MemoryLayer MCP server started');
+
+    // Initialize the engine in the background (indexing, etc.)
+    // This allows MCP to respond while indexing happens
+    this.engine.initialize().catch(err => {
+      console.error('Engine initialization error:', err);
+    });
+
+    // Handle shutdown
+    process.on('SIGINT', () => {
+      this.shutdown();
+      process.exit(0);
+    });
+
+    process.on('SIGTERM', () => {
+      this.shutdown();
+      process.exit(0);
+    });
+  }
+
+  shutdown(): void {
+    this.engine.shutdown();
+  }
+}

package/src/server/resources.ts

@@ -0,0 +1,85 @@
+import type { MemoryLayerEngine } from '../core/engine.js';
+
+export interface ResourceDefinition {
+  uri: string;
+  name: string;
+  description: string;
+  mimeType: string;
+}
+
+export const resourceDefinitions: ResourceDefinition[] = [
+  {
+    uri: 'memorylayer://decisions/recent',
+    name: 'Recent Decisions',
+    description: 'Last 10 architectural decisions made in this project',
+    mimeType: 'application/json'
+  },
+  {
+    uri: 'memorylayer://project/overview',
+    name: 'Project Overview',
+    description: 'High-level project summary including languages, files, and structure',
+    mimeType: 'text/markdown'
+  }
+];
+
+export async function handleResourceRead(
+  engine: MemoryLayerEngine,
+  uri: string
+): Promise<{ contents: string; mimeType: string }> {
+  switch (uri) {
+    case 'memorylayer://decisions/recent': {
+      const decisions = engine.getRecentDecisions(10);
+
+      const contents = JSON.stringify(
+        decisions.map(d => ({
+          id: d.id,
+          title: d.title,
+          description: d.description,
+          files: d.files,
+          tags: d.tags,
+          created_at: d.createdAt.toISOString()
+        })),
+        null,
+        2
+      );
+
+      return { contents, mimeType: 'application/json' };
+    }
+
+    case 'memorylayer://project/overview': {
+      const summary = engine.getProjectSummary();
+
+      const markdown = `# ${summary.name}
+
+${summary.description || 'No description available.'}
+
+## Statistics
+- **Total Files**: ${summary.totalFiles}
+- **Total Lines**: ${summary.totalLines.toLocaleString()}
+- **Languages**: ${summary.languages.join(', ') || 'Unknown'}
+
+## Key Directories
+${summary.keyDirectories.map(d => `- \`${d}/\``).join('\n') || 'None detected'}
+
+## Dependencies
+${summary.dependencies.slice(0, 10).map(d => `- ${d}`).join('\n') || 'None detected'}
+${summary.dependencies.length > 10 ? `\n... and ${summary.dependencies.length - 10} more` : ''}
+
+## Recent Decisions
+${summary.recentDecisions.length > 0
+  ? summary.recentDecisions.map(d => `### ${d.title}
+${d.description}
+_${d.createdAt.toLocaleDateString()}_
+`).join('\n')
+  : 'No decisions recorded yet.'}
+
+${summary.architectureNotes ? `## Architecture Notes\n${summary.architectureNotes}` : ''}
+`;
+
+      return { contents: markdown, mimeType: 'text/markdown' };
+    }
+
+    default:
+      throw new Error(`Unknown resource: ${uri}`);
+  }
+}