@heysalad/cheri-cli 0.5.0 → 0.6.0

package/README.md

@@ -1,6 +1,8 @@
-# Cheri CLI
+# cheri-cli
 
-AI-powered cloud IDE by [HeySalad](https://heysalad.app). Like Claude Code, but for cloud workspaces.
+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.
 
 ## Install
 
@@ -8,53 +10,79 @@ AI-powered cloud IDE by [HeySalad](https://heysalad.app). Like Claude Code, but
 npm install -g @heysalad/cheri-cli
 ```
 
-## Usage
+Requires Node.js 18+.
+
+## Quick Start
 
 ```bash
-# Login to your Cheri account
+# Authenticate with your Cheri account
 cheri login
 
+# Launch a cloud workspace
+cheri workspace launch owner/my-repo
+
 # Check account status
 cheri status
 
-# Launch a cloud workspace
-cheri workspace launch owner/repo
-
-# List your workspaces
-cheri workspace list
+# View API usage and rate limits
+cheri usage
+```
 
-# Stop a workspace
-cheri workspace stop
+## 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:
 
-# Initialize AI project config
-cheri init
+```
+$ cheri
+🍒 cheri > help
+🍒 cheri > workspace list
+🍒 cheri > usage
+🍒 cheri > exit
+```
 
-# Manage persistent memory
-cheri memory show
-cheri memory add "Always use TypeScript strict mode"
-cheri memory clear
+## Rate Limits
 
-# View/update configuration
-cheri config list
-cheri config set apiUrl https://cheri.heysalad.app
-```
+| Plan | Limit |
+|---|---|
+| Free | 100 requests/hour |
+| Pro | 1,000 requests/hour |
 
-## How it works
+Use `cheri usage` to check your current rate limit status.
 
-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
+## Configuration
 
-## Requirements
+Config is stored in `~/.cheri/`. Set the API URL if self-hosting:
 
-- Node.js >= 18
+```bash
+cheri config set apiUrl https://your-instance.example.com
+```
 
 ## Links
 
 - [Cheri Cloud IDE](https://cheri.heysalad.app)
-- [GitHub](https://github.com/Hey-Salad/cheri-cli)
+- [Dashboard](https://cheri.heysalad.app/dashboard)
+- [GitHub](https://github.com/chilu18/cloud-ide)
 
 ## License
 
-MIT - HeySalad
+MIT

package/bin/cheri.js

@@ -7,13 +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 { registerChatCommand } from "../src/commands/chat.js";
+import { registerUsageCommand } from "../src/commands/usage.js";
 import { registerAgentCommand } from "../src/commands/agent.js";
 
 program
   .name("cheri")
   .description("Cheri CLI - AI-powered cloud IDE by HeySalad")
-  .version("0.2.0");
+  .version("0.1.0");
 
 registerLoginCommand(program);
 registerInitCommand(program);
@@ -21,7 +21,7 @@ registerStatusCommand(program);
 registerMemoryCommand(program);
 registerConfigCommand(program);
 registerWorkspaceCommand(program);
-registerChatCommand(program);
+registerUsageCommand(program);
 registerAgentCommand(program);
 
 // If no args, launch interactive command REPL

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heysalad/cheri-cli",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Cheri CLI - AI-powered cloud IDE by HeySalad. Like Claude Code, but for cloud workspaces.",
   "type": "module",
   "bin": {
@@ -8,15 +8,14 @@
   },
   "files": [
     "bin/",
-    "src/",
-    "README.md"
+    "src/"
   ],
   "scripts": {
     "start": "node bin/cheri.js",
     "dev": "node bin/cheri.js",
-    "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"
+    "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"
   },
   "keywords": [
     "cloud-ide",
@@ -29,23 +28,18 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/Hey-Salad/cheri-cli.git"
+    "url": "https://github.com/chilu18/cloud-ide.git",
+    "directory": "cli"
   },
-  "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

@@ -1,6 +1,4 @@
 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";
 
@@ -8,96 +6,121 @@ const SYSTEM_PROMPT = `You are Cheri Agent, an AI assistant for the Cheri cloud
 
 const TOOLS = [
   {
-    name: "get_account_info",
-    description: "Get the current user's account information",
-    parameters: { type: "object", properties: {}, required: [] },
+    type: "function",
+    function: {
+      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: [] },
+    type: "function",
+    function: {
+      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" },
+    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"],
       },
-      required: ["repo"],
     },
   },
   {
-    name: "stop_workspace",
-    description: "Stop and delete a running workspace",
-    parameters: {
-      type: "object",
-      properties: {
-        id: { type: "string", description: "Workspace ID to stop" },
+    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"],
       },
-      required: ["id"],
     },
   },
   {
-    name: "get_workspace_status",
-    description: "Get the status of a specific workspace",
-    parameters: {
-      type: "object",
-      properties: {
-        id: { type: "string", description: "Workspace 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"],
       },
-      required: ["id"],
     },
   },
   {
-    name: "get_memory",
-    description: "Retrieve all stored memory entries",
-    parameters: { type: "object", properties: {}, required: [] },
+    type: "function",
+    function: {
+      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')" },
+    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"],
       },
-      required: ["content"],
     },
   },
   {
-    name: "clear_memory",
-    description: "Clear all stored memory entries",
-    parameters: { type: "object", properties: {}, required: [] },
+    type: "function",
+    function: {
+      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: [] },
+    type: "function",
+    function: {
+      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'" },
+    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"],
       },
-      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" },
+    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"],
       },
-      required: ["key", "value"],
     },
   },
 ];
@@ -123,11 +146,15 @@ async function executeTool(name, args) {
         return await apiClient.clearMemory();
       case "get_usage":
         return await apiClient.getUsage();
-      case "get_config":
+      case "get_config": {
+        const { getConfigValue } = await import("../lib/config-store.js");
         return { key: args.key, value: getConfigValue(args.key) };
-      case "set_config":
+      }
+      case "set_config": {
+        const { setConfigValue } = await import("../lib/config-store.js");
         setConfigValue(args.key, args.value);
         return { key: args.key, value: args.value, status: "updated" };
+      }
       default:
         return { error: `Unknown tool: ${name}` };
     }
@@ -136,72 +163,101 @@ async function executeTool(name, args) {
   }
 }
 
-export async function runAgent(userRequest) {
-  const providerName = getConfigValue("agent.provider") || getConfigValue("ai.provider") || "anthropic";
-  const model = getConfigValue("agent.model") || undefined;
+// Parse SSE stream from the cloud proxy
+async function* parseSSEStream(response) {
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  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() || "";
 
-  const provider = await createProvider({ provider: providerName, model });
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          const data = line.slice(6).trim();
+          if (data === "[DONE]") return;
+          try {
+            yield JSON.parse(data);
+          } catch {}
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
 
+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++) {
+    const response = await apiClient.chatStream(messages, TOOLS);
+
     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;
+    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) {
+        process.stdout.write(delta.content);
+        fullText += delta.content;
+      }
 
-        case "done":
-          break;
+      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);
+
     // No tool calls — final text response, done
-    if (toolCalls.length === 0) {
+    if (toolCallList.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 });
+    // Build assistant message with tool calls
+    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 },
+    }));
+    messages.push(assistantMsg);
+
+    // Execute each tool and add results
+    for (const tc of toolCallList) {
+      let input = {};
+      try { input = JSON.parse(tc.arguments); } catch {}
 
-    // 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)) : ""}`);
+      log.info(`Calling ${chalk.cyan(tc.name)}${Object.keys(input).length ? chalk.dim(" " + JSON.stringify(input)) : ""}`);
 
-      const result = await executeTool(tc.name, tc.input);
+      const result = await executeTool(tc.name, input);
 
       if (result.error) {
         log.error(result.error);
@@ -209,14 +265,12 @@ export async function runAgent(userRequest) {
         log.success(tc.name);
       }
 
-      toolResults.push({
-        type: "tool_result",
-        tool_use_id: tc.id,
+      messages.push({
+        role: "tool",
+        tool_call_id: tc.id,
         content: JSON.stringify(result),
       });
     }
-
-    messages.push({ role: "user", content: toolResults });
   }
 
   log.warn("Agent reached maximum iterations (10). Stopping.");

package/src/commands/memory.js

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

package/src/commands/usage.js

@@ -0,0 +1,64 @@
+import chalk from "chalk";
+import ora from "ora";
+import { apiClient } from "../lib/api-client.js";
+import { log } from "../lib/logger.js";
+
+export async function showUsage() {
+  log.blank();
+  log.brand("Usage");
+
+  const spinner = ora("Fetching usage data...").start();
+
+  try {
+    const data = await apiClient.getUsage();
+    spinner.stop();
+
+    // Rate limit
+    log.header("Rate Limit");
+    log.keyValue("Plan", data.plan === "pro" ? chalk.green("Pro") : "Free");
+    log.keyValue("Limit", `${data.rateLimit.limit} requests/hour`);
+    const remaining = data.rateLimit.remaining;
+    const limit = data.rateLimit.limit;
+    const remainColor = remaining > limit * 0.5 ? chalk.green : remaining > limit * 0.1 ? chalk.yellow : chalk.red;
+    log.keyValue("Remaining", remainColor(`${remaining}`));
+    log.keyValue("Resets at", data.rateLimit.resetsAt);
+
+    // Today's usage
+    log.header("Today");
+    log.keyValue("Requests", `${data.usage.today.requests}`);
+    const endpoints = data.usage.today.endpoints || {};
+    if (Object.keys(endpoints).length > 0) {
+      for (const [ep, count] of Object.entries(endpoints)) {
+        console.log(`    ${chalk.dim(ep)} ${chalk.cyan(count)}`);
+      }
+    }
+
+    // Summary
+    log.header("Summary");
+    log.keyValue("Last 7 days", `${data.usage.last7d.requests} requests`);
+    log.keyValue("Last 30 days", `${data.usage.last30d.requests} requests`);
+    log.keyValue("All time", `${data.summary.totalRequests} requests`);
+    if (data.summary.memberSince) {
+      log.keyValue("Member since", new Date(data.summary.memberSince).toLocaleDateString());
+    }
+  } catch (err) {
+    spinner.stop();
+    log.error(err.message);
+  }
+
+  log.blank();
+}
+
+export function registerUsageCommand(program) {
+  program
+    .command("usage")
+    .description("Show API usage and rate limit status")
+    .action(async () => {
+      try {
+        await showUsage();
+      } catch (err) {
+        log.error(err.message);
+        process.exit(1);
+      }
+    });
+}