@heysalad/cheri-cli 0.4.0 → 0.6.0

package/src/lib/branding.js

@@ -1,36 +0,0 @@
-import chalk from "chalk";
-import { getConfigValue } from "./config-store.js";
-
-const CHERRY_ART = `
-      ${chalk.red("🍒🍒")}
-     ${chalk.red("🍒  🍒")}
-`;
-
-export function showStartupScreen(options = {}) {
-  const provider = options.provider || getConfigValue("ai.provider") || "anthropic";
-  const model = options.model || getConfigValue("ai.model") || getDefaultModel(provider);
-  const cwd = process.cwd();
-  const version = "0.2.0";
-
-  console.log(CHERRY_ART);
-  console.log(chalk.bold(`  cheri  v${version}`));
-  console.log(chalk.dim("  AI coding agent by HeySalad"));
-  console.log();
-  console.log(`  ${chalk.dim("Provider:")}  ${chalk.cyan(provider)}`);
-  console.log(`  ${chalk.dim("Model:")}     ${chalk.cyan(model)}`);
-  console.log(`  ${chalk.dim("Directory:")} ${chalk.cyan(cwd)}`);
-  console.log();
-  console.log(chalk.dim("  Type your request. /help for commands, Ctrl+C to exit."));
-  console.log(chalk.dim("  " + "─".repeat(48)));
-  console.log();
-}
-
-export function getDefaultModel(provider) {
-  const defaults = {
-    anthropic: "claude-sonnet-4-20250514",
-    openai: "gpt-4o",
-    deepseek: "deepseek-chat",
-    gemini: "gemini-2.0-flash",
-  };
-  return defaults[provider] || "unknown";
-}

package/src/lib/deepseek-client.js

@@ -1,64 +0,0 @@
-import { getConfigValue } from "./config-store.js";
-
-export function getApiKey() {
-  const key = getConfigValue("deepseekApiKey") || getConfigValue("ai.keys.deepseek");
-  if (!key) {
-    throw new Error(
-      "DeepSeek API key not set. Run: cheri config set deepseekApiKey sk-..."
-    );
-  }
-  return key;
-}
-
-export function getModel() {
-  return getConfigValue("agent.model") || "deepseek-chat";
-}
-
-export async function* streamChatCompletion(messages, tools) {
-  const apiKey = getApiKey();
-  const model = getModel();
-
-  const body = {
-    model,
-    messages,
-    stream: true,
-  };
-  if (tools && tools.length > 0) {
-    body.tools = tools;
-  }
-
-  const res = await fetch("https://api.deepseek.com/chat/completions", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`,
-    },
-    body: JSON.stringify(body),
-  });
-
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`DeepSeek API error (${res.status}): ${text}`);
-  }
-
-  const decoder = new TextDecoder();
-  let buffer = "";
-
-  for await (const chunk of res.body) {
-    buffer += decoder.decode(chunk, { 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);
-      if (data === "[DONE]") return;
-      try {
-        yield JSON.parse(data);
-      } catch {
-        // skip malformed chunks
-      }
-    }
-  }
-}

package/src/lib/providers/anthropic.js

@@ -1,66 +0,0 @@
-import { BaseProvider, SYSTEM_PROMPT } from "./base.js";
-
-export class AnthropicProvider extends BaseProvider {
-  constructor(apiKey, model = "claude-sonnet-4-20250514") {
-    super(apiKey, model);
-  }
-
-  async *chat(messages, tools) {
-    const { default: Anthropic } = await import("@anthropic-ai/sdk");
-    const client = new Anthropic({ apiKey: this.apiKey });
-
-    const anthropicTools = tools.map((t) => ({
-      name: t.name,
-      description: t.description,
-      input_schema: t.parameters,
-    }));
-
-    const stream = await client.messages.stream({
-      model: this.model,
-      max_tokens: 8192,
-      system: SYSTEM_PROMPT,
-      messages,
-      tools: anthropicTools.length > 0 ? anthropicTools : undefined,
-    });
-
-    let currentToolId = null;
-    let currentToolName = null;
-    let toolInputJson = "";
-
-    for await (const event of stream) {
-      if (event.type === "content_block_start") {
-        if (event.content_block.type === "text") {
-          // text block starting
-        } else if (event.content_block.type === "tool_use") {
-          currentToolId = event.content_block.id;
-          currentToolName = event.content_block.name;
-          toolInputJson = "";
-          yield { type: "tool_use_start", id: currentToolId, name: currentToolName };
-        }
-      } else if (event.type === "content_block_delta") {
-        if (event.delta.type === "text_delta") {
-          yield { type: "text", content: event.delta.text };
-        } else if (event.delta.type === "input_json_delta") {
-          toolInputJson += event.delta.partial_json;
-          yield { type: "tool_input_delta", content: event.delta.partial_json };
-        }
-      } else if (event.type === "content_block_stop") {
-        if (currentToolId) {
-          let input = {};
-          try {
-            input = JSON.parse(toolInputJson);
-          } catch {}
-          yield { type: "tool_use_end", id: currentToolId, name: currentToolName, input };
-          currentToolId = null;
-          currentToolName = null;
-          toolInputJson = "";
-        }
-      } else if (event.type === "message_stop") {
-        // done
-      }
-    }
-
-    const finalMessage = await stream.finalMessage();
-    yield { type: "done", stopReason: finalMessage.stop_reason };
-  }
-}

package/src/lib/providers/base.js

@@ -1,34 +0,0 @@
-export const SYSTEM_PROMPT = `You are Cheri, an AI coding assistant by HeySalad. You help developers write, debug, and understand code.
-
-You have access to tools that let you read files, write files, edit files, run shell commands, search files, and list directories. Use them proactively to help the user.
-
-Guidelines:
-- Read files before modifying them to understand the existing code.
-- Use edit_file for targeted changes instead of rewriting entire files.
-- When running commands, explain what you're about to run and why.
-- Be concise but thorough. Show relevant code snippets in your responses.
-- If you're unsure about something, say so rather than guessing.
-- Format responses with markdown for readability.`;
-
-export class BaseProvider {
-  constructor(apiKey, model) {
-    this.apiKey = apiKey;
-    this.model = model;
-  }
-
-  /**
-   * Async generator that yields streaming events:
-   *   { type: "text", content: string }
-   *   { type: "tool_use_start", id: string, name: string }
-   *   { type: "tool_input_delta", content: string }
-   *   { type: "tool_use_end", id: string, name: string, input: object }
-   *   { type: "done", stopReason: string }
-   */
-  async *chat(messages, tools) {
-    throw new Error("chat() must be implemented by subclass");
-  }
-
-  getModel() {
-    return this.model;
-  }
-}

package/src/lib/providers/gemini.js

@@ -1,89 +0,0 @@
-import { BaseProvider, SYSTEM_PROMPT } from "./base.js";
-
-export class GeminiProvider extends BaseProvider {
-  constructor(apiKey, model = "gemini-2.0-flash") {
-    super(apiKey, model);
-  }
-
-  async *chat(messages, tools) {
-    const { GoogleGenerativeAI } = await import("@google/generative-ai");
-    const genAI = new GoogleGenerativeAI(this.apiKey);
-
-    const geminiTools = tools.length > 0 ? [{
-      functionDeclarations: tools.map((t) => ({
-        name: t.name,
-        description: t.description,
-        parameters: t.parameters,
-      })),
-    }] : undefined;
-
-    const genModel = genAI.getGenerativeModel({
-      model: this.model,
-      systemInstruction: SYSTEM_PROMPT,
-      tools: geminiTools,
-    });
-
-    // Convert messages to Gemini format
-    const history = [];
-    for (const msg of messages.slice(0, -1)) {
-      const role = msg.role === "assistant" ? "model" : "user";
-      if (typeof msg.content === "string") {
-        history.push({ role, parts: [{ text: msg.content }] });
-      } else if (Array.isArray(msg.content)) {
-        const parts = [];
-        for (const block of msg.content) {
-          if (block.type === "text") {
-            parts.push({ text: block.text });
-          } else if (block.type === "tool_use") {
-            parts.push({ functionCall: { name: block.name, args: block.input } });
-          } else if (block.type === "tool_result") {
-            const resultText = typeof block.content === "string" ? block.content : JSON.stringify(block.content);
-            parts.push({ functionResponse: { name: block.name || "tool", response: { result: resultText } } });
-          }
-        }
-        if (parts.length > 0) history.push({ role, parts });
-      }
-    }
-
-    const chat = genModel.startChat({ history });
-
-    // Get the last message content
-    const lastMsg = messages[messages.length - 1];
-    const lastContent = typeof lastMsg.content === "string"
-      ? lastMsg.content
-      : lastMsg.content.map((b) => {
-          if (b.type === "text") return b.text;
-          if (b.type === "tool_result") {
-            return typeof b.content === "string" ? b.content : JSON.stringify(b.content);
-          }
-          return "";
-        }).join("\n");
-
-    const result = await chat.sendMessageStream(lastContent);
-
-    let hasToolCalls = false;
-
-    for await (const chunk of result.stream) {
-      const text = chunk.text();
-      if (text) {
-        yield { type: "text", content: text };
-      }
-
-      // Check for function calls
-      const candidates = chunk.candidates || [];
-      for (const candidate of candidates) {
-        for (const part of candidate.content?.parts || []) {
-          if (part.functionCall) {
-            hasToolCalls = true;
-            const id = `gemini_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-            yield { type: "tool_use_start", id, name: part.functionCall.name };
-            yield { type: "tool_input_delta", content: JSON.stringify(part.functionCall.args) };
-            yield { type: "tool_use_end", id, name: part.functionCall.name, input: part.functionCall.args || {} };
-          }
-        }
-      }
-    }
-
-    yield { type: "done", stopReason: hasToolCalls ? "tool_use" : "end_turn" };
-  }
-}

package/src/lib/providers/index.js

@@ -1,47 +0,0 @@
-import { getConfigValue } from "../config-store.js";
-import { getDefaultModel } from "../branding.js";
-
-export async function createProvider(options = {}) {
-  const provider = options.provider || getConfigValue("ai.provider") || "anthropic";
-  const model = options.model || getConfigValue("ai.model") || getDefaultModel(provider);
-
-  // Resolve API key: env var takes priority, then config
-  const envKeys = {
-    anthropic: "ANTHROPIC_API_KEY",
-    openai: "OPENAI_API_KEY",
-    deepseek: "DEEPSEEK_API_KEY",
-    gemini: "GEMINI_API_KEY",
-  };
-
-  const apiKey = process.env[envKeys[provider]] || getConfigValue(`ai.keys.${provider}`);
-
-  if (!apiKey) {
-    throw new Error(
-      `No API key found for ${provider}. Set it with:\n` +
-      `  cheri config set ai.keys.${provider} <your-key>\n` +
-      `Or set the ${envKeys[provider]} environment variable.`
-    );
-  }
-
-  // Lazy import only the selected provider
-  switch (provider) {
-    case "anthropic": {
-      const { AnthropicProvider } = await import("./anthropic.js");
-      return new AnthropicProvider(apiKey, model);
-    }
-    case "openai": {
-      const { OpenAIProvider } = await import("./openai.js");
-      return new OpenAIProvider(apiKey, model);
-    }
-    case "deepseek": {
-      const { DeepSeekProvider } = await import("./openai.js");
-      return new DeepSeekProvider(apiKey, model);
-    }
-    case "gemini": {
-      const { GeminiProvider } = await import("./gemini.js");
-      return new GeminiProvider(apiKey, model);
-    }
-    default:
-      throw new Error(`Unknown provider: ${provider}. Supported: anthropic, openai, deepseek, gemini`);
-  }
-}

package/src/lib/providers/openai.js

@@ -1,105 +0,0 @@
-import { BaseProvider, SYSTEM_PROMPT } from "./base.js";
-
-export class OpenAIProvider extends BaseProvider {
-  constructor(apiKey, model = "gpt-4o", baseURL = undefined) {
-    super(apiKey, model);
-    this.baseURL = baseURL;
-  }
-
-  async *chat(messages, tools) {
-    const { default: OpenAI } = await import("openai");
-    const clientOpts = { apiKey: this.apiKey };
-    if (this.baseURL) clientOpts.baseURL = this.baseURL;
-    const client = new OpenAI(clientOpts);
-
-    // Convert from Anthropic message format to OpenAI format
-    const openaiMessages = [{ role: "system", content: SYSTEM_PROMPT }];
-    for (const msg of messages) {
-      if (typeof msg.content === "string") {
-        openaiMessages.push({ role: msg.role, content: msg.content });
-      } else if (Array.isArray(msg.content)) {
-        // Handle tool results and multi-part content
-        for (const block of msg.content) {
-          if (block.type === "tool_result") {
-            openaiMessages.push({
-              role: "tool",
-              tool_call_id: block.tool_use_id,
-              content: typeof block.content === "string" ? block.content : JSON.stringify(block.content),
-            });
-          } else if (block.type === "text") {
-            openaiMessages.push({ role: msg.role, content: block.text });
-          } else if (block.type === "tool_use") {
-            // Assistant message with tool call
-            openaiMessages.push({
-              role: "assistant",
-              content: null,
-              tool_calls: [{
-                id: block.id,
-                type: "function",
-                function: { name: block.name, arguments: JSON.stringify(block.input) },
-              }],
-            });
-          }
-        }
-      }
-    }
-
-    const openaiTools = tools.map((t) => ({
-      type: "function",
-      function: { name: t.name, description: t.description, parameters: t.parameters },
-    }));
-
-    const stream = await client.chat.completions.create({
-      model: this.model,
-      messages: openaiMessages,
-      tools: openaiTools.length > 0 ? openaiTools : undefined,
-      stream: true,
-    });
-
-    const toolCalls = {};
-
-    for await (const chunk of stream) {
-      const delta = chunk.choices?.[0]?.delta;
-      const finishReason = chunk.choices?.[0]?.finish_reason;
-
-      if (delta?.content) {
-        yield { type: "text", content: 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;
-            yield { type: "tool_use_start", id: toolCalls[idx].id, name: tc.function.name };
-          }
-          if (tc.function?.arguments) {
-            toolCalls[idx].arguments += tc.function.arguments;
-            yield { type: "tool_input_delta", content: tc.function.arguments };
-          }
-        }
-      }
-
-      if (finishReason) {
-        // Emit tool_use_end for any accumulated tool calls
-        for (const idx of Object.keys(toolCalls)) {
-          const tc = toolCalls[idx];
-          let input = {};
-          try { input = JSON.parse(tc.arguments); } catch {}
-          yield { type: "tool_use_end", id: tc.id, name: tc.name, input };
-        }
-        yield { type: "done", stopReason: finishReason === "tool_calls" ? "tool_use" : finishReason };
-      }
-    }
-  }
-}
-
-export class DeepSeekProvider extends OpenAIProvider {
-  constructor(apiKey, model = "deepseek-chat") {
-    super(apiKey, model, "https://api.deepseek.com");
-  }
-}

package/src/lib/renderer.js

@@ -1,44 +0,0 @@
-import chalk from "chalk";
-
-let markedRender = null;
-
-async function getMarked() {
-  if (markedRender) return markedRender;
-  const { marked } = await import("marked");
-  const { default: TerminalRenderer } = await import("marked-terminal");
-  marked.setOptions({
-    renderer: new TerminalRenderer({
-      reflowText: true,
-      width: Math.min(process.stdout.columns || 80, 100),
-      tab: 2,
-    }),
-  });
-  markedRender = marked;
-  return markedRender;
-}
-
-export async function renderMarkdown(text) {
-  try {
-    const marked = await getMarked();
-    return marked.parse(text);
-  } catch {
-    return text;
-  }
-}
-
-export function renderToolUse(name, input) {
-  const shortInput = Object.entries(input || {})
-    .map(([k, v]) => {
-      const val = typeof v === "string" ? (v.length > 60 ? v.slice(0, 57) + "..." : v) : JSON.stringify(v);
-      return `${chalk.dim(k)}=${val}`;
-    })
-    .join(", ");
-  return `${chalk.magenta("🔧")} ${chalk.bold(name)}(${shortInput})`;
-}
-
-export function renderToolResult(name, result) {
-  if (result.error) {
-    return chalk.red(`❌ ${name}: ${result.error}`);
-  }
-  return chalk.green(`✅ ${name} completed`);
-}