deeper-cli 1.0.0

package/src/mcp/MCPClient.ts

@@ -0,0 +1,326 @@
+import { EventBus, Events } from '../core/eventbus.js';
+import { StdioTransport } from './StdioTransport.js';
+import { SSETransport } from './SSETransport.js';
+import { ToolAdapter } from './ToolAdapter.js';
+import { ResourceAdapter } from './ResourceAdapter.js';
+import type {
+  MCPServerConfig,
+  MCPTool,
+  MCPResource,
+  MCPTransport,
+  JSONRPCMessage,
+  JSONRPCResponse,
+} from './types.js';
+import type { Tool, ToolResult } from '../tools/tool-types.js';
+import { MCP_CONNECTION_TIMEOUT_MS } from '../core/constants.js';
+
+interface ServerConnection {
+  config: MCPServerConfig;
+  transport: MCPTransport;
+  tools: MCPTool[];
+  resources: MCPResource[];
+  connected: boolean;
+}
+
+export class MCPClient {
+  private servers = new Map<string, ServerConnection>();
+  private eventbus: EventBus;
+  private toolAdapter: ToolAdapter;
+  private resourceAdapter: ResourceAdapter;
+  private requestIdCounter = 0;
+
+  constructor(eventbus?: EventBus) {
+    this.eventbus = eventbus || new EventBus();
+    this.toolAdapter = new ToolAdapter(this);
+    this.resourceAdapter = new ResourceAdapter(this);
+  }
+
+  async connect(config: MCPServerConfig): Promise<void> {
+    if (this.servers.has(config.name)) {
+      await this.disconnect(config.name);
+    }
+
+    const transport: MCPTransport = config.type === 'stdio'
+      ? new StdioTransport()
+      : new SSETransport();
+
+    const connection: ServerConnection = {
+      config,
+      transport,
+      tools: [],
+      resources: [],
+      connected: false,
+    };
+
+    this.servers.set(config.name, connection);
+
+    try {
+      const connectPromise = transport.connect(config);
+      const timeoutPromise = new Promise<never>((_, reject) => {
+        setTimeout(() => reject(new Error(`Connection timeout: ${config.name}`)), MCP_CONNECTION_TIMEOUT_MS);
+      });
+
+      await Promise.race([connectPromise, timeoutPromise]);
+
+      connection.connected = true;
+
+      transport.onMessage((message: JSONRPCMessage) => {
+        this.handleMessage(config.name, message);
+      });
+
+      await this.initializeServer(config.name);
+
+      this.eventbus.emit(Events.MCP_CONNECTED, {
+        serverName: config.name,
+        type: config.type,
+      });
+    } catch (error) {
+      transport.disconnect();
+      this.servers.delete(config.name);
+
+      this.eventbus.emit(Events.MCP_ERROR, {
+        serverName: config.name,
+        error: error instanceof Error ? error.message : String(error),
+      });
+
+      throw error;
+    }
+  }
+
+  disconnect(name: string): void {
+    const connection = this.servers.get(name);
+    if (!connection) return;
+
+    connection.transport.disconnect();
+    connection.connected = false;
+    this.servers.delete(name);
+
+    this.eventbus.emit(Events.MCP_DISCONNECTED, {
+      serverName: name,
+    });
+  }
+
+  disconnectAll(): void {
+    for (const name of this.servers.keys()) {
+      this.disconnect(name);
+    }
+  }
+
+  listTools(serverName?: string): MCPTool[] {
+    if (serverName) {
+      const connection = this.servers.get(serverName);
+      return connection ? [...connection.tools] : [];
+    }
+
+    const allTools: MCPTool[] = [];
+    for (const [, conn] of this.servers) {
+      allTools.push(...conn.tools);
+    }
+    return allTools;
+  }
+
+  getAdaptedTools(): Tool[] {
+    const tools: Tool[] = [];
+    for (const [name, conn] of this.servers) {
+      tools.push(...this.toolAdapter.adaptBatch(conn.tools, name));
+    }
+    return tools;
+  }
+
+  async callTool(
+    serverName: string,
+    toolName: string,
+    args: Record<string, unknown>,
+  ): Promise<ToolResult> {
+    const connection = this.servers.get(serverName);
+    if (!connection) {
+      return {
+        success: false,
+        output: '',
+        error: `Server not connected: ${serverName}`,
+      };
+    }
+
+    if (!connection.connected) {
+      return {
+        success: false,
+        output: '',
+        error: `Server disconnected: ${serverName}`,
+      };
+    }
+
+    try {
+      const requestId = ++this.requestIdCounter;
+      const response = await this.sendRequest(connection, requestId, 'tools/call', {
+        name: toolName,
+        arguments: args,
+      });
+
+      const result = response.result as Record<string, unknown> | undefined;
+      const content = result?.content;
+
+      if (Array.isArray(content)) {
+        const textParts = content
+          .filter((c: unknown) => {
+            const item = c as Record<string, unknown>;
+            return item?.type === 'text' && typeof item?.text === 'string';
+          })
+          .map((c: unknown) => (c as Record<string, string>).text);
+
+        return {
+          success: true,
+          output: textParts.join('\n'),
+        };
+      }
+
+      return {
+        success: true,
+        output: typeof content === 'string' ? content : JSON.stringify(content),
+      };
+    } catch (error) {
+      const errMsg = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        output: '',
+        error: errMsg,
+      };
+    }
+  }
+
+  async listResources(serverName: string): Promise<MCPResource[]> {
+    const connection = this.servers.get(serverName);
+    if (!connection) return [];
+
+    try {
+      const requestId = ++this.requestIdCounter;
+      const response = await this.sendRequest(connection, requestId, 'resources/list', {});
+
+      const result = response.result as Record<string, unknown> | undefined;
+      const resources = result?.resources;
+
+      if (Array.isArray(resources)) {
+        return resources as MCPResource[];
+      }
+
+      return [];
+    } catch {
+      return [];
+    }
+  }
+
+  async readResource(serverName: string, uri: string): Promise<string> {
+    const connection = this.servers.get(serverName);
+    if (!connection) {
+      throw new Error(`Server not connected: ${serverName}`);
+    }
+
+    const requestId = ++this.requestIdCounter;
+    const response = await this.sendRequest(connection, requestId, 'resources/read', { uri });
+
+    const result = response.result as Record<string, unknown> | undefined;
+    const contents = result?.contents;
+
+    if (Array.isArray(contents)) {
+      const textParts = contents
+        .filter((c: unknown) => {
+          const item = c as Record<string, unknown>;
+          return typeof item?.text === 'string';
+        })
+        .map((c: unknown) => (c as Record<string, string>).text);
+
+      return textParts.join('\n');
+    }
+
+    return JSON.stringify(contents);
+  }
+
+  isConnected(name: string): boolean {
+    const connection = this.servers.get(name);
+    return connection ? connection.connected : false;
+  }
+
+  getConnectedServers(): string[] {
+    const names: string[] = [];
+    for (const [name, conn] of this.servers) {
+      if (conn.connected) {
+        names.push(name);
+      }
+    }
+    return names;
+  }
+
+  private async initializeServer(serverName: string): Promise<void> {
+    const connection = this.servers.get(serverName);
+    if (!connection) return;
+
+    const initRequestId = ++this.requestIdCounter;
+    const initResponse = await this.sendRequest(connection, initRequestId, 'initialize', {
+      protocolVersion: '2024-11-18',
+      capabilities: {
+        tools: {},
+        resources: {},
+      },
+      clientInfo: {
+        name: 'DeeperCode',
+        version: '1.0.0',
+      },
+    });
+
+    const notifyMessage = {
+      jsonrpc: '2.0' as const,
+      method: 'notifications/initialized',
+    };
+    await connection.transport.send(notifyMessage);
+
+    const toolsRequestId = ++this.requestIdCounter;
+    const toolsResponse = await this.sendRequest(connection, toolsRequestId, 'tools/list', {});
+
+    const toolsResult = toolsResponse.result as Record<string, unknown> | undefined;
+    if (toolsResult?.tools && Array.isArray(toolsResult.tools)) {
+      connection.tools = toolsResult.tools as MCPTool[];
+    }
+
+    this.eventbus.emit(Events.MCP_TOOLS_DISCOVERED, {
+      serverName,
+      toolCount: connection.tools.length,
+      tools: connection.tools.map((t) => t.name),
+    });
+  }
+
+  private async sendRequest(
+    connection: ServerConnection,
+    requestId: number,
+    method: string,
+    params: Record<string, unknown>,
+    timeoutMs: number = 30000,
+  ): Promise<JSONRPCResponse> {
+    const request = {
+      jsonrpc: '2.0' as const,
+      id: requestId,
+      method,
+      params,
+    };
+
+    const responsePromise = new Promise<JSONRPCResponse>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        cleanup();
+        reject(new Error(`Request timeout: ${method}`));
+      }, timeoutMs);
+
+      const cleanup = connection.transport.onMessage((message: JSONRPCMessage) => {
+        if ('id' in message && message.id === requestId) {
+          clearTimeout(timeout);
+          cleanup();
+          resolve(message as JSONRPCResponse);
+        }
+      });
+    });
+
+    await connection.transport.send(request);
+    return responsePromise;
+  }
+
+  private handleMessage(_serverName: string, _message: JSONRPCMessage): void {
+    // Messages are handled through the request/response pattern in sendRequest
+  }
+}

package/src/mcp/ResourceAdapter.ts

@@ -0,0 +1,58 @@
+import type { Tool, ToolResult } from '../tools/tool-types.js';
+import type { MCPResource } from './types.js';
+import type { MCPClient } from './MCPClient.js';
+
+export class ResourceAdapter {
+  private client: MCPClient;
+
+  constructor(client: MCPClient) {
+    this.client = client;
+  }
+
+  async readResource(serverName: string, uri: string): Promise<string> {
+    const content = await this.client.readResource(serverName, uri);
+    return content;
+  }
+
+  async listResources(serverName: string): Promise<MCPResource[]> {
+    return this.client.listResources(serverName);
+  }
+
+  createResourceTools(resources: MCPResource[], serverName: string): Tool[] {
+    return resources.map((resource) => this.adaptResource(resource, serverName));
+  }
+
+  private adaptResource(resource: MCPResource, serverName: string): Tool {
+    const adaptedName = `mcp:${serverName}:resource:${resource.name}`;
+
+    return {
+      name: adaptedName,
+      description: `[MCP:${serverName}] Read resource: ${resource.name} (${resource.uri})`,
+      category: 'system',
+      parameters: {
+        type: 'object',
+        properties: {},
+        required: [],
+      },
+      dangerous: false,
+      requiresApproval: false,
+      execute: async (_params: Record<string, unknown>, _signal?: AbortSignal): Promise<ToolResult> => {
+        try {
+          const content = await this.client.readResource(serverName, resource.uri);
+          return {
+            success: true,
+            output: content,
+            metadata: { uri: resource.uri, mimeType: resource.mimeType },
+          };
+        } catch (error) {
+          const errMsg = error instanceof Error ? error.message : String(error);
+          return {
+            success: false,
+            output: '',
+            error: `MCP resource error [${serverName}/${resource.name}]: ${errMsg}`,
+          };
+        }
+      },
+    };
+  }
+}

package/src/mcp/SSETransport.ts

@@ -0,0 +1,133 @@
+import type { MCPServerConfig, JSONRPCMessage, MCPTransport } from './types.js';
+
+export class SSETransport implements MCPTransport {
+  private url: string = '';
+  private headers: Record<string, string> = {};
+  private messageHandlers: Array<(message: JSONRPCMessage) => void> = [];
+  private connected: boolean = false;
+  private abortController: AbortController | null = null;
+
+  async connect(config: MCPServerConfig): Promise<void> {
+    if (!config.url) {
+      throw new Error('SSETransport requires a URL');
+    }
+
+    this.url = config.url;
+    this.headers = config.headers || {};
+    this.abortController = new AbortController();
+
+    this.connected = true;
+
+    this.establishSSEConnection();
+  }
+
+  private async establishSSEConnection(): Promise<void> {
+    try {
+      const response = await fetch(this.url, {
+        method: 'GET',
+        headers: {
+          Accept: 'text/event-stream',
+          ...this.headers,
+        },
+        signal: this.abortController!.signal,
+      });
+
+      if (!response.ok) {
+        throw new Error(`SSE connection failed: ${response.status} ${response.statusText}`);
+      }
+
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new Error('SSE response has no readable body');
+      }
+
+      const decoder = new TextDecoder();
+      let buffer = '';
+
+      while (this.connected) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        let eventData = '';
+        for (const line of lines) {
+          if (line.startsWith('data: ')) {
+            eventData += line.slice(6);
+          } else if (line === '' && eventData) {
+            try {
+              const message = JSON.parse(eventData) as JSONRPCMessage;
+              for (const handler of this.messageHandlers) {
+                handler(message);
+              }
+            } catch {
+              // Ignore non-JSON SSE data
+            }
+            eventData = '';
+          }
+        }
+      }
+    } catch (error) {
+      if (error instanceof DOMException && error.name === 'AbortError') {
+        return;
+      }
+      this.connected = false;
+      for (const handler of this.messageHandlers) {
+        handler({
+          jsonrpc: '2.0',
+          method: 'error',
+          params: { message: String(error) },
+        });
+      }
+    }
+  }
+
+  async send(message: JSONRPCMessage): Promise<void> {
+    if (!this.connected) {
+      throw new Error('SSETransport not connected');
+    }
+
+    const response = await fetch(this.url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...this.headers,
+      },
+      body: JSON.stringify(message),
+      signal: this.abortController!.signal,
+    });
+
+    if (!response.ok) {
+      throw new Error(`SSE POST failed: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json() as JSONRPCMessage;
+    for (const handler of this.messageHandlers) {
+      handler(data);
+    }
+  }
+
+  onMessage(handler: (message: JSONRPCMessage) => void): () => void {
+    this.messageHandlers.push(handler);
+    return () => {
+      const idx = this.messageHandlers.indexOf(handler);
+      if (idx !== -1) {
+        this.messageHandlers.splice(idx, 1);
+      }
+    };
+  }
+
+  disconnect(): void {
+    this.connected = false;
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+  }
+
+  isConnected(): boolean {
+    return this.connected;
+  }
+}

package/src/mcp/StdioTransport.ts

@@ -0,0 +1,116 @@
+import { spawn } from 'node:child_process';
+import type { ChildProcess } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import type { MCPServerConfig, JSONRPCMessage, MCPTransport } from './types.js';
+
+export class StdioTransport implements MCPTransport {
+  private process: ChildProcess | null = null;
+  private messageHandlers: Array<(message: JSONRPCMessage) => void> = [];
+  private connected: boolean = false;
+  private buffer: string = '';
+
+  async connect(config: MCPServerConfig): Promise<void> {
+    if (!config.command) {
+      throw new Error('StdioTransport requires a command');
+    }
+
+    const env = {
+      ...process.env,
+      ...config.env,
+    };
+
+    this.process = spawn(config.command, config.args || [], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env,
+      shell: true,
+    });
+
+    const rl = createInterface({ input: this.process.stdout! });
+
+    rl.on('line', (line: string) => {
+      try {
+        const message = JSON.parse(line) as JSONRPCMessage;
+        for (const handler of this.messageHandlers) {
+          handler(message);
+        }
+      } catch {
+        this.buffer += line;
+      }
+    });
+
+    this.process.stderr?.on('data', (data: Buffer) => {
+      const text = data.toString();
+      try {
+        const message = JSON.parse(text) as JSONRPCMessage;
+        for (const handler of this.messageHandlers) {
+          handler(message);
+        }
+      } catch {
+        // MCP stderr is for logging, not JSON-RPC
+      }
+    });
+
+    this.process.on('exit', (code) => {
+      this.connected = false;
+      if (code !== 0 && code !== null) {
+        for (const handler of this.messageHandlers) {
+          handler({
+            jsonrpc: '2.0',
+            method: 'exit',
+            params: { code },
+          });
+        }
+      }
+    });
+
+    this.process.on('error', (err) => {
+      this.connected = false;
+      for (const handler of this.messageHandlers) {
+        handler({
+          jsonrpc: '2.0',
+          method: 'error',
+          params: { message: err.message },
+        });
+      }
+    });
+
+    this.connected = true;
+  }
+
+  async send(message: JSONRPCMessage): Promise<void> {
+    if (!this.process || !this.connected) {
+      throw new Error('StdioTransport not connected');
+    }
+
+    const line = JSON.stringify(message) + '\n';
+    await new Promise<void>((resolve, reject) => {
+      this.process!.stdin!.write(line, (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+
+  onMessage(handler: (message: JSONRPCMessage) => void): () => void {
+    this.messageHandlers.push(handler);
+    return () => {
+      const idx = this.messageHandlers.indexOf(handler);
+      if (idx !== -1) {
+        this.messageHandlers.splice(idx, 1);
+      }
+    };
+  }
+
+  disconnect(): void {
+    if (this.process) {
+      this.process.stdin?.end();
+      this.process.kill();
+      this.process = null;
+    }
+    this.connected = false;
+  }
+
+  isConnected(): boolean {
+    return this.connected && this.process !== null && !this.process.killed;
+  }
+}

package/src/mcp/ToolAdapter.ts

@@ -0,0 +1,71 @@
+import type { Tool, ToolResult } from '../tools/tool-types.js';
+import type { MCPTool } from './types.js';
+import type { MCPClient } from './MCPClient.js';
+
+export class ToolAdapter {
+  private client: MCPClient;
+
+  constructor(client: MCPClient) {
+    this.client = client;
+  }
+
+  adapt(mcpTool: MCPTool, serverName: string): Tool {
+    const adaptedName = `mcp:${serverName}:${mcpTool.name}`;
+
+    const tool: Tool = {
+      name: adaptedName,
+      description: `[MCP:${serverName}] ${mcpTool.description}`,
+      category: this.inferCategory(mcpTool) as string,
+      parameters: mcpTool.inputSchema,
+      dangerous: false,
+      requiresApproval: false,
+      execute: async (params: Record<string, unknown>, signal?: AbortSignal): Promise<ToolResult> => {
+        try {
+          const result = await this.client.callTool(serverName, mcpTool.name, params);
+          return result;
+        } catch (error) {
+          const errMsg = error instanceof Error ? error.message : String(error);
+          return {
+            success: false,
+            output: '',
+            error: `MCP tool error [${serverName}/${mcpTool.name}]: ${errMsg}`,
+          };
+        }
+      },
+    };
+
+    return tool;
+  }
+
+  adaptBatch(mcpTools: MCPTool[], serverName: string): Tool[] {
+    return mcpTools.map((t) => this.adapt(t, serverName));
+  }
+
+  private inferCategory(mcpTool: MCPTool): string {
+    const desc = (mcpTool.description + ' ' + mcpTool.name).toLowerCase();
+
+    if (desc.includes('file') || desc.includes('dir') || desc.includes('path')) {
+      return 'filesystem';
+    }
+    if (desc.includes('search') || desc.includes('find') || desc.includes('query')) {
+      return 'search';
+    }
+    if (desc.includes('shell') || desc.includes('command') || desc.includes('exec')) {
+      return 'shell';
+    }
+    if (desc.includes('http') || desc.includes('api') || desc.includes('fetch') || desc.includes('url')) {
+      return 'network';
+    }
+    if (desc.includes('code') || desc.includes('lint') || desc.includes('compile')) {
+      return 'code';
+    }
+    if (desc.includes('db') || desc.includes('sql') || desc.includes('database')) {
+      return 'database';
+    }
+    if (desc.includes('security') || desc.includes('auth') || desc.includes('token')) {
+      return 'security';
+    }
+
+    return 'system';
+  }
+}