@heysalad/cheri-cli 0.3.0 → 0.4.0

package/README.md

@@ -1,88 +1,60 @@
-# 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
 
 ```bash
-npm install -g cheri-cli
+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.0",
+  "version": "0.4.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,272 @@
+import { apiClient } from "../lib/api-client.js";
+import { getConfigValue, setConfigValue } from "../lib/config-store.js";
+import { streamChatCompletion } from "../lib/deepseek-client.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 = [
+  {
+    type: "function",
+    function: {
+      name: "get_account_info",
+      description: "Get the current user's account information",
+      parameters: { type: "object", properties: {}, required: [] },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "list_workspaces",
+      description: "List all cloud workspaces for the current user",
+      parameters: { type: "object", properties: {}, required: [] },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      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"],
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "stop_workspace",
+      description: "Stop and delete a running workspace",
+      parameters: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Workspace ID to stop" },
+        },
+        required: ["id"],
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "get_workspace_status",
+      description: "Get the status of a specific workspace",
+      parameters: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Workspace ID" },
+        },
+        required: ["id"],
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "get_memory",
+      description: "Retrieve all stored memory entries",
+      parameters: { type: "object", properties: {}, required: [] },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      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"],
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "clear_memory",
+      description: "Clear all stored memory entries",
+      parameters: { type: "object", properties: {}, required: [] },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "get_usage",
+      description: "Get the user's API usage and rate limit statistics",
+      parameters: { type: "object", properties: {}, required: [] },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      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"],
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      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 messages = [
+    { role: "system", content: SYSTEM_PROMPT },
+    { role: "user", content: userRequest },
+  ];
+
+  const MAX_ITERATIONS = 10;
+
+  for (let i = 0; i < MAX_ITERATIONS; i++) {
+    let textContent = "";
+    const toolCalls = {};
+
+    for await (const chunk of streamChatCompletion(messages, TOOLS)) {
+      const delta = chunk.choices?.[0]?.delta;
+      if (!delta) continue;
+
+      // Stream text content to stdout
+      if (delta.content) {
+        process.stdout.write(delta.content);
+        textContent += delta.content;
+      }
+
+      // Accumulate tool call deltas
+      if (delta.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          const idx = tc.index;
+          if (!toolCalls[idx]) {
+            toolCalls[idx] = { id: tc.id || "", function: { name: "", arguments: "" } };
+          }
+          if (tc.id) toolCalls[idx].id = tc.id;
+          if (tc.function?.name) toolCalls[idx].function.name += tc.function.name;
+          if (tc.function?.arguments) toolCalls[idx].function.arguments += tc.function.arguments;
+        }
+      }
+    }
+
+    const toolCallList = Object.values(toolCalls);
+
+    // No tool calls — final text response, done
+    if (toolCallList.length === 0) {
+      if (textContent) process.stdout.write("\n");
+      return;
+    }
+
+    // Append assistant message with tool calls
+    const assistantMsg = { role: "assistant", content: textContent || null, tool_calls: [] };
+    for (const tc of toolCallList) {
+      assistantMsg.tool_calls.push({
+        id: tc.id,
+        type: "function",
+        function: { name: tc.function.name, arguments: tc.function.arguments },
+      });
+    }
+    messages.push(assistantMsg);
+
+    // Execute each tool call and append results
+    for (const tc of toolCallList) {
+      const fnName = tc.function.name;
+      let args = {};
+      try {
+        args = JSON.parse(tc.function.arguments || "{}");
+      } catch {
+        args = {};
+      }
+
+      log.info(`Calling ${chalk.cyan(fnName)}${Object.keys(args).length ? chalk.dim(" " + JSON.stringify(args)) : ""}`);
+
+      const result = await executeTool(fnName, args);
+      const resultStr = JSON.stringify(result);
+
+      if (result.error) {
+        log.error(result.error);
+      } else {
+        log.success(fnName);
+      }
+
+      messages.push({
+        role: "tool",
+        tool_call_id: tc.id,
+        content: resultStr,
+      });
+    }
+  }
+
+  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,36 @@
+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/config-store.js

@@ -74,5 +74,15 @@ function getDefaultConfig() {
       theme: "dark",
       fontSize: 14,
     },
+    ai: {
+      provider: "anthropic",
+      model: "",
+      keys: {
+        anthropic: "",
+        openai: "",
+        deepseek: "",
+        gemini: "",
+      },
+    },
   };
 }

package/src/lib/deepseek-client.js

@@ -0,0 +1,64 @@
+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/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")}`);