@heysalad/cheri-cli 0.2.0 → 0.3.1

package/src/repl.js

@@ -0,0 +1,217 @@
+import readline from "readline";
+import chalk from "chalk";
+import { log } from "./lib/logger.js";
+
+// Import standalone action handlers
+import { launchWorkspace, stopWorkspace, listWorkspaces, getWorkspaceStatus } from "./commands/workspace.js";
+import { showMemory, addMemory, clearMemory, exportMemory } from "./commands/memory.js";
+import { showStatus } from "./commands/status.js";
+import { listConfig, getConfigKey, setConfigKey } from "./commands/config.js";
+import { loginFlow } from "./commands/login.js";
+import { initProject } from "./commands/init.js";
+import { showUsage } from "./commands/usage.js";
+
+const COMMANDS = {
+  "workspace launch": { args: "<repo>", desc: "Launch a new cloud workspace" },
+  "workspace list":   { args: "",       desc: "List all workspaces" },
+  "workspace stop":   { args: "<id>",   desc: "Stop a running workspace" },
+  "workspace status": { args: "<id>",   desc: "Get workspace status" },
+  "memory show":      { args: "",       desc: "Show current memory entries" },
+  "memory add":       { args: "<text>", desc: "Add a memory entry" },
+  "memory clear":     { args: "",       desc: "Clear all memory" },
+  "memory export":    { args: "",       desc: "Export memory to JSON" },
+  "status":           { args: "",       desc: "Show account & workspace status" },
+  "usage":            { args: "",       desc: "Show API usage & rate limits" },
+  "config list":      { args: "",       desc: "Show all configuration" },
+  "config get":       { args: "<key>",  desc: "Get a config value" },
+  "config set":       { args: "<k> <v>",desc: "Set a config value" },
+  "login":            { args: "",       desc: "Authenticate with Cheri" },
+  "init":             { args: "",       desc: "Initialize a project" },
+  "help":             { args: "",       desc: "Show this help" },
+  "clear":            { args: "",       desc: "Clear the terminal" },
+  "exit":             { args: "",       desc: "Exit Cheri" },
+};
+
+function showHelp() {
+  log.blank();
+  log.brand("Available Commands");
+  log.blank();
+
+  const maxCmd = 20;
+  const maxArgs = 10;
+
+  for (const [cmd, { args, desc }] of Object.entries(COMMANDS)) {
+    const cmdStr = chalk.cyan(cmd.padEnd(maxCmd));
+    const argsStr = chalk.dim(args.padEnd(maxArgs));
+    console.log(`  ${cmdStr} ${argsStr} ${desc}`);
+  }
+
+  log.blank();
+  log.tip("Type a command above, or 'exit' to quit. Use arrow keys for history.");
+  log.blank();
+}
+
+async function dispatch(input) {
+  const parts = input.split(/\s+/);
+  const cmd = parts[0];
+  const sub = parts[1];
+  const rest = parts.slice(2).join(" ");
+
+  switch (cmd) {
+    case "help":
+      showHelp();
+      return;
+
+    case "clear":
+      console.clear();
+      return;
+
+    case "exit":
+    case "quit":
+      console.log(chalk.dim("\nGoodbye! 🍒\n"));
+      process.exit(0);
+
+    case "status":
+      await showStatus();
+      return;
+
+    case "usage":
+      await showUsage();
+      return;
+
+    case "login":
+      await loginFlow();
+      return;
+
+    case "init":
+      await initProject();
+      return;
+
+    case "workspace":
+      switch (sub) {
+        case "launch":
+          if (!rest) {
+            log.error("Usage: workspace launch <owner/repo>");
+            return;
+          }
+          await launchWorkspace(rest);
+          return;
+        case "list":
+          await listWorkspaces();
+          return;
+        case "stop":
+          if (!rest) {
+            log.error("Usage: workspace stop <id>");
+            return;
+          }
+          await stopWorkspace(rest);
+          return;
+        case "status":
+          if (!rest) {
+            log.error("Usage: workspace status <id>");
+            return;
+          }
+          await getWorkspaceStatus(rest);
+          return;
+        default:
+          log.error("Usage: workspace [launch|list|stop|status]");
+          return;
+      }
+
+    case "memory":
+      switch (sub) {
+        case "show":
+          await showMemory();
+          return;
+        case "add":
+          if (!rest) {
+            log.error("Usage: memory add <content>");
+            return;
+          }
+          await addMemory(rest);
+          return;
+        case "clear":
+          await clearMemory();
+          return;
+        case "export":
+          await exportMemory();
+          return;
+        default:
+          log.error("Usage: memory [show|add|clear|export]");
+          return;
+      }
+
+    case "config":
+      switch (sub) {
+        case "list":
+          listConfig();
+          return;
+        case "get":
+          if (!rest) {
+            log.error("Usage: config get <key>");
+            return;
+          }
+          getConfigKey(rest);
+          return;
+        case "set": {
+          const setParts = rest.split(/\s+/);
+          if (setParts.length < 2) {
+            log.error("Usage: config set <key> <value>");
+            return;
+          }
+          setConfigKey(setParts[0], setParts.slice(1).join(" "));
+          return;
+        }
+        default:
+          log.error("Usage: config [list|get|set]");
+          return;
+      }
+
+    default:
+      log.warn(`Unknown command: '${cmd}'. Type ${chalk.cyan("help")} for available commands.`);
+  }
+}
+
+export async function startCommandRepl() {
+  log.banner();
+  console.log(chalk.dim("  " + "─".repeat(40)));
+  log.tip(`Type ${chalk.cyan("help")} for commands, ${chalk.cyan("exit")} to quit.`);
+  log.blank();
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: chalk.red("🍒 cheri") + chalk.dim(" > "),
+    terminal: true,
+  });
+
+  rl.prompt();
+
+  rl.on("line", async (line) => {
+    const input = line.trim();
+
+    if (!input) {
+      rl.prompt();
+      return;
+    }
+
+    try {
+      await dispatch(input);
+    } catch (err) {
+      log.error(err.message);
+    }
+
+    rl.prompt();
+  });
+
+  rl.on("close", () => {
+    console.log(chalk.dim("\nGoodbye! 🍒\n"));
+    process.exit(0);
+  });
+
+  // Handle Ctrl+C gracefully
+  rl.on("SIGINT", () => {
+    console.log(chalk.dim("\nGoodbye! 🍒\n"));
+    process.exit(0);
+  });
+}

package/src/commands/chat.js

@@ -1,15 +0,0 @@
-import { startRepl } from "../lib/repl.js";
-
-export function registerChatCommand(program) {
-  program
-    .command("chat")
-    .description("Start an interactive AI coding session")
-    .option("-p, --provider <provider>", "AI provider (anthropic, openai, deepseek, gemini)")
-    .option("-m, --model <model>", "Model to use (overrides provider default)")
-    .action(async (options) => {
-      await startRepl({
-        provider: options.provider,
-        model: options.model,
-      });
-    });
-}

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/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`);
-}