@heysalad/cheri-cli 0.10.0 → 1.1.0

package/src/lib/mcp/client.js

@@ -0,0 +1,258 @@
+// MCP (Model Context Protocol) client
+// Connects to MCP servers via stdio transport, discovers tools, and calls them
+import { spawn } from "child_process";
+import { log } from "../logger.js";
+
+const JSONRPC_VERSION = "2.0";
+let requestId = 0;
+
+/**
+ * MCP Server connection
+ */
+export class McpServer {
+  constructor(name, command, args = [], env = {}) {
+    this.name = name;
+    this.command = command;
+    this.args = args;
+    this.env = { ...process.env, ...env };
+    this.process = null;
+    this.tools = [];
+    this.resources = [];
+    this.pendingRequests = new Map();
+    this._buffer = "";
+  }
+
+  async connect() {
+    return new Promise((resolve, reject) => {
+      this.process = spawn(this.command, this.args, {
+        env: this.env,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+
+      this.process.stdout.on("data", (data) => {
+        this._buffer += data.toString();
+        this._processBuffer();
+      });
+
+      this.process.stderr.on("data", (data) => {
+        log.dim(`[mcp:${this.name}] ${data.toString().trim()}`);
+      });
+
+      this.process.on("error", (err) => {
+        reject(new Error(`MCP server ${this.name} failed to start: ${err.message}`));
+      });
+
+      this.process.on("close", (code) => {
+        for (const [, { reject: r }] of this.pendingRequests) {
+          r(new Error(`MCP server ${this.name} exited with code ${code}`));
+        }
+        this.pendingRequests.clear();
+      });
+
+      // Initialize the connection
+      setTimeout(async () => {
+        try {
+          await this._initialize();
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      }, 500);
+    });
+  }
+
+  async _initialize() {
+    const result = await this._request("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "cheri", version: "0.10.0" },
+    });
+
+    // Send initialized notification
+    this._notify("notifications/initialized", {});
+
+    // Discover tools
+    try {
+      const toolsResult = await this._request("tools/list", {});
+      this.tools = toolsResult.tools || [];
+    } catch {
+      this.tools = [];
+    }
+
+    // Discover resources
+    try {
+      const resourcesResult = await this._request("resources/list", {});
+      this.resources = resourcesResult.resources || [];
+    } catch {
+      this.resources = [];
+    }
+
+    return result;
+  }
+
+  async callTool(name, args = {}) {
+    return this._request("tools/call", { name, arguments: args });
+  }
+
+  async readResource(uri) {
+    return this._request("resources/read", { uri });
+  }
+
+  _request(method, params) {
+    return new Promise((resolve, reject) => {
+      const id = ++requestId;
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`MCP request ${method} timed out`));
+      }, 30000);
+
+      this.pendingRequests.set(id, {
+        resolve: (result) => { clearTimeout(timeout); resolve(result); },
+        reject: (err) => { clearTimeout(timeout); reject(err); },
+      });
+
+      const message = JSON.stringify({
+        jsonrpc: JSONRPC_VERSION,
+        id,
+        method,
+        params,
+      });
+
+      try {
+        this.process.stdin.write(message + "\n");
+      } catch (err) {
+        this.pendingRequests.delete(id);
+        clearTimeout(timeout);
+        reject(new Error(`Failed to write to MCP server '${this.name}': ${err.message}`));
+      }
+    });
+  }
+
+  _notify(method, params) {
+    const message = JSON.stringify({
+      jsonrpc: JSONRPC_VERSION,
+      method,
+      params,
+    });
+    try {
+      this.process.stdin.write(message + "\n");
+    } catch {}
+  }
+
+  _processBuffer() {
+    const lines = this._buffer.split("\n");
+    this._buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const msg = JSON.parse(line);
+        if (msg.id && this.pendingRequests.has(msg.id)) {
+          const { resolve, reject } = this.pendingRequests.get(msg.id);
+          this.pendingRequests.delete(msg.id);
+          if (msg.error) {
+            reject(new Error(msg.error.message || "MCP error"));
+          } else {
+            resolve(msg.result);
+          }
+        }
+      } catch (err) {
+        log.dim(`[mcp:${this.name}] Failed to parse response: ${line.slice(0, 100)}`);
+      }
+    }
+  }
+
+  getToolDefinitions() {
+    return this.tools.map(t => ({
+      name: `mcp_${this.name}_${t.name}`,
+      description: `[MCP:${this.name}] ${t.description || t.name}`,
+      parameters: t.inputSchema || { type: "object", properties: {} },
+      mcpServer: this.name,
+      mcpToolName: t.name,
+    }));
+  }
+
+  disconnect() {
+    if (this.process) {
+      try { this.process.kill(); } catch {}
+      this.process = null;
+    }
+  }
+}
+
+/**
+ * MCP Manager — manages multiple MCP server connections
+ */
+export class McpManager {
+  constructor() {
+    this.servers = new Map();
+  }
+
+  async addServer(name, config) {
+    const server = new McpServer(
+      name,
+      config.command,
+      config.args || [],
+      config.env || {}
+    );
+
+    try {
+      await server.connect();
+      this.servers.set(name, server);
+      log.success(`MCP server '${name}' connected (${server.tools.length} tools)`);
+      return server;
+    } catch (err) {
+      log.warn(`MCP server '${name}' failed: ${err.message}`);
+      return null;
+    }
+  }
+
+  getAllToolDefinitions() {
+    const tools = [];
+    for (const server of this.servers.values()) {
+      tools.push(...server.getToolDefinitions());
+    }
+    return tools;
+  }
+
+  async callTool(fullName, args) {
+    // Find the server by checking registered tool names (avoids underscore ambiguity)
+    let server = null;
+    let toolName = null;
+    for (const s of this.servers.values()) {
+      const def = s.getToolDefinitions().find(t => t.name === fullName);
+      if (def) { server = s; toolName = def.mcpToolName; break; }
+    }
+    if (!server || !toolName) {
+      // Fallback: try regex parse
+      const match = fullName.match(/^mcp_([^_]+)_(.+)$/);
+      if (!match) return { error: `Invalid MCP tool name: ${fullName}` };
+      const [, serverName, tn] = match;
+      server = this.servers.get(serverName);
+      toolName = tn;
+      if (!server) return { error: `MCP server '${serverName}' not connected` };
+    }
+
+    try {
+      const result = await server.callTool(toolName, args);
+      // Extract text content from MCP response
+      if (result.content) {
+        return { result: result.content.map(c => c.text || JSON.stringify(c)).join("\n") };
+      }
+      return result;
+    } catch (err) {
+      return { error: err.message };
+    }
+  }
+
+  isMcpTool(name) {
+    return name.startsWith("mcp_");
+  }
+
+  disconnectAll() {
+    for (const server of this.servers.values()) {
+      server.disconnect();
+    }
+    this.servers.clear();
+  }
+}

package/src/lib/multi-agent.js

@@ -0,0 +1,153 @@
+// Multi-agent orchestration — spawn child agents for subtasks
+import { log } from "./logger.js";
+
+/**
+ * SubAgent — a lightweight agent that runs a focused subtask
+ * with its own message history but shares the parent's tools and API
+ */
+export class SubAgent {
+  constructor(name, systemPrompt, options = {}) {
+    this.name = name;
+    this.systemPrompt = systemPrompt;
+    this.maxIterations = options.maxIterations || 10;
+    this.tools = options.tools || [];
+    this.messages = [{ role: "system", content: systemPrompt }];
+    this.status = "idle"; // idle, running, done, error
+    this.result = null;
+  }
+}
+
+/**
+ * Agent orchestrator — manages parent + child agents
+ */
+export class AgentOrchestrator {
+  constructor(chatFn, executeTool) {
+    this.chatFn = chatFn;        // async function(messages, tools) => response
+    this.executeTool = executeTool; // async function(name, args) => result
+    this.agents = new Map();
+    this.parentId = "main";
+  }
+
+  /**
+   * Spawn a child agent for a subtask
+   */
+  createAgent(name, task, options = {}) {
+    const systemPrompt = `You are a sub-agent named "${name}" focused on a specific task.
+Your task: ${task}
+
+Complete this task using the available tools, then provide a concise summary of what you did and the results.
+Be focused and efficient. Do not ask questions — make reasonable decisions.
+Current working directory: ${process.cwd()}`;
+
+    const agent = new SubAgent(name, systemPrompt, {
+      maxIterations: options.maxIterations || 8,
+      tools: options.tools,
+    });
+
+    this.agents.set(name, agent);
+    return agent;
+  }
+
+  /**
+   * Run a child agent to completion
+   */
+  async runAgent(name, userMessage, allTools, parseSSEStream) {
+    const agent = this.agents.get(name);
+    if (!agent) throw new Error(`Agent '${name}' not found`);
+
+    agent.status = "running";
+    agent.messages.push({ role: "user", content: userMessage });
+
+    log.dim(`  [${name}] Starting subtask...`);
+
+    try {
+      for (let i = 0; i < agent.maxIterations; i++) {
+        const response = await this.chatFn(agent.messages, allTools);
+
+        let fullText = "";
+        const toolCalls = {};
+
+        for await (const chunk of parseSSEStream(response)) {
+          const delta = chunk.choices?.[0]?.delta;
+          const finishReason = chunk.choices?.[0]?.finish_reason;
+
+          if (delta?.content) fullText += delta.content;
+
+          if (delta?.tool_calls) {
+            for (const tc of delta.tool_calls) {
+              const idx = tc.index;
+              if (!toolCalls[idx]) toolCalls[idx] = { id: tc.id || "", name: "", arguments: "" };
+              if (tc.id) toolCalls[idx].id = tc.id;
+              if (tc.function?.name) toolCalls[idx].name = tc.function.name;
+              if (tc.function?.arguments) toolCalls[idx].arguments += tc.function.arguments;
+            }
+          }
+
+          if (finishReason) break;
+        }
+
+        const toolCallList = Object.values(toolCalls);
+
+        if (toolCallList.length === 0) {
+          agent.messages.push({ role: "assistant", content: fullText });
+          agent.status = "done";
+          agent.result = fullText;
+          log.dim(`  [${name}] Completed.`);
+          return fullText;
+        }
+
+        const assistantMsg = { role: "assistant", content: fullText || null };
+        assistantMsg.tool_calls = toolCallList.map(tc => ({
+          id: tc.id, type: "function", function: { name: tc.name, arguments: tc.arguments },
+        }));
+        agent.messages.push(assistantMsg);
+
+        // Execute tools (in parallel)
+        const toolPromises = toolCallList.map(async (tc) => {
+          let input = {};
+          try { input = JSON.parse(tc.arguments); } catch {}
+          log.dim(`  [${name}] → ${tc.name}`);
+          const result = await this.executeTool(tc.name, input);
+          return { id: tc.id, result };
+        });
+
+        const toolResults = await Promise.all(toolPromises);
+
+        for (const { id, result } of toolResults) {
+          const resultStr = JSON.stringify(result);
+          const truncated = resultStr.length > 6000 ? resultStr.slice(0, 6000) + "...(truncated)" : resultStr;
+          agent.messages.push({ role: "tool", tool_call_id: id, content: truncated });
+        }
+      }
+
+      agent.status = "done";
+      agent.result = "Reached maximum iterations";
+      return agent.result;
+    } catch (err) {
+      agent.status = "error";
+      agent.result = err.message;
+      log.warn(`  [${name}] Error: ${err.message}`);
+      return `Error: ${err.message}`;
+    }
+  }
+
+  /**
+   * Run multiple agents in parallel
+   */
+  async runParallel(tasks, allTools, parseSSEStream) {
+    const promises = tasks.map(({ name, task }) => {
+      this.createAgent(name, task);
+      return this.runAgent(name, task, allTools, parseSSEStream);
+    });
+
+    return Promise.all(promises);
+  }
+
+  getAgentStatus() {
+    const statuses = {};
+    for (const [name, agent] of this.agents) {
+      statuses[name] = { status: agent.status, result: agent.result?.slice(0, 200) };
+    }
+    return statuses;
+  }
+}

package/src/lib/providers/index.js

@@ -0,0 +1,290 @@
+// Multi-provider abstraction
+// Supports: Cheri Cloud (default), OpenAI, Anthropic, Ollama, custom OpenAI-compatible
+import { getConfigValue } from "../config-store.js";
+
+/**
+ * Provider interface:
+ * - chatStream(messages, tools, options) => Response (SSE stream)
+ * - chatSync(messages, tools, options) => parsed JSON response
+ */
+
+// ── Cheri Cloud Provider (default) ──────────────────────────────────────────
+class CheriCloudProvider {
+  constructor(token, baseUrl) {
+    this.token = token;
+    this.baseUrl = baseUrl || "https://cheri.heysalad.app";
+  }
+
+  async chatStream(messages, tools = [], options = {}) {
+    const body = { messages, stream: true };
+    if (tools.length > 0) body.tools = tools;
+    if (options.model) body.model = options.model;
+
+    const res = await fetch(`${this.baseUrl}/api/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!res.ok) {
+      const text = await res.text();
+      let msg;
+      try { msg = JSON.parse(text).error || text; } catch { msg = text; }
+      throw new Error(`AI error (${res.status}): ${msg}`);
+    }
+    return res;
+  }
+}
+
+// ── OpenAI-Compatible Provider ──────────────────────────────────────────────
+class OpenAIProvider {
+  constructor(apiKey, baseUrl, defaultModel) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+    this.defaultModel = defaultModel;
+  }
+
+  async chatStream(messages, tools = [], options = {}) {
+    const body = {
+      model: options.model || this.defaultModel,
+      messages,
+      stream: true,
+    };
+    if (tools.length > 0) body.tools = tools;
+    if (options.temperature !== undefined) body.temperature = options.temperature;
+    if (options.max_tokens) body.max_tokens = options.max_tokens;
+
+    const res = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Provider error (${res.status}): ${text.slice(0, 200)}`);
+    }
+    return res;
+  }
+}
+
+// ── Anthropic Provider ──────────────────────────────────────────────────────
+class AnthropicProvider {
+  constructor(apiKey, defaultModel) {
+    this.apiKey = apiKey;
+    this.defaultModel = defaultModel || "claude-sonnet-4-20250514";
+  }
+
+  async chatStream(messages, tools = [], options = {}) {
+    // Convert OpenAI format to Anthropic format
+    const system = messages.filter(m => m.role === "system").map(m => m.content).join("\n");
+    const anthropicMessages = [];
+
+    for (const msg of messages) {
+      if (msg.role === "system") continue;
+
+      if (msg.role === "user") {
+        anthropicMessages.push({ role: "user", content: msg.content });
+      } else if (msg.role === "assistant") {
+        const content = [];
+        if (msg.content) content.push({ type: "text", text: msg.content });
+        if (msg.tool_calls) {
+          for (const tc of msg.tool_calls) {
+            let input = {};
+            try { input = JSON.parse(tc.function.arguments); } catch {}
+            content.push({ type: "tool_use", id: tc.id, name: tc.function.name, input });
+          }
+        }
+        anthropicMessages.push({ role: "assistant", content });
+      } else if (msg.role === "tool") {
+        // Merge consecutive tool results into user message
+        const last = anthropicMessages[anthropicMessages.length - 1];
+        const block = { type: "tool_result", tool_use_id: msg.tool_call_id, content: msg.content };
+        if (last?.role === "user" && Array.isArray(last.content)) {
+          last.content.push(block);
+        } else {
+          anthropicMessages.push({ role: "user", content: [block] });
+        }
+      }
+    }
+
+    const anthropicTools = tools.map(t => ({
+      name: t.function.name,
+      description: t.function.description,
+      input_schema: t.function.parameters,
+    }));
+
+    const body = {
+      model: options.model || this.defaultModel,
+      max_tokens: options.max_tokens || 8192,
+      system,
+      messages: anthropicMessages,
+      stream: true,
+    };
+    if (anthropicTools.length > 0) body.tools = anthropicTools;
+
+    const res = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2023-06-01",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Anthropic error (${res.status}): ${text.slice(0, 200)}`);
+    }
+
+    // Anthropic SSE has different format — we need to convert to OpenAI format
+    // Return raw response; the agent will need to handle both formats
+    // For now, wrap in a converter
+    return this._convertStream(res, options.model || this.defaultModel);
+  }
+
+  async _convertStream(res, model) {
+    const reader = res.body.getReader();
+    const { readable, writable } = new TransformStream();
+    const writer = writable.getWriter();
+    const encoder = new TextEncoder();
+
+    (async () => {
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let toolUseId = "";
+      let toolName = "";
+
+      try {
+        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) {
+            if (!line.startsWith("data: ")) continue;
+            const data = line.slice(6).trim();
+            if (!data || data === "[DONE]") continue;
+
+            try {
+              const event = JSON.parse(data);
+              let chunk = null;
+
+              switch (event.type) {
+                case "content_block_start":
+                  if (event.content_block?.type === "tool_use") {
+                    toolUseId = event.content_block.id;
+                    toolName = event.content_block.name;
+                    chunk = { choices: [{ index: 0, delta: { tool_calls: [{ index: event.index, id: toolUseId, type: "function", function: { name: toolName, arguments: "" } }] }, finish_reason: null }] };
+                  }
+                  break;
+                case "content_block_delta":
+                  if (event.delta?.type === "text_delta") {
+                    chunk = { choices: [{ index: 0, delta: { content: event.delta.text }, finish_reason: null }] };
+                  } else if (event.delta?.type === "input_json_delta") {
+                    chunk = { choices: [{ index: 0, delta: { tool_calls: [{ index: 0, function: { arguments: event.delta.partial_json } }] }, finish_reason: null }] };
+                  }
+                  break;
+                case "message_delta":
+                  if (event.delta?.stop_reason) {
+                    const fr = event.delta.stop_reason === "tool_use" ? "tool_calls" : "stop";
+                    chunk = { choices: [{ index: 0, delta: {}, finish_reason: fr }] };
+                  }
+                  break;
+              }
+
+              if (chunk) {
+                chunk.model = model;
+                await writer.write(encoder.encode(`data: ${JSON.stringify(chunk)}\n\n`));
+              }
+            } catch {}
+          }
+        }
+        await writer.write(encoder.encode("data: [DONE]\n\n"));
+      } catch (err) {
+        try {
+          const errChunk = { choices: [{ index: 0, delta: { content: `\n[Stream error: ${err.message || "unknown"}]` }, finish_reason: "stop" }] };
+          await writer.write(encoder.encode(`data: ${JSON.stringify(errChunk)}\n\n`));
+        } catch {}
+      } finally {
+        try { await writer.close(); } catch {}
+      }
+    })();
+
+    return new Response(readable, {
+      headers: { "Content-Type": "text/event-stream" },
+    });
+  }
+}
+
+// ── Provider Factory ────────────────────────────────────────────────────────
+
+const PROVIDER_CONFIGS = {
+  cheri:     { envKey: null },
+  openai:    { envKey: "OPENAI_API_KEY",    baseUrl: "https://api.openai.com/v1",  defaultModel: "gpt-4o" },
+  anthropic: { envKey: "ANTHROPIC_API_KEY",  defaultModel: "claude-sonnet-4-20250514" },
+  deepseek:  { envKey: "DEEPSEEK_API_KEY",  baseUrl: "https://api.deepseek.com/v1", defaultModel: "deepseek-chat" },
+  groq:      { envKey: "GROQ_API_KEY",      baseUrl: "https://api.groq.com/openai/v1", defaultModel: "llama-3.3-70b-versatile" },
+  together:  { envKey: "TOGETHER_API_KEY",  baseUrl: "https://api.together.xyz/v1", defaultModel: "meta-llama/Llama-3.3-70B-Instruct-Turbo" },
+  ollama:    { envKey: null,                 baseUrl: "http://localhost:11434/v1",   defaultModel: "llama3.2" },
+  openrouter:{ envKey: "OPENROUTER_API_KEY", baseUrl: "https://openrouter.ai/api/v1", defaultModel: "anthropic/claude-sonnet-4" },
+  xai:       { envKey: "XAI_API_KEY",       baseUrl: "https://api.x.ai/v1",        defaultModel: "grok-3" },
+  mistral:   { envKey: "MISTRAL_API_KEY",   baseUrl: "https://api.mistral.ai/v1",  defaultModel: "mistral-large-latest" },
+};
+
+/**
+ * Create a provider based on config
+ */
+export function createProvider(providerName) {
+  providerName = providerName || getConfigValue("ai.provider") || "cheri";
+
+  if (providerName === "cheri") {
+    const token = getConfigValue("token");
+    const baseUrl = getConfigValue("apiUrl") || "https://cheri.heysalad.app";
+    if (!token) throw new Error("Not logged in. Run 'cheri login' first.");
+    return new CheriCloudProvider(token, baseUrl);
+  }
+
+  if (providerName === "anthropic") {
+    const apiKey = getConfigValue(`ai.keys.${providerName}`) || process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) throw new Error(`No API key for ${providerName}. Set via: cheri config set ai.keys.anthropic <key>`);
+    const model = getConfigValue("ai.model") || PROVIDER_CONFIGS.anthropic.defaultModel;
+    return new AnthropicProvider(apiKey, model);
+  }
+
+  const config = PROVIDER_CONFIGS[providerName];
+  if (!config) {
+    // Treat as custom OpenAI-compatible endpoint
+    const baseUrl = getConfigValue(`ai.providers.${providerName}.baseUrl`);
+    const apiKey = getConfigValue(`ai.keys.${providerName}`) || "none";
+    const model = getConfigValue(`ai.providers.${providerName}.model`) || "default";
+    if (!baseUrl) throw new Error(`Unknown provider '${providerName}'. Set baseUrl via: cheri config set ai.providers.${providerName}.baseUrl <url>`);
+    return new OpenAIProvider(apiKey, baseUrl, model);
+  }
+
+  const apiKey = getConfigValue(`ai.keys.${providerName}`) || (config.envKey ? process.env[config.envKey] : "none");
+  if (!apiKey || apiKey === "none") {
+    if (providerName !== "ollama") {
+      throw new Error(`No API key for ${providerName}. Set via: cheri config set ai.keys.${providerName} <key>`);
+    }
+  }
+
+  const model = getConfigValue("ai.model") || config.defaultModel;
+  return new OpenAIProvider(apiKey || "ollama", config.baseUrl, model);
+}
+
+/**
+ * List available providers
+ */
+export function listProviders() {
+  return Object.keys(PROVIDER_CONFIGS);
+}