@synth-coder/memhub 0.1.2 → 0.1.4

package/src/contracts/mcp.ts

@@ -1,6 +1,6 @@
 /**
  * MCP (Model Context Protocol) specific types and constants
- * Defines the protocol structures for stdio-based communication
+ * Tool definitions and business-level types (protocol types provided by SDK)
  */
 
 import type { Memory } from './types.js';
@@ -19,86 +19,7 @@ export const SERVER_INFO = {
 } as const;
 
 // ============================================================================
-// MCP Request/Response Types
-// ============================================================================
-
-/** JSON-RPC request ID */
-export type RequestId = string | number;
-
-/** Base JSON-RPC request structure */
-export interface JsonRpcRequest<T = unknown> {
-  jsonrpc: '2.0';
-  id?: RequestId;
-  method: string;
-  params?: T;
-}
-
-/** Base JSON-RPC response structure */
-export interface JsonRpcResponse<T = unknown> {
-  jsonrpc: '2.0';
-  id: RequestId | null;
-  result?: T;
-  error?: JsonRpcError;
-}
-
-/** JSON-RPC error structure */
-export interface JsonRpcError {
-  code: number;
-  message: string;
-  data?: unknown;
-}
-
-/** JSON-RPC notification (no response expected) */
-export interface JsonRpcNotification<T = unknown> {
-  jsonrpc: '2.0';
-  method: string;
-  params?: T;
-}
-
-// ============================================================================
-// MCP Lifecycle Messages
-// ============================================================================
-
-/** Initialize request parameters */
-export interface InitializeParams {
-  protocolVersion: string;
-  capabilities: ClientCapabilities;
-  clientInfo: Implementation;
-}
-
-/** Initialize result */
-export interface InitializeResult {
-  protocolVersion: string;
-  capabilities: ServerCapabilities;
-  serverInfo: Implementation;
-}
-
-/** Implementation information */
-export interface Implementation {
-  name: string;
-  version: string;
-}
-
-/** Client capabilities */
-export interface ClientCapabilities {
-  // Client can handle these features
-  readonly experimental?: Record<string, unknown>;
-  readonly roots?: { listChanged?: boolean };
-  readonly sampling?: Record<string, unknown>;
-}
-
-/** Server capabilities */
-export interface ServerCapabilities {
-  // Server provides these features
-  readonly experimental?: Record<string, unknown>;
-  readonly logging?: Record<string, unknown>;
-  readonly prompts?: { listChanged?: boolean };
-  readonly resources?: { subscribe?: boolean; listChanged?: boolean };
-  readonly tools?: { listChanged?: boolean };
-}
-
-// ============================================================================
-// MCP Tool Definitions
+// MCP Tool Definitions (kept for SDK use)
 // ============================================================================
 
 /** Tool definition for tool/list */
@@ -116,34 +37,6 @@ export interface ToolInputSchema {
   additionalProperties?: boolean;
 }
 
-/** Tool call request */
-export interface ToolCallRequest {
-  name: string;
-  arguments?: Record<string, unknown>;
-}
-
-/** Tool call result */
-export interface ToolCallResult {
-  content: ToolContent[];
-  isError?: boolean;
-}
-
-/** Tool content types */
-export type ToolContent = TextContent | ImageContent;
-
-/** Text content */
-export interface TextContent {
-  type: 'text';
-  text: string;
-}
-
-/** Image content */
-export interface ImageContent {
-  type: 'image';
-  data: string; // base64 encoded
-  mimeType: string;
-}
-
 // ============================================================================
 // MCP Tool List
 // ============================================================================
@@ -209,41 +102,9 @@ export const TOOL_DEFINITIONS: readonly Tool[] = [
 ] as const;
 
 // ============================================================================
-// MCP Methods
-// ============================================================================
-
-/** All MCP method names */
-export const MCP_METHODS = {
-  // Lifecycle
-  INITIALIZE: 'initialize',
-  INITIALIZED: 'notifications/initialized',
-  SHUTDOWN: 'shutdown',
-  EXIT: 'exit',
-
-  // Tools
-  TOOLS_LIST: 'tools/list',
-  TOOLS_CALL: 'tools/call',
-
-  // Logging
-  LOGGING_MESSAGE: 'notifications/message',
-
-  // Progress
-  PROGRESS: 'notifications/progress',
-} as const;
-
-// ============================================================================
-// Error Codes (Standard MCP + Custom)
+// Error Codes (MemHub Custom)
 // ============================================================================
 
-/** Standard JSON-RPC error codes */
-export const JSONRPC_ERROR_CODES = {
-  PARSE_ERROR: -32700,
-  INVALID_REQUEST: -32600,
-  METHOD_NOT_FOUND: -32601,
-  INVALID_PARAMS: -32602,
-  INTERNAL_ERROR: -32603,
-} as const;
-
 /** MemHub custom error codes */
 export const MEMHUB_ERROR_CODES = {
   NOT_FOUND: -32001,
@@ -252,9 +113,13 @@ export const MEMHUB_ERROR_CODES = {
   DUPLICATE_ERROR: -32004,
 } as const;
 
-/** Combined error codes */
+/** Combined error codes (includes JSON-RPC standard codes) */
 export const ERROR_CODES = {
-  ...JSONRPC_ERROR_CODES,
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
   ...MEMHUB_ERROR_CODES,
 } as const;
 
@@ -300,4 +165,4 @@ export type ToolInput<T extends ToolName> = T extends 'memory_load'
         category?: string;
         importance?: number;
       }
-    : never;
+    : never;

package/src/server/mcp-server.ts

@@ -1,36 +1,25 @@
 #!/usr/bin/env node
 /**
  * MCP Server - Model Context Protocol server implementation
- * Communicates via stdio
+ * Uses @modelcontextprotocol/sdk for protocol handling
  */
 
 import { readFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
-import type {
-  JsonRpcRequest,
-  JsonRpcResponse,
-  JsonRpcError,
-  RequestId,
-  InitializeParams,
-  InitializeResult,
-  ToolCallRequest,
-  ToolCallResult,
-  TextContent,
-} from '../contracts/mcp.js';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import {
-  MCP_PROTOCOL_VERSION,
-  SERVER_INFO,
-  TOOL_DEFINITIONS,
-  MCP_METHODS,
-  ERROR_CODES,
-} from '../contracts/mcp.js';
-import { ErrorCode } from '../contracts/types.js';
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
 import { MemoryService, ServiceError } from '../services/memory-service.js';
 import {
   MemoryLoadInputSchema,
   MemoryUpdateInputV2Schema,
 } from '../contracts/schemas.js';
+import { TOOL_DEFINITIONS, SERVER_INFO } from '../contracts/mcp.js';
+import { ErrorCode } from '../contracts/types.js';
 
 // Get package version
 const __filename = fileURLToPath(import.meta.url);
@@ -39,169 +28,40 @@ interface PackageJson {
   version?: string;
 }
 
-const packageJson = JSON.parse(
-  readFileSync(join(__dirname, '../../package.json'), 'utf-8')
-) as PackageJson;
+// npm package runtime: dist/src/server -> package root
+const packageJsonPath = join(__dirname, '../../../package.json');
+
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8')) as PackageJson;
 
 /**
- * MCP Server implementation
+ * Create McpServer instance using SDK
  */
-export class McpServer {
-  private readonly memoryService: MemoryService;
-
-  constructor() {
-    const storagePath = process.env.MEMHUB_STORAGE_PATH || './memories';
-    this.memoryService = new MemoryService({ storagePath });
-  }
-
-  /**
-   * Starts the MCP server and begins listening for requests on stdin
-   */
-  start(): void {
-    this.log('info', 'MemHub MCP Server starting...');
-
-    process.stdin.setEncoding('utf-8');
-
-    let buffer = '';
-
-    process.stdin.on('data', (chunk: string) => {
-      buffer += chunk;
-
-      // Process complete lines (JSON-RPC messages)
-      const lines = buffer.split('\n');
-      buffer = lines.pop() || ''; // Keep incomplete line in buffer
-
-      for (const line of lines) {
-        if (line.trim()) {
-          void this.handleMessage(line.trim());
-        }
-      }
-    });
-
-    process.stdin.on('end', () => {
-      this.log('info', 'Stdin closed, shutting down...');
-      process.exit(0);
-    });
-
-    process.on('SIGINT', () => {
-      this.log('info', 'Received SIGINT, shutting down...');
-      process.exit(0);
-    });
-
-    process.on('SIGTERM', () => {
-      this.log('info', 'Received SIGTERM, shutting down...');
-      process.exit(0);
-    });
-  }
-
-  /**
-   * Handles an incoming JSON-RPC message
-   *
-   * @param message - The JSON-RPC message string
-   */
-  private async handleMessage(message: string): Promise<void> {
-    let request: JsonRpcRequest | null = null;
-
-    try {
-      request = JSON.parse(message) as JsonRpcRequest;
-    } catch {
-      this.sendError(null, ERROR_CODES.PARSE_ERROR, 'Parse error: Invalid JSON');
-      return;
-    }
-
-    // Validate JSON-RPC request
-    if (request.jsonrpc !== '2.0' || !request.method) {
-      this.sendError(
-        request.id ?? null,
-        ERROR_CODES.INVALID_REQUEST,
-        'Invalid Request'
-      );
-      return;
-    }
-
-    try {
-      const result = await this.handleMethod(request.method, request.params);
-
-      // Send response (only for requests with id, not notifications)
-      if (request.id !== undefined) {
-        this.sendResponse(request.id, result);
-      }
-    } catch (error) {
-      this.handleError(request.id ?? null, error);
-    }
-  }
-
-  /**
-   * Handles a specific method call
-   *
-   * @param method - The method name
-   * @param params - The method parameters
-   * @returns The method result
-   */
-  private async handleMethod(
-    method: string,
-    params: unknown
-  ): Promise<unknown> {
-    switch (method) {
-      case MCP_METHODS.INITIALIZE:
-        return this.handleInitialize(params as InitializeParams);
-
-      case MCP_METHODS.INITIALIZED:
-        // Notification, no response needed
-        this.log('info', 'Client initialized');
-        return null;
-
-      case MCP_METHODS.SHUTDOWN:
-        return null;
-
-      case MCP_METHODS.EXIT:
-        process.exit(0);
-        return null;
-
-      case MCP_METHODS.TOOLS_LIST:
-        return { tools: TOOL_DEFINITIONS };
-
-      case MCP_METHODS.TOOLS_CALL:
-        return this.handleToolCall(params as ToolCallRequest);
-
-      default:
-        throw new ServiceError(
-          `Method not found: ${method}`,
-          ErrorCode.METHOD_NOT_FOUND
-        );
-    }
-  }
-
-  /**
-   * Handles the initialize method
-   *
-   * @param params - Initialize parameters
-   * @returns Initialize result
-   */
-  private handleInitialize(params: InitializeParams): InitializeResult {
-    this.log('info', `Client initializing: ${params.clientInfo.name} v${params.clientInfo.version}`);
-
-    return {
-      protocolVersion: MCP_PROTOCOL_VERSION,
+export function createMcpServer(): Server {
+  const storagePath = process.env.MEMHUB_STORAGE_PATH || './memories';
+  const memoryService = new MemoryService({ storagePath });
+
+  // Create server using SDK
+  const server = new Server(
+    {
+      name: SERVER_INFO.name,
+      version: packageJson.version || SERVER_INFO.version,
+    },
+    {
       capabilities: {
         tools: { listChanged: false },
         logging: {},
       },
-      serverInfo: {
-        name: SERVER_INFO.name,
-        version: packageJson.version || SERVER_INFO.version,
-      },
-    };
-  }
+    }
+  );
+
+  // Handle tools/list request
+  server.setRequestHandler(ListToolsRequestSchema, () => {
+    return { tools: TOOL_DEFINITIONS };
+  });
 
-  /**
-   * Handles tool calls
-   *
-   * @param request - Tool call request
-   * @returns Tool call result
-   */
-  private async handleToolCall(request: ToolCallRequest): Promise<ToolCallResult> {
-    const { name, arguments: args } = request;
+  // Handle tools/call request
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
 
     try {
       let result: unknown;
@@ -209,13 +69,13 @@ export class McpServer {
       switch (name) {
         case 'memory_load': {
           const input = MemoryLoadInputSchema.parse(args ?? {});
-          result = await this.memoryService.memoryLoad(input);
+          result = await memoryService.memoryLoad(input);
           break;
         }
 
         case 'memory_update': {
           const input = MemoryUpdateInputV2Schema.parse(args ?? {});
-          result = await this.memoryService.memoryUpdate(input);
+          result = await memoryService.memoryUpdate(input);
           break;
         }
 
@@ -229,9 +89,9 @@ export class McpServer {
       return {
         content: [
           {
-            type: 'text',
+            type: 'text' as const,
             text: JSON.stringify(result, null, 2),
-          } as TextContent,
+          },
         ],
       };
     } catch (error) {
@@ -239,115 +99,46 @@ export class McpServer {
         return {
           content: [
             {
-              type: 'text',
+              type: 'text' as const,
               text: JSON.stringify({ error: error.message }, null, 2),
-            } as TextContent,
+            },
           ],
           isError: true,
         };
       }
 
-      // Re-throw for generic error handling
-      throw error;
-    }
-  }
+      if (error instanceof Error && error.name === 'ZodError') {
+        return {
+          content: [
+            {
+              type: 'text' as const,
+              text: JSON.stringify({ error: `Invalid parameters: ${error.message}` }, null, 2),
+            },
+          ],
+          isError: true,
+        };
+      }
 
-  /**
-   * Handles errors and sends appropriate error response
-   *
-   * @param id - Request ID
-   * @param error - The error that occurred
-   */
-  private handleError(id: RequestId | null, error: unknown): void {
-    if (error instanceof ServiceError) {
-      this.sendError(id, error.code, error.message, error.data);
-    } else if (error instanceof Error && error.name === 'ZodError') {
-      this.sendError(
-        id,
-        ERROR_CODES.INVALID_PARAMS,
-        `Invalid parameters: ${error.message}`
-      );
-    } else {
-      this.sendError(
-        id,
-        ERROR_CODES.INTERNAL_ERROR,
-        `Internal error: ${error instanceof Error ? error.message : 'Unknown error'}`
-      );
+      // Re-throw for SDK error handling
+      throw error;
     }
-  }
-
-  /**
-   * Sends a JSON-RPC response
-   *
-   * @param id - Request ID
-   * @param result - Response result
-   */
-  private sendResponse(id: RequestId, result: unknown): void {
-    const response: JsonRpcResponse = {
-      jsonrpc: '2.0',
-      id,
-      result,
-    };
-    this.sendMessage(response);
-  }
-
-  /**
-   * Sends a JSON-RPC error
-   *
-   * @param id - Request ID
-   * @param code - Error code
-   * @param message - Error message
-   * @param data - Additional error data
-   */
-  private sendError(
-    id: RequestId | null,
-    code: number,
-    message: string,
-    data?: Record<string, unknown>
-  ): void {
-    const error: JsonRpcError = {
-      code,
-      message,
-      data,
-    };
+  });
 
-    const response: JsonRpcResponse = {
-      jsonrpc: '2.0',
-      id: id ?? null,
-      error,
-    };
-
-    this.sendMessage(response);
-  }
-
-  /**
-   * Sends a message to stdout
-   *
-   * @param message - The message to send
-   */
-  private sendMessage(message: JsonRpcResponse | JsonRpcRequest): void {
-    const json = JSON.stringify(message);
-    process.stdout.write(json + '\n');
-  }
+  return server;
+}
 
-  /**
-   * Logs a message
-   *
-   * @param level - Log level
-   * @param message - Log message
-   */
-  private log(level: 'debug' | 'info' | 'warn' | 'error', message: string): void {
-    const logLevel = process.env.MEMHUB_LOG_LEVEL || 'info';
-    const levels = { debug: 0, info: 1, warn: 2, error: 3 };
+/**
+ * Start the MCP server
+ */
+async function main(): Promise<void> {
+  const server = createMcpServer();
+  const transport = new StdioServerTransport();
 
-    if (levels[level] >= levels[logLevel as keyof typeof levels]) {
-      console.error(`[${level.toUpperCase()}] ${message}`);
-    }
-  }
+  await server.connect(transport);
+  console.error('MemHub MCP Server running on stdio');
 }
 
-// Start server if this file is run directly
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const server = new McpServer();
-  server.start();
-}
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});