@heysalad/cheri-cli 0.3.1 → 0.5.0

package/README.md

@@ -1,8 +1,6 @@
-# cheri-cli
+# Cheri CLI
 
-CLI for [Cheri](https://cheri.heysalad.app) — the AI-powered cloud IDE that never forgets.
-
-Manage workspaces, track API usage, and access your AI memory from the terminal.
+AI-powered cloud IDE by [HeySalad](https://heysalad.app). Like Claude Code, but for cloud workspaces.
 
 ## Install
 
@@ -10,79 +8,53 @@ Manage workspaces, track API usage, and access your AI memory from the terminal.
 npm install -g @heysalad/cheri-cli
 ```
 
-Requires Node.js 18+.
-
-## Quick Start
+## Usage
 
 ```bash
-# Authenticate with your Cheri account
+# Login to your Cheri account
 cheri login
 
-# Launch a cloud workspace
-cheri workspace launch owner/my-repo
-
 # Check account status
 cheri status
 
-# View API usage and rate limits
-cheri usage
-```
+# Launch a cloud workspace
+cheri workspace launch owner/repo
 
-## Commands
-
-| Command | Description |
-|---|---|
-| `cheri login` | Authenticate with GitHub |
-| `cheri status` | Show account and workspace status |
-| `cheri usage` | Show API usage and rate limit status |
-| `cheri workspace launch <repo>` | Launch a new cloud workspace |
-| `cheri workspace list` | List all workspaces |
-| `cheri workspace stop <id>` | Stop a running workspace |
-| `cheri workspace status <id>` | Get workspace status |
-| `cheri memory show` | Show current memory entries |
-| `cheri memory add <text>` | Add a memory entry |
-| `cheri memory clear` | Clear all memory |
-| `cheri memory export` | Export memory to JSON |
-| `cheri config list` | Show all configuration |
-| `cheri config get <key>` | Get a config value |
-| `cheri config set <key> <value>` | Set a config value |
-| `cheri init` | Initialize a project |
-
-## Interactive REPL
-
-Run `cheri` with no arguments to enter the interactive REPL:
+# List your workspaces
+cheri workspace list
 
-```
-$ cheri
-🍒 cheri > help
-🍒 cheri > workspace list
-🍒 cheri > usage
-🍒 cheri > exit
-```
+# Stop a workspace
+cheri workspace stop
+
+# Initialize AI project config
+cheri init
 
-## Rate Limits
+# Manage persistent memory
+cheri memory show
+cheri memory add "Always use TypeScript strict mode"
+cheri memory clear
 
-| Plan | Limit |
-|---|---|
-| Free | 100 requests/hour |
-| Pro | 1,000 requests/hour |
+# View/update configuration
+cheri config list
+cheri config set apiUrl https://cheri.heysalad.app
+```
 
-Use `cheri usage` to check your current rate limit status.
+## How it works
 
-## Configuration
+1. **`cheri login`** opens your browser for GitHub OAuth, then you paste your API token
+2. **`cheri workspace launch`** spins up a cloud workspace with code-server (VS Code in browser)
+3. **`cheri memory`** stores persistent context that follows you across sessions
+4. **`cheri init`** creates a local `.ai/` directory with project constitution files
 
-Config is stored in `~/.cheri/`. Set the API URL if self-hosting:
+## Requirements
 
-```bash
-cheri config set apiUrl https://your-instance.example.com
-```
+- Node.js >= 18
 
 ## Links
 
 - [Cheri Cloud IDE](https://cheri.heysalad.app)
-- [Dashboard](https://cheri.heysalad.app/dashboard)
-- [GitHub](https://github.com/chilu18/cloud-ide)
+- [GitHub](https://github.com/Hey-Salad/cheri-cli)
 
 ## License
 
-MIT
+MIT - HeySalad

package/bin/cheri.js

@@ -7,12 +7,13 @@ import { registerStatusCommand } from "../src/commands/status.js";
 import { registerMemoryCommand } from "../src/commands/memory.js";
 import { registerConfigCommand } from "../src/commands/config.js";
 import { registerWorkspaceCommand } from "../src/commands/workspace.js";
-import { registerUsageCommand } from "../src/commands/usage.js";
+import { registerChatCommand } from "../src/commands/chat.js";
+import { registerAgentCommand } from "../src/commands/agent.js";
 
 program
   .name("cheri")
   .description("Cheri CLI - AI-powered cloud IDE by HeySalad")
-  .version("0.1.0");
+  .version("0.2.0");
 
 registerLoginCommand(program);
 registerInitCommand(program);
@@ -20,7 +21,8 @@ registerStatusCommand(program);
 registerMemoryCommand(program);
 registerConfigCommand(program);
 registerWorkspaceCommand(program);
-registerUsageCommand(program);
+registerChatCommand(program);
+registerAgentCommand(program);
 
 // If no args, launch interactive command REPL
 if (!process.argv.slice(2).length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heysalad/cheri-cli",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "description": "Cheri CLI - AI-powered cloud IDE by HeySalad. Like Claude Code, but for cloud workspaces.",
   "type": "module",
   "bin": {
@@ -8,14 +8,15 @@
   },
   "files": [
     "bin/",
-    "src/"
+    "src/",
+    "README.md"
   ],
   "scripts": {
     "start": "node bin/cheri.js",
     "dev": "node bin/cheri.js",
-    "release:patch": "npm version patch && npm publish && git push && git push --tags",
-    "release:minor": "npm version minor && npm publish && git push && git push --tags",
-    "release:major": "npm version major && npm publish && git push && git push --tags"
+    "release:patch": "npm version patch && npm publish --access public && git push && git push --tags",
+    "release:minor": "npm version minor && npm publish --access public && git push && git push --tags",
+    "release:major": "npm version major && npm publish --access public && git push && git push --tags"
   },
   "keywords": [
     "cloud-ide",
@@ -28,18 +29,23 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/chilu18/cloud-ide.git",
-    "directory": "cli"
+    "url": "https://github.com/Hey-Salad/cheri-cli.git"
   },
+  "homepage": "https://cheri.heysalad.app",
   "author": "HeySalad",
   "license": "MIT",
   "engines": {
     "node": ">=18"
   },
   "dependencies": {
+    "@anthropic-ai/sdk": "^0.74.0",
+    "@google/generative-ai": "^0.24.1",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "inquirer": "^9.2.23",
+    "marked": "^15.0.12",
+    "marked-terminal": "^7.3.0",
+    "openai": "^6.22.0",
     "ora": "^8.0.1"
   }
 }

package/src/commands/agent.js

@@ -0,0 +1,238 @@
+import { apiClient } from "../lib/api-client.js";
+import { getConfigValue, setConfigValue } from "../lib/config-store.js";
+import { createProvider } from "../lib/providers/index.js";
+import { log } from "../lib/logger.js";
+import chalk from "chalk";
+
+const SYSTEM_PROMPT = `You are Cheri Agent, an AI assistant for the Cheri cloud IDE platform. You help users manage cloud workspaces, memory, configuration, and their account. Use the provided tools to get real data — never guess or fabricate information. Be concise. After performing actions, briefly summarize what happened and the result.`;
+
+const TOOLS = [
+  {
+    name: "get_account_info",
+    description: "Get the current user's account information",
+    parameters: { type: "object", properties: {}, required: [] },
+  },
+  {
+    name: "list_workspaces",
+    description: "List all cloud workspaces for the current user",
+    parameters: { type: "object", properties: {}, required: [] },
+  },
+  {
+    name: "create_workspace",
+    description: "Launch a new cloud workspace for a GitHub repository",
+    parameters: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "GitHub repo in owner/name format" },
+      },
+      required: ["repo"],
+    },
+  },
+  {
+    name: "stop_workspace",
+    description: "Stop and delete a running workspace",
+    parameters: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Workspace ID to stop" },
+      },
+      required: ["id"],
+    },
+  },
+  {
+    name: "get_workspace_status",
+    description: "Get the status of a specific workspace",
+    parameters: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Workspace ID" },
+      },
+      required: ["id"],
+    },
+  },
+  {
+    name: "get_memory",
+    description: "Retrieve all stored memory entries",
+    parameters: { type: "object", properties: {}, required: [] },
+  },
+  {
+    name: "add_memory",
+    description: "Add a new memory entry for the user",
+    parameters: {
+      type: "object",
+      properties: {
+        content: { type: "string", description: "Memory content to store" },
+        category: { type: "string", description: "Optional category (defaults to 'general')" },
+      },
+      required: ["content"],
+    },
+  },
+  {
+    name: "clear_memory",
+    description: "Clear all stored memory entries",
+    parameters: { type: "object", properties: {}, required: [] },
+  },
+  {
+    name: "get_usage",
+    description: "Get the user's API usage and rate limit statistics",
+    parameters: { type: "object", properties: {}, required: [] },
+  },
+  {
+    name: "get_config",
+    description: "Get a configuration value by key (dot notation supported)",
+    parameters: {
+      type: "object",
+      properties: {
+        key: { type: "string", description: "Config key, e.g. 'ai.provider'" },
+      },
+      required: ["key"],
+    },
+  },
+  {
+    name: "set_config",
+    description: "Set a configuration value",
+    parameters: {
+      type: "object",
+      properties: {
+        key: { type: "string", description: "Config key" },
+        value: { type: "string", description: "Value to set" },
+      },
+      required: ["key", "value"],
+    },
+  },
+];
+
+async function executeTool(name, args) {
+  try {
+    switch (name) {
+      case "get_account_info":
+        return await apiClient.getMe();
+      case "list_workspaces":
+        return await apiClient.listWorkspaces();
+      case "create_workspace":
+        return await apiClient.createWorkspace(args.repo);
+      case "stop_workspace":
+        return await apiClient.deleteWorkspace(args.id);
+      case "get_workspace_status":
+        return await apiClient.getWorkspaceStatus(args.id);
+      case "get_memory":
+        return await apiClient.getMemory();
+      case "add_memory":
+        return await apiClient.addMemory(args.content, args.category);
+      case "clear_memory":
+        return await apiClient.clearMemory();
+      case "get_usage":
+        return await apiClient.getUsage();
+      case "get_config":
+        return { key: args.key, value: getConfigValue(args.key) };
+      case "set_config":
+        setConfigValue(args.key, args.value);
+        return { key: args.key, value: args.value, status: "updated" };
+      default:
+        return { error: `Unknown tool: ${name}` };
+    }
+  } catch (err) {
+    return { error: err.message };
+  }
+}
+
+export async function runAgent(userRequest) {
+  const providerName = getConfigValue("agent.provider") || getConfigValue("ai.provider") || "anthropic";
+  const model = getConfigValue("agent.model") || undefined;
+
+  const provider = await createProvider({ provider: providerName, model });
+
+  const messages = [
+    { role: "user", content: userRequest },
+  ];
+
+  const MAX_ITERATIONS = 10;
+
+  for (let i = 0; i < MAX_ITERATIONS; i++) {
+    let fullText = "";
+    const toolCalls = [];
+
+    for await (const event of provider.chat(messages, TOOLS, { systemPrompt: SYSTEM_PROMPT })) {
+      switch (event.type) {
+        case "text":
+          process.stdout.write(event.content);
+          fullText += event.content;
+          break;
+
+        case "tool_use_start":
+          toolCalls.push({ id: event.id, name: event.name, input: {} });
+          break;
+
+        case "tool_input_delta":
+          // accumulated by provider, final input comes in tool_use_end
+          break;
+
+        case "tool_use_end":
+          if (toolCalls.length > 0) {
+            toolCalls[toolCalls.length - 1].input = event.input;
+          }
+          break;
+
+        case "done":
+          break;
+      }
+    }
+
+    // No tool calls — final text response, done
+    if (toolCalls.length === 0) {
+      if (fullText) process.stdout.write("\n");
+      return;
+    }
+
+    if (fullText) process.stdout.write("\n");
+
+    // Build assistant message in Anthropic content-block format
+    const assistantContent = [];
+    if (fullText) {
+      assistantContent.push({ type: "text", text: fullText });
+    }
+    for (const tc of toolCalls) {
+      assistantContent.push({ type: "tool_use", id: tc.id, name: tc.name, input: tc.input });
+    }
+    messages.push({ role: "assistant", content: assistantContent });
+
+    // Execute each tool call and build tool results
+    const toolResults = [];
+    for (const tc of toolCalls) {
+      log.info(`Calling ${chalk.cyan(tc.name)}${Object.keys(tc.input).length ? chalk.dim(" " + JSON.stringify(tc.input)) : ""}`);
+
+      const result = await executeTool(tc.name, tc.input);
+
+      if (result.error) {
+        log.error(result.error);
+      } else {
+        log.success(tc.name);
+      }
+
+      toolResults.push({
+        type: "tool_result",
+        tool_use_id: tc.id,
+        content: JSON.stringify(result),
+      });
+    }
+
+    messages.push({ role: "user", content: toolResults });
+  }
+
+  log.warn("Agent reached maximum iterations (10). Stopping.");
+}
+
+export function registerAgentCommand(program) {
+  program
+    .command("agent")
+    .argument("<request...>")
+    .description("AI agent — natural language command interface")
+    .action(async (requestParts) => {
+      const request = requestParts.join(" ");
+      try {
+        await runAgent(request);
+      } catch (err) {
+        log.error(err.message);
+      }
+    });
+}

package/src/commands/chat.js

@@ -0,0 +1,15 @@
+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/commands/memory.js

@@ -53,13 +53,21 @@ export async function showMemory(options = {}) {
 }
 
 export async function addMemory(content, category = "general") {
-  const { entry, count } = await apiClient.addMemory(content, category);
-  log.success(`Memory saved (${count} total). Category: ${chalk.cyan(entry.category)}`);
+  try {
+    const { entry, count } = await apiClient.addMemory(content, category);
+    log.success(`Memory saved (${count} total). Category: ${chalk.cyan(entry.category)}`);
+  } catch (err) {
+    throw err;
+  }
 }
 
 export async function clearMemory() {
-  await apiClient.clearMemory();
-  log.success("All memories cleared.");
+  try {
+    await apiClient.clearMemory();
+    log.success("All memories cleared.");
+  } catch (err) {
+    throw err;
+  }
 }
 
 export async function exportMemory(options = {}) {

package/src/lib/branding.js

@@ -0,0 +1,37 @@
+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",
+    bedrock: "anthropic.claude-opus-4-6-v1:0",
+  };
+  return defaults[provider] || "unknown";
+}

package/src/lib/config-store.js

@@ -74,5 +74,19 @@ function getDefaultConfig() {
       theme: "dark",
       fontSize: 14,
     },
+    ai: {
+      provider: "anthropic",
+      model: "",
+      keys: {
+        anthropic: "",
+        openai: "",
+        deepseek: "",
+        gemini: "",
+        bedrock: "",
+      },
+    },
+    bedrock: {
+      region: "us-east-1",
+    },
   };
 }

package/src/lib/logger.js

@@ -36,7 +36,7 @@ export const log = {
       console.log(chalk.dim(prefix) + " " + item);
     });
   },
-  banner(version = "0.1.0") {
+  banner(version = "0.2.0") {
     console.log();
     console.log(`   ${chalk.red("🍒")} ${chalk.red.bold("Cheri")}`);
     console.log(`   ${chalk.dim("AI-powered cloud IDE by HeySalad")}`);

package/src/lib/providers/anthropic.js

@@ -0,0 +1,66 @@
+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, options = {}) {
+    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: options.systemPrompt || 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

@@ -0,0 +1,34 @@
+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, options = {}) {
+    throw new Error("chat() must be implemented by subclass");
+  }
+
+  getModel() {
+    return this.model;
+  }
+}

package/src/lib/providers/bedrock.js

@@ -0,0 +1,7 @@
+import { OpenAIProvider } from "./openai.js";
+
+export class BedrockProvider extends OpenAIProvider {
+  constructor(apiKey, model = "anthropic.claude-opus-4-6-v1:0", region = "us-east-1") {
+    super(apiKey, model, `https://bedrock-runtime.${region}.amazonaws.com/openai/v1`);
+  }
+}