@miphamai/cli 0.2.3

package/src/mcp/protocol.ts

@@ -0,0 +1,104 @@
+import type {
+  InitializeResult,
+  ToolDefinition,
+  ToolCallResult,
+  ResourceDefinition,
+  ResourceReadResult,
+} from './types'
+import { StdioTransport } from './transport'
+
+const MCP_VERSION = '2024-11-05'
+
+/**
+ * MCP protocol layer — implements the initialize/tools/resources
+ * lifecycle on top of a StdioTransport.
+ */
+export class McpProtocol {
+  private serverCapabilities: {
+    tools?: { listChanged?: boolean }
+    resources?: { subscribe?: boolean; listChanged?: boolean }
+  } = {}
+
+  constructor(private transport: StdioTransport) {}
+
+  async initialize(
+    serverCommand: string,
+    serverArgs: string[],
+    env?: Record<string, string>,
+  ): Promise<InitializeResult> {
+    // Start transport
+    await this.transport.start(serverCommand, serverArgs, env)
+
+    // Send initialize request
+    const result = (await this.transport.sendRequest('initialize', {
+      protocolVersion: MCP_VERSION,
+      capabilities: {
+        tools: {},
+        resources: {},
+      },
+      clientInfo: {
+        name: 'Mipham Code',
+        version: '0.2.0',
+      },
+    })) as InitializeResult
+
+    // Send initialized notification
+    this.transport.sendNotification('notifications/initialized')
+
+    this.serverCapabilities = result.capabilities
+
+    return result
+  }
+
+  async listTools(): Promise<ToolDefinition[]> {
+    const result = (await this.transport.sendRequest('tools/list')) as { tools: ToolDefinition[] }
+    return result.tools || []
+  }
+
+  async callTool(name: string, args?: Record<string, unknown>): Promise<ToolCallResult> {
+    const result = (await this.transport.sendRequest('tools/call', {
+      name,
+      arguments: args || {},
+    })) as ToolCallResult
+    return result
+  }
+
+  async listResources(): Promise<ResourceDefinition[]> {
+    if (!this.serverCapabilities.resources) {
+      return []
+    }
+    const result = (await this.transport.sendRequest('resources/list')) as {
+      resources: ResourceDefinition[]
+    }
+    return result.resources || []
+  }
+
+  async readResource(uri: string): Promise<ResourceReadResult> {
+    const result = (await this.transport.sendRequest('resources/read', {
+      uri,
+    })) as ResourceReadResult
+    return result
+  }
+
+  onNotification(handler: (method: string, params?: Record<string, unknown>) => void): void {
+    this.transport.onNotification((notification) => {
+      handler(notification.method, notification.params)
+    })
+  }
+
+  hasTools(): boolean {
+    return !!this.serverCapabilities.tools
+  }
+
+  hasResources(): boolean {
+    return !!this.serverCapabilities.resources
+  }
+
+  getCapabilities() {
+    return { ...this.serverCapabilities }
+  }
+
+  async close(): Promise<void> {
+    await this.transport.close()
+  }
+}

package/src/mcp/transport.ts

@@ -0,0 +1,169 @@
+import { spawn, type ChildProcess } from 'node:child_process'
+import type { JsonRpcRequest, JsonRpcResponse, JsonRpcNotification } from './types'
+
+type ResponseHandler = (response: JsonRpcResponse) => void
+type NotificationHandler = (notification: JsonRpcNotification) => void
+
+const REQUEST_TIMEOUT_MS = 30_000
+
+/**
+ * MCP stdio transport — spawns a subprocess and communicates via
+ * newline-delimited JSON-RPC 2.0 messages on stdin/stdout.
+ *
+ * Uses Node.js child_process for portability across Bun and Node runtimes.
+ */
+export class StdioTransport {
+  private proc: ChildProcess | null = null
+  private msgId = 0
+  private pending = new Map<
+    number,
+    {
+      resolve: (v: unknown) => void
+      reject: (e: Error) => void
+      timer: ReturnType<typeof setTimeout>
+    }
+  >()
+  private notificationHandlers: NotificationHandler[] = []
+  private buffer = ''
+  private closed = false
+
+  async start(command: string, args: string[], env?: Record<string, string>): Promise<void> {
+    this.closed = false
+
+    const procEnv: Record<string, string> = {
+      ...(process.env as Record<string, string>),
+      ...env,
+    }
+
+    return new Promise((resolve, reject) => {
+      const child = spawn(command, args, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: procEnv,
+      })
+
+      child.on('error', (err) => {
+        this.closed = true
+        reject(err)
+      })
+
+      child.stdout?.on('data', (data: Buffer) => {
+        this.buffer += data.toString()
+        const lines = this.buffer.split('\n')
+        this.buffer = lines.pop() || ''
+
+        for (const line of lines) {
+          const trimmed = line.trim()
+          if (!trimmed) continue
+
+          try {
+            const msg = JSON.parse(trimmed)
+
+            // Check if it's a response (has id and result/error)
+            if (typeof msg.id === 'number' && ('result' in msg || 'error' in msg)) {
+              const response = msg as JsonRpcResponse
+              const entry = this.pending.get(response.id)
+              if (entry) {
+                clearTimeout(entry.timer)
+                this.pending.delete(response.id)
+                if (response.error) {
+                  entry.reject(
+                    new Error(`MCP error ${response.error.code}: ${response.error.message}`),
+                  )
+                } else {
+                  entry.resolve(response.result)
+                }
+              }
+            } else if (msg.method && msg.id === undefined) {
+              // Notification — no id field
+              for (const handler of this.notificationHandlers) {
+                handler(msg as JsonRpcNotification)
+              }
+            }
+          } catch {
+            // Skip unparseable lines
+          }
+        }
+      })
+
+      child.on('close', () => {
+        this.closed = true
+        // Reject any remaining pending requests
+        for (const [, entry] of this.pending) {
+          clearTimeout(entry.timer)
+          entry.reject(new Error('Transport closed'))
+        }
+        this.pending.clear()
+      })
+
+      this.proc = child
+      resolve()
+    })
+  }
+
+  async sendRequest(method: string, params?: Record<string, unknown>): Promise<unknown> {
+    if (!this.proc || this.closed) {
+      throw new Error('Transport not connected')
+    }
+
+    const id = ++this.msgId
+    const request: JsonRpcRequest = {
+      jsonrpc: '2.0',
+      id,
+      method,
+      ...(params ? { params } : {}),
+    }
+
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id)
+        reject(new Error(`MCP request timeout: ${method} (${REQUEST_TIMEOUT_MS}ms)`))
+      }, REQUEST_TIMEOUT_MS)
+
+      this.pending.set(id, { resolve, reject, timer })
+
+      // Write to stdin
+      this.proc!.stdin!.write(JSON.stringify(request) + '\n')
+    })
+  }
+
+  sendNotification(method: string, params?: Record<string, unknown>): void {
+    if (!this.proc || this.closed) return
+
+    const notification: JsonRpcNotification = {
+      jsonrpc: '2.0',
+      method,
+      ...(params ? { params } : {}),
+    }
+
+    this.proc.stdin!.write(JSON.stringify(notification) + '\n')
+  }
+
+  onNotification(handler: NotificationHandler): void {
+    this.notificationHandlers.push(handler)
+  }
+
+  async close(): Promise<void> {
+    this.closed = true
+
+    // Reject all pending requests
+    for (const [, entry] of this.pending) {
+      clearTimeout(entry.timer)
+      entry.reject(new Error('Transport closed'))
+    }
+    this.pending.clear()
+
+    if (this.proc) {
+      try {
+        this.proc.stdin?.end()
+      } catch {
+        /* ignore */
+      }
+      this.proc.kill()
+      this.proc = null
+    }
+  }
+
+  isConnected(): boolean {
+    return this.proc !== null && !this.closed
+  }
+}

package/src/mcp/types.ts

@@ -0,0 +1,112 @@
+// ── JSON-RPC 2.0 ──
+
+export interface JsonRpcRequest {
+  jsonrpc: '2.0'
+  id: number
+  method: string
+  params?: Record<string, unknown>
+}
+
+export interface JsonRpcResponse {
+  jsonrpc: '2.0'
+  id: number
+  result?: unknown
+  error?: JsonRpcError
+}
+
+export interface JsonRpcNotification {
+  jsonrpc: '2.0'
+  method: string
+  params?: Record<string, unknown>
+}
+
+export interface JsonRpcError {
+  code: number
+  message: string
+  data?: unknown
+}
+
+export type JsonRpcMessage = JsonRpcRequest | JsonRpcResponse | JsonRpcNotification
+
+// ── MCP Initialize ──
+
+export interface InitializeRequest {
+  protocolVersion: string
+  capabilities: ClientCapabilities
+  clientInfo: { name: string; version: string }
+}
+
+export interface ClientCapabilities {
+  tools?: Record<string, unknown>
+  resources?: Record<string, unknown>
+}
+
+export interface InitializeResult {
+  protocolVersion: string
+  capabilities: ServerCapabilities
+  serverInfo: { name: string; version: string }
+}
+
+export interface ServerCapabilities {
+  tools?: { listChanged?: boolean }
+  resources?: { subscribe?: boolean; listChanged?: boolean }
+}
+
+// ── MCP Tools ──
+
+export interface ToolDefinition {
+  name: string
+  description?: string
+  inputSchema: {
+    type: 'object'
+    properties?: Record<string, unknown>
+    required?: string[]
+  }
+}
+
+export interface ToolCallParams {
+  name: string
+  arguments?: Record<string, unknown>
+}
+
+export interface ToolCallContent {
+  type: 'text' | 'image' | 'resource'
+  text?: string
+  data?: string
+  mimeType?: string
+}
+
+export interface ToolCallResult {
+  content: ToolCallContent[]
+  isError?: boolean
+}
+
+// ── MCP Resources ──
+
+export interface ResourceDefinition {
+  uri: string
+  name: string
+  description?: string
+  mimeType?: string
+}
+
+export interface ResourceReadResult {
+  contents: Array<{
+    uri: string
+    mimeType?: string
+    text?: string
+    blob?: string
+  }>
+}
+
+// ── Connection State ──
+
+export type ConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'error'
+
+export interface ConnectionInfo {
+  config: { name: string; command: string; args: string[] }
+  status: ConnectionStatus
+  tools: ToolDefinition[]
+  error?: string
+  serverInfo?: { name: string; version: string }
+}

package/src/providers/anthropic.ts

@@ -0,0 +1,286 @@
+import type {
+  ProviderConfig,
+  ModelInfo,
+  Message,
+  StreamChunk,
+  ContentBlock,
+} from '../shared/index.ts'
+import type { ProviderInstance, ChatRequest } from './registry'
+
+interface AnthropicContentBlock {
+  type: string
+  text?: string
+  id?: string
+  name?: string
+  input?: Record<string, unknown>
+  source?: { type: string; media_type: string; data: string }
+  tool_use_id?: string
+  content?: string | AnthropicContentBlock[]
+}
+
+interface AnthropicSSEEvent {
+  type: string
+  message?: {
+    content: AnthropicContentBlock[]
+    stop_reason: string | null
+  }
+  index?: number
+  content_block?: AnthropicContentBlock
+  delta?: {
+    type: string
+    text?: string
+    partial_json?: string
+  }
+  error?: { type: string; message: string }
+  usage?: { input_tokens: number; output_tokens: number }
+}
+
+export class AnthropicProvider implements ProviderInstance {
+  private baseUrl = 'https://api.anthropic.com/v1'
+  private anthropicVersion = '2023-06-01'
+
+  constructor(public config: ProviderConfig) {}
+
+  async *chat(req: ChatRequest): AsyncGenerator<StreamChunk> {
+    const apiKey = this.resolveApiKey(this.config.apiKey)
+
+    // Collect accumulated tool use input (Anthropic streams tool input as partial JSON deltas)
+    let currentToolName = ''
+    let currentToolId = ''
+    let accumulatedToolInput = ''
+
+    const body: Record<string, unknown> = {
+      model: req.model,
+      max_tokens: req.maxTokens || 4096,
+      stream: true,
+      messages: this.convertMessages(req.messages),
+    }
+
+    if (req.systemPrompt) {
+      body.system = req.systemPrompt
+    }
+
+    if (req.temperature !== undefined) {
+      body.temperature = req.temperature
+    }
+
+    if (req.tools && req.tools.length > 0) {
+      body.tools = req.tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        input_schema: t.parameters || t.input_schema || { type: 'object', properties: {} },
+      }))
+    }
+
+    const response = await fetch(`${this.baseUrl}/messages`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': this.anthropicVersion,
+        'anthropic-beta': 'prompt-caching-2024-07-31',
+      },
+      body: JSON.stringify(body),
+    })
+
+    if (!response.ok) {
+      const errText = await response.text()
+      yield { type: 'error', error: `Anthropic API error ${response.status}: ${errText}` }
+      return
+    }
+
+    if (!response.body) {
+      yield { type: 'error', error: 'No response body' }
+      return
+    }
+
+    const reader = response.body.getReader()
+    const decoder = new TextDecoder()
+    let buffer = ''
+
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+
+      buffer += decoder.decode(value, { stream: true })
+      const lines = buffer.split('\n')
+      buffer = lines.pop() || ''
+
+      for (const line of lines) {
+        const trimmed = line.trim()
+        if (!trimmed || !trimmed.startsWith('data: ')) continue
+        const data = trimmed.slice(6)
+
+        try {
+          const event = JSON.parse(data) as AnthropicSSEEvent
+
+          switch (event.type) {
+            case 'content_block_start': {
+              const cb = event.content_block
+              if (!cb) continue
+
+              if (cb.type === 'tool_use') {
+                currentToolName = cb.name || ''
+                currentToolId = cb.id || ''
+                accumulatedToolInput = ''
+              }
+              break
+            }
+
+            case 'content_block_delta': {
+              const delta = event.delta
+              if (!delta) continue
+
+              if (delta.type === 'text_delta' && delta.text) {
+                yield { type: 'text', content: delta.text }
+              }
+
+              if (delta.type === 'input_json_delta' && delta.partial_json) {
+                accumulatedToolInput += delta.partial_json
+              }
+              break
+            }
+
+            case 'content_block_stop': {
+              if (currentToolId && currentToolName && accumulatedToolInput) {
+                let parsedInput: Record<string, unknown> = {}
+                try {
+                  parsedInput = JSON.parse(accumulatedToolInput)
+                } catch {
+                  parsedInput = { _raw: accumulatedToolInput }
+                }
+
+                yield {
+                  type: 'tool_use',
+                  toolUse: {
+                    type: 'tool_use',
+                    id: currentToolId,
+                    name: currentToolName,
+                    input: parsedInput,
+                  },
+                }
+
+                // Reset accumulator
+                currentToolName = ''
+                currentToolId = ''
+                accumulatedToolInput = ''
+              }
+              break
+            }
+
+            case 'message_delta': {
+              // Contains stop_reason and usage info
+              if (event.delta?.type === 'input_json_delta' && event.delta.partial_json) {
+                accumulatedToolInput += event.delta.partial_json
+              }
+              break
+            }
+
+            case 'message_stop': {
+              yield { type: 'stop' }
+              return
+            }
+
+            case 'error': {
+              yield { type: 'error', error: event.error?.message || 'Unknown Anthropic error' }
+              return
+            }
+          }
+        } catch {
+          // Skip unparseable SSE events
+        }
+      }
+    }
+
+    yield { type: 'stop' }
+  }
+
+  async listModels(): Promise<ModelInfo[]> {
+    return this.config.models.filter((m) => m.status === 'active')
+  }
+
+  async healthCheck(): Promise<boolean> {
+    // Anthropic doesn't have a public models list endpoint
+    // Use a lightweight check — verify API key format exists
+    const apiKey = this.resolveApiKey(this.config.apiKey)
+    return apiKey.length > 0 && apiKey.startsWith('sk-ant-')
+  }
+
+  private convertMessages(messages: Message[]): Record<string, unknown>[] {
+    const result: Record<string, unknown>[] = []
+
+    for (const msg of messages) {
+      // Anthropic does not allow 'system' role in messages array — it goes to top-level system param
+      if (msg.role === 'system') continue
+
+      if (typeof msg.content === 'string') {
+        result.push({
+          role: msg.role,
+          content: [{ type: 'text', text: msg.content }],
+        })
+      } else {
+        const blocks = (msg.content as ContentBlock[]).map((block) => {
+          switch (block.type) {
+            case 'text':
+              return { type: 'text', text: block.text }
+
+            case 'image_url': {
+              const url = block.image_url.url
+              // Handle data URIs (base64) and regular URLs
+              if (url.startsWith('data:')) {
+                const [header, data] = url.split(',')
+                const mediaType = header?.match(/data:(image\/\w+);base64/)?.[1] || 'image/png'
+                return {
+                  type: 'image',
+                  source: {
+                    type: 'base64',
+                    media_type: mediaType,
+                    data: data || '',
+                  },
+                }
+              }
+              // For regular URLs, pass as image_url (Anthropic might not support directly)
+              return {
+                type: 'image',
+                source: {
+                  type: 'url',
+                  url,
+                },
+              }
+            }
+
+            case 'tool_use':
+              return {
+                type: 'tool_use',
+                id: block.id,
+                name: block.name,
+                input: block.input,
+              }
+
+            case 'tool_result':
+              return {
+                type: 'tool_result',
+                tool_use_id: block.tool_use_id,
+                content: block.content,
+              }
+
+            default:
+              return { type: 'text', text: '' }
+          }
+        })
+
+        result.push({ role: msg.role, content: blocks })
+      }
+    }
+
+    return result
+  }
+
+  private resolveApiKey(keyTemplate: string): string {
+    const match = keyTemplate.match(/^\$\{(.+)\}$/)
+    if (match?.[1]) {
+      return process.env[match[1]] || ''
+    }
+    return keyTemplate
+  }
+}

package/src/providers/bootstrap.ts

@@ -0,0 +1,28 @@
+import type { ProviderConfig } from '../shared/index.ts'
+import { ProviderRegistry } from './registry'
+import { OpenAICompatProvider } from './openai-compat'
+import { AnthropicProvider } from './anthropic'
+
+export function bootstrapProviders(
+  configs: ProviderConfig[],
+  defaultProvider: string,
+  defaultModel: string,
+): ProviderRegistry {
+  const registry = new ProviderRegistry(configs, defaultProvider, defaultModel)
+
+  for (const config of configs) {
+    if (config.status === 'upcoming') continue
+
+    switch (config.protocol) {
+      case 'openai-compatible':
+        registry.register(config.id, new OpenAICompatProvider(config))
+        break
+      case 'anthropic':
+        registry.register(config.id, new AnthropicProvider(config))
+        break
+      // custom protocol providers must be registered manually via registry.register()
+    }
+  }
+
+  return registry
+}