neuronlayer 0.1.8 → 0.2.0

package/src/server/mcp.ts

@@ -1,154 +0,0 @@
-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: 'neuronlayer',
-        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

@@ -1,85 +0,0 @@
-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}`);
-  }
-}