@heysalad/cheri-cli 0.1.0 → 0.3.0

package/README.md

@@ -1,60 +1,88 @@
-# 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
 
 ```bash
-npm install -g @heysalad/cheri-cli
+npm install -g 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,6 +7,7 @@ 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";
 
 program
   .name("cheri")
@@ -19,10 +20,12 @@ registerStatusCommand(program);
 registerMemoryCommand(program);
 registerConfigCommand(program);
 registerWorkspaceCommand(program);
+registerUsageCommand(program);
 
-program.parse(process.argv);
-
-// Show help if no command provided
+// If no args, launch interactive command REPL
 if (!process.argv.slice(2).length) {
-  program.outputHelp();
+  const { startCommandRepl } = await import("../src/repl.js");
+  await startCommandRepl();
+} else {
+  program.parse(process.argv);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heysalad/cheri-cli",
-  "version": "0.1.0",
+  "version": "0.3.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,9 +28,9 @@
   ],
   "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": {

package/src/commands/config.js

@@ -2,6 +2,42 @@ import chalk from "chalk";
 import { getConfig, getConfigValue, setConfigValue } from "../lib/config-store.js";
 import { log } from "../lib/logger.js";
 
+export function listConfig() {
+  const cfg = getConfig();
+
+  log.blank();
+  log.brand("Configuration");
+  log.blank();
+
+  printObject(cfg, "");
+  log.blank();
+}
+
+export function getConfigKey(key) {
+  const value = getConfigValue(key);
+  if (value === undefined) {
+    throw new Error(`Key '${key}' not found.`);
+  }
+  if (typeof value === "object") {
+    console.log(JSON.stringify(value, null, 2));
+  } else {
+    console.log(value);
+  }
+}
+
+export function setConfigKey(key, value) {
+  // Try to parse as JSON (for arrays, numbers, booleans)
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    parsed = value;
+  }
+
+  setConfigValue(key, parsed);
+  log.success(`Set ${chalk.cyan(key)} = ${chalk.white(value)}`);
+}
+
 export function registerConfigCommand(program) {
   const config = program
     .command("config")
@@ -11,46 +47,26 @@ export function registerConfigCommand(program) {
     .command("list")
     .description("Show all configuration values")
     .action(() => {
-      const cfg = getConfig();
-
-      log.blank();
-      log.brand("Configuration");
-      log.blank();
-
-      printObject(cfg, "");
-      log.blank();
+      listConfig();
     });
 
   config
     .command("get <key>")
     .description("Get a configuration value")
     .action((key) => {
-      const value = getConfigValue(key);
-      if (value === undefined) {
-        log.error(`Key '${key}' not found.`);
+      try {
+        getConfigKey(key);
+      } catch (err) {
+        log.error(err.message);
         process.exit(1);
       }
-      if (typeof value === "object") {
-        console.log(JSON.stringify(value, null, 2));
-      } else {
-        console.log(value);
-      }
     });
 
   config
     .command("set <key> <value>")
     .description("Set a configuration value")
     .action((key, value) => {
-      // Try to parse as JSON (for arrays, numbers, booleans)
-      let parsed;
-      try {
-        parsed = JSON.parse(value);
-      } catch {
-        parsed = value;
-      }
-
-      setConfigValue(key, parsed);
-      log.success(`Set ${chalk.cyan(key)} = ${chalk.white(value)}`);
+      setConfigKey(key, value);
     });
 }
 

package/src/commands/init.js

@@ -1,7 +1,7 @@
 import ora from "ora";
 import inquirer from "inquirer";
 import chalk from "chalk";
-import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync } from "fs";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
 import { join } from "path";
 import { setConfigValue } from "../lib/config-store.js";
 import { log } from "../lib/logger.js";
@@ -79,6 +79,86 @@ const TEMPLATES = {
 `,
 };
 
+export async function initProject(options = {}) {
+  log.blank();
+  log.brand("Initializing project...");
+  log.blank();
+
+  const aiDir = join(process.cwd(), AI_DIR);
+
+  if (existsSync(aiDir) && !options.yes) {
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: "A .ai/ directory already exists. Add missing files?",
+        default: true,
+      },
+    ]);
+    if (!overwrite) {
+      log.info("Initialization cancelled.");
+      return;
+    }
+  }
+
+  let projectName = options.name;
+  if (!projectName && !options.yes) {
+    const answers = await inquirer.prompt([
+      {
+        type: "input",
+        name: "name",
+        message: "Project name:",
+        default: process.cwd().split("/").pop(),
+      },
+    ]);
+    projectName = answers.name;
+  }
+
+  projectName = projectName || process.cwd().split("/").pop();
+
+  const spinner = ora("Creating project constitution...").start();
+
+  try {
+    if (!existsSync(aiDir)) {
+      mkdirSync(aiDir, { recursive: true });
+    }
+
+    const created = [];
+    for (const [filename, content] of Object.entries(TEMPLATES)) {
+      const filePath = join(aiDir, filename);
+      if (!existsSync(filePath)) {
+        writeFileSync(filePath, content);
+        created.push(filename);
+      }
+    }
+
+    spinner.succeed("Project constitution created");
+    log.blank();
+
+    if (created.length > 0) {
+      created.forEach((file) => {
+        console.log(`  ${chalk.green("+")} .ai/${file}`);
+      });
+    } else {
+      log.info("All constitution files already exist.");
+    }
+
+    // Save project config
+    setConfigValue("project.name", projectName);
+    setConfigValue("project.initializedAt", new Date().toISOString());
+
+    log.blank();
+    log.success(`Project '${chalk.bold(projectName)}' initialized.`);
+    log.dim(
+      `Run ${chalk.cyan("cheri workspace launch owner/repo")} to start coding in the cloud.`
+    );
+    log.blank();
+  } catch (err) {
+    spinner.fail("Failed to initialize project");
+    throw err;
+  }
+}
+
 export function registerInitCommand(program) {
   program
     .command("init")
@@ -86,81 +166,9 @@ export function registerInitCommand(program) {
     .option("-n, --name <name>", "Project name")
     .option("-y, --yes", "Skip prompts and use defaults")
     .action(async (options) => {
-      log.blank();
-      log.brand("Initializing project...");
-      log.blank();
-
-      const aiDir = join(process.cwd(), AI_DIR);
-
-      if (existsSync(aiDir) && !options.yes) {
-        const { overwrite } = await inquirer.prompt([
-          {
-            type: "confirm",
-            name: "overwrite",
-            message: "A .ai/ directory already exists. Add missing files?",
-            default: true,
-          },
-        ]);
-        if (!overwrite) {
-          log.info("Initialization cancelled.");
-          return;
-        }
-      }
-
-      let projectName = options.name;
-      if (!projectName && !options.yes) {
-        const answers = await inquirer.prompt([
-          {
-            type: "input",
-            name: "name",
-            message: "Project name:",
-            default: process.cwd().split("/").pop(),
-          },
-        ]);
-        projectName = answers.name;
-      }
-
-      projectName = projectName || process.cwd().split("/").pop();
-
-      const spinner = ora("Creating project constitution...").start();
-
       try {
-        if (!existsSync(aiDir)) {
-          mkdirSync(aiDir, { recursive: true });
-        }
-
-        const created = [];
-        for (const [filename, content] of Object.entries(TEMPLATES)) {
-          const filePath = join(aiDir, filename);
-          if (!existsSync(filePath)) {
-            writeFileSync(filePath, content);
-            created.push(filename);
-          }
-        }
-
-        spinner.succeed("Project constitution created");
-        log.blank();
-
-        if (created.length > 0) {
-          created.forEach((file) => {
-            console.log(`  ${chalk.green("+")} .ai/${file}`);
-          });
-        } else {
-          log.info("All constitution files already exist.");
-        }
-
-        // Save project config
-        setConfigValue("project.name", projectName);
-        setConfigValue("project.initializedAt", new Date().toISOString());
-
-        log.blank();
-        log.success(`Project '${chalk.bold(projectName)}' initialized.`);
-        log.dim(
-          `Run ${chalk.cyan("cheri workspace launch owner/repo")} to start coding in the cloud.`
-        );
-        log.blank();
+        await initProject(options);
       } catch (err) {
-        spinner.fail("Failed to initialize project");
         log.error(err.message);
         process.exit(1);
       }

package/src/commands/login.js

@@ -4,53 +4,60 @@ import { setConfigValue, getConfigValue } from "../lib/config-store.js";
 import { apiClient } from "../lib/api-client.js";
 import { log } from "../lib/logger.js";
 
+export async function loginFlow() {
+  const apiUrl = getConfigValue("apiUrl") || "https://cheri.heysalad.app";
+
+  log.blank();
+  log.brand("Login to Cheri");
+  log.blank();
+
+  log.info("Step 1: Open this URL in your browser to authenticate:");
+  log.blank();
+  console.log(`  ${chalk.cyan.underline(`${apiUrl}/auth/github`)}`);
+  log.blank();
+  log.info("Step 2: After login, visit the token page:");
+  console.log(`  ${chalk.cyan.underline(`${apiUrl}/auth/token?user=YOUR_USERNAME`)}`);
+  log.blank();
+  log.info("Step 3: Copy your API token and paste it below.");
+  log.blank();
+
+  const { token } = await inquirer.prompt([
+    {
+      type: "password",
+      name: "token",
+      message: "Paste your API token:",
+      mask: "*",
+    },
+  ]);
+
+  if (!token || !token.trim()) {
+    throw new Error("No token provided.");
+  }
+
+  setConfigValue("token", token.trim());
+
+  // Verify token works
+  try {
+    const me = await apiClient.getMe();
+    log.blank();
+    log.success(`Logged in as ${chalk.cyan(me.ghLogin || me.userId)}`);
+    log.keyValue("Plan", me.plan === "pro" ? chalk.green("Pro") : "Free");
+    log.blank();
+  } catch (err) {
+    setConfigValue("token", "");
+    throw new Error(`Token verification failed: ${err.message}`);
+  }
+}
+
 export function registerLoginCommand(program) {
   program
     .command("login")
     .description("Authenticate with Cheri cloud IDE")
     .action(async () => {
-      const apiUrl = getConfigValue("apiUrl") || "https://cheri.heysalad.app";
-
-      log.blank();
-      log.brand("Login to Cheri");
-      log.blank();
-
-      log.info("Step 1: Open this URL in your browser to authenticate:");
-      log.blank();
-      console.log(`  ${chalk.cyan.underline(`${apiUrl}/auth/github`)}`);
-      log.blank();
-      log.info("Step 2: After login, visit the token page:");
-      console.log(`  ${chalk.cyan.underline(`${apiUrl}/auth/token?user=YOUR_USERNAME`)}`);
-      log.blank();
-      log.info("Step 3: Copy your API token and paste it below.");
-      log.blank();
-
-      const { token } = await inquirer.prompt([
-        {
-          type: "password",
-          name: "token",
-          message: "Paste your API token:",
-          mask: "*",
-        },
-      ]);
-
-      if (!token || !token.trim()) {
-        log.error("No token provided.");
-        process.exit(1);
-      }
-
-      setConfigValue("token", token.trim());
-
-      // Verify token works
       try {
-        const me = await apiClient.getMe();
-        log.blank();
-        log.success(`Logged in as ${chalk.cyan(me.ghLogin || me.userId)}`);
-        log.keyValue("Plan", me.plan === "pro" ? chalk.green("Pro") : "Free");
-        log.blank();
+        await loginFlow();
       } catch (err) {
-        log.error(`Token verification failed: ${err.message}`);
-        setConfigValue("token", "");
+        log.error(err.message);
         process.exit(1);
       }
     });

package/src/commands/memory.js

@@ -4,6 +4,86 @@ import { writeFileSync } from "fs";
 import { apiClient } from "../lib/api-client.js";
 import { log } from "../lib/logger.js";
 
+export async function showMemory(options = {}) {
+  const spinner = ora("Fetching memories...").start();
+
+  try {
+    const { memories } = await apiClient.getMemory();
+    spinner.stop();
+
+    log.blank();
+    log.brand("AI Memory");
+    log.blank();
+    log.keyValue("Entries", `${memories.length}`);
+
+    if (memories.length === 0) {
+      log.blank();
+      log.dim("  No memories yet. Use 'memory add <content>' to store context.");
+      log.blank();
+      return;
+    }
+
+    const limit = parseInt(options.limit || "10");
+    const recent = memories.slice(-limit);
+
+    log.keyValue(
+      "Last updated",
+      memories.length > 0
+        ? timeSince(new Date(memories[memories.length - 1].timestamp))
+        : "never"
+    );
+
+    log.blank();
+    log.dim("  Recent memories:");
+
+    recent.forEach((entry) => {
+      const category = chalk.dim(`(${entry.category})`);
+      const content =
+        entry.content.length > 60
+          ? entry.content.slice(0, 60) + "..."
+          : entry.content;
+      console.log(`  ${chalk.dim("-")} "${content}" ${category}`);
+    });
+
+    log.blank();
+  } catch (err) {
+    spinner.fail("Failed to fetch memories");
+    throw err;
+  }
+}
+
+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)}`);
+}
+
+export async function clearMemory() {
+  await apiClient.clearMemory();
+  log.success("All memories cleared.");
+}
+
+export async function exportMemory(options = {}) {
+  const spinner = ora("Exporting memories...").start();
+
+  try {
+    const { memories } = await apiClient.getMemory();
+
+    const exportData = {
+      version: "0.1.0",
+      exportedAt: new Date().toISOString(),
+      entryCount: memories.length,
+      entries: memories,
+    };
+
+    const outputFile = options.output || `cheri-memory-export.json`;
+    writeFileSync(outputFile, JSON.stringify(exportData, null, 2));
+    spinner.succeed(`Exported ${memories.length} entries to ${chalk.cyan(outputFile)}`);
+  } catch (err) {
+    spinner.fail("Failed to export memories");
+    throw err;
+  }
+}
+
 export function registerMemoryCommand(program) {
   const memory = program
     .command("memory")
@@ -14,49 +94,9 @@ export function registerMemoryCommand(program) {
     .description("Show current memory entries")
     .option("-l, --limit <n>", "Number of entries to show", "10")
     .action(async (options) => {
-      const spinner = ora("Fetching memories...").start();
-
       try {
-        const { memories } = await apiClient.getMemory();
-        spinner.stop();
-
-        log.blank();
-        log.brand("AI Memory");
-        log.blank();
-        log.keyValue("Entries", `${memories.length}`);
-
-        if (memories.length === 0) {
-          log.blank();
-          log.dim("  No memories yet. Use 'cheri memory add' to store context.");
-          log.blank();
-          return;
-        }
-
-        const limit = parseInt(options.limit);
-        const recent = memories.slice(-limit);
-
-        log.keyValue(
-          "Last updated",
-          memories.length > 0
-            ? timeSince(new Date(memories[memories.length - 1].timestamp))
-            : "never"
-        );
-
-        log.blank();
-        log.dim("  Recent memories:");
-
-        recent.forEach((entry) => {
-          const category = chalk.dim(`(${entry.category})`);
-          const content =
-            entry.content.length > 60
-              ? entry.content.slice(0, 60) + "..."
-              : entry.content;
-          console.log(`  ${chalk.dim("-")} "${content}" ${category}`);
-        });
-
-        log.blank();
+        await showMemory(options);
       } catch (err) {
-        spinner.fail("Failed to fetch memories");
         log.error(err.message);
         process.exit(1);
       }
@@ -69,8 +109,7 @@ export function registerMemoryCommand(program) {
     .option("-c, --category <category>", "Category", "general")
     .action(async (content, options) => {
       try {
-        const { entry, count } = await apiClient.addMemory(content, options.category);
-        log.success(`Memory saved (${count} total). Category: ${chalk.cyan(entry.category)}`);
+        await addMemory(content, options.category);
       } catch (err) {
         log.error(err.message);
         process.exit(1);
@@ -82,8 +121,7 @@ export function registerMemoryCommand(program) {
     .description("Clear all memory")
     .action(async () => {
       try {
-        await apiClient.clearMemory();
-        log.success("All memories cleared.");
+        await clearMemory();
       } catch (err) {
         log.error(err.message);
         process.exit(1);
@@ -95,23 +133,9 @@ export function registerMemoryCommand(program) {
     .description("Export memory to JSON file")
     .option("-o, --output <file>", "Output file path")
     .action(async (options) => {
-      const spinner = ora("Exporting memories...").start();
-
       try {
-        const { memories } = await apiClient.getMemory();
-
-        const exportData = {
-          version: "0.1.0",
-          exportedAt: new Date().toISOString(),
-          entryCount: memories.length,
-          entries: memories,
-        };
-
-        const outputFile = options.output || `cheri-memory-export.json`;
-        writeFileSync(outputFile, JSON.stringify(exportData, null, 2));
-        spinner.succeed(`Exported ${memories.length} entries to ${chalk.cyan(outputFile)}`);
+        await exportMemory(options);
       } catch (err) {
-        spinner.fail("Failed to export memories");
         log.error(err.message);
         process.exit(1);
       }

package/src/commands/status.js

@@ -4,53 +4,63 @@ import { getConfigValue } from "../lib/config-store.js";
 import { apiClient } from "../lib/api-client.js";
 import { log } from "../lib/logger.js";
 
+export async function showStatus() {
+  log.blank();
+  log.brand("Status");
+
+  // Account info
+  log.header("Account");
+  const spinner = ora("Fetching account info...").start();
+
+  try {
+    const me = await apiClient.getMe();
+    spinner.stop();
+
+    log.keyValue("User", chalk.cyan(me.ghLogin || me.userId));
+    log.keyValue("Plan", me.plan === "pro" ? chalk.green("Pro") : "Free");
+  } catch (err) {
+    spinner.stop();
+    log.keyValue("User", chalk.yellow("Not logged in"));
+    log.dim(`  Run ${chalk.cyan("cheri login")} to authenticate.`);
+  }
+
+  // Workspaces
+  log.header("Workspaces");
+  try {
+    const { workspaces } = await apiClient.listWorkspaces();
+    if (workspaces.length === 0) {
+      log.keyValue("Count", "0");
+      log.dim(`  Run ${chalk.cyan("cheri workspace launch owner/repo")} to create one.`);
+    } else {
+      log.keyValue("Count", `${workspaces.length}`);
+      workspaces.forEach((ws) => {
+        const statusIcon = ws.status === "running" ? chalk.green("●") : chalk.dim("○");
+        const statusColor = ws.status === "running" ? chalk.green : chalk.dim;
+        console.log(`    ${statusIcon} ${ws.id} (${ws.repo || ws.id}) — ${statusColor(ws.status)}`);
+      });
+    }
+  } catch {
+    log.dim("  Could not fetch workspaces.");
+  }
+
+  // Config info
+  log.header("Configuration");
+  log.keyValue("API URL", getConfigValue("apiUrl") || "https://cheri.heysalad.app");
+  log.keyValue("Config dir", chalk.dim("~/.cheri/"));
+
+  log.blank();
+}
+
 export function registerStatusCommand(program) {
   program
     .command("status")
     .description("Show account and workspace status")
     .action(async () => {
-      log.blank();
-      log.brand("Status");
-
-      // Account info
-      log.header("Account");
-      const spinner = ora("Fetching account info...").start();
-
       try {
-        const me = await apiClient.getMe();
-        spinner.stop();
-
-        log.keyValue("User", chalk.cyan(me.ghLogin || me.userId));
-        log.keyValue("Plan", me.plan === "pro" ? chalk.green("Pro") : "Free");
+        await showStatus();
       } catch (err) {
-        spinner.stop();
-        log.keyValue("User", chalk.yellow("Not logged in"));
-        log.dim(`  Run ${chalk.cyan("cheri login")} to authenticate.`);
-      }
-
-      // Workspaces
-      log.header("Workspaces");
-      try {
-        const { workspaces } = await apiClient.listWorkspaces();
-        if (workspaces.length === 0) {
-          log.keyValue("Count", "0");
-          log.dim(`  Run ${chalk.cyan("cheri workspace launch owner/repo")} to create one.`);
-        } else {
-          log.keyValue("Count", `${workspaces.length}`);
-          workspaces.forEach((ws) => {
-            const statusColor = ws.status === "running" ? chalk.green : chalk.dim;
-            console.log(`    ${statusColor("●")} ${ws.id} (${ws.repo || ws.id}) — ${statusColor(ws.status)}`);
-          });
-        }
-      } catch {
-        log.dim("  Could not fetch workspaces.");
+        log.error(err.message);
+        process.exit(1);
       }
-
-      // Config info
-      log.header("Configuration");
-      log.keyValue("API URL", getConfigValue("apiUrl") || "https://cheri.heysalad.app");
-      log.keyValue("Config dir", chalk.dim("~/.cheri/"));
-
-      log.blank();
     });
 }

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);
+      }
+    });
+}

package/src/commands/workspace.js

@@ -3,6 +3,105 @@ import ora from "ora";
 import { apiClient } from "../lib/api-client.js";
 import { log } from "../lib/logger.js";
 
+export async function launchWorkspace(repo) {
+  log.blank();
+  log.brand("Launching workspace");
+  log.blank();
+
+  const spinner = ora("Creating workspace...").start();
+
+  try {
+    const { workspace: ws } = await apiClient.createWorkspace(repo);
+    spinner.succeed("Workspace is live!");
+
+    log.blank();
+    log.keyValue("ID", chalk.cyan(ws.id));
+    log.keyValue("Repo", chalk.cyan(ws.repo));
+    log.keyValue("Status", chalk.green(ws.status));
+    log.keyValue("URL", chalk.cyan.underline(ws.url));
+    log.blank();
+    log.dim("Open the URL above in your browser to start coding.");
+    log.blank();
+  } catch (err) {
+    spinner.fail("Failed to launch workspace");
+    throw err;
+  }
+}
+
+export async function stopWorkspace(id) {
+  const spinner = ora(`Stopping workspace: ${id}...`).start();
+
+  try {
+    await apiClient.deleteWorkspace(id);
+    spinner.succeed(`Workspace '${chalk.cyan(id)}' stopped.`);
+    log.dim("  Data preserved. Launch again to resume.");
+  } catch (err) {
+    spinner.fail("Failed to stop workspace");
+    throw err;
+  }
+}
+
+export async function listWorkspaces() {
+  const spinner = ora("Fetching workspaces...").start();
+
+  try {
+    const { workspaces } = await apiClient.listWorkspaces();
+    spinner.stop();
+
+    log.blank();
+    log.brand("Workspaces");
+    log.blank();
+
+    if (workspaces.length === 0) {
+      log.dim("  No workspaces found. Run 'cheri workspace launch owner/repo' to create one.");
+      log.blank();
+      return;
+    }
+
+    // Table header
+    console.log(
+      `  ${chalk.dim("ID".padEnd(24))} ${chalk.dim("REPO".padEnd(24))} ${chalk.dim("STATUS".padEnd(10))} ${chalk.dim("URL")}`
+    );
+    console.log(chalk.dim("  " + "─".repeat(90)));
+
+    workspaces.forEach((ws) => {
+      const statusIcon =
+        ws.status === "running" ? chalk.green("●") : chalk.dim("○");
+      const statusColor =
+        ws.status === "running" ? chalk.green : chalk.dim;
+      console.log(
+        `  ${ws.id.padEnd(24)} ${(ws.repo || "").padEnd(24)} ${statusIcon} ${statusColor(ws.status.padEnd(9))} ${chalk.cyan(ws.url || "")}`
+      );
+    });
+
+    log.blank();
+  } catch (err) {
+    spinner.fail("Failed to fetch workspaces");
+    throw err;
+  }
+}
+
+export async function getWorkspaceStatus(id) {
+  const spinner = ora("Fetching workspace status...").start();
+
+  try {
+    const { workspace: ws } = await apiClient.getWorkspaceStatus(id);
+    spinner.stop();
+
+    log.blank();
+    log.brand(`Workspace: ${ws.id}`);
+    log.blank();
+    log.keyValue("Status", ws.status === "running" ? chalk.green("● " + ws.status) : chalk.dim("○ " + ws.status));
+    log.keyValue("Repo", chalk.cyan(ws.repo || ""));
+    log.keyValue("URL", chalk.cyan.underline(ws.url || ""));
+    log.keyValue("Created", new Date(ws.createdAt).toLocaleString());
+    log.blank();
+  } catch (err) {
+    spinner.fail("Failed to fetch workspace status");
+    throw err;
+  }
+}
+
 export function registerWorkspaceCommand(program) {
   const workspace = program
     .command("workspace")
@@ -13,26 +112,9 @@ export function registerWorkspaceCommand(program) {
     .description("Launch a new cloud workspace")
     .argument("<repo>", "GitHub repository (owner/repo)")
     .action(async (repo) => {
-      log.blank();
-      log.brand("Launching workspace");
-      log.blank();
-
-      const spinner = ora("Creating workspace...").start();
-
       try {
-        const { workspace: ws } = await apiClient.createWorkspace(repo);
-        spinner.succeed("Workspace is live!");
-
-        log.blank();
-        log.keyValue("ID", chalk.cyan(ws.id));
-        log.keyValue("Repo", chalk.cyan(ws.repo));
-        log.keyValue("Status", chalk.green(ws.status));
-        log.keyValue("URL", chalk.cyan.underline(ws.url));
-        log.blank();
-        log.dim("Open the URL above in your browser to start coding.");
-        log.blank();
+        await launchWorkspace(repo);
       } catch (err) {
-        spinner.fail("Failed to launch workspace");
         log.error(err.message);
         process.exit(1);
       }
@@ -43,14 +125,9 @@ export function registerWorkspaceCommand(program) {
     .description("Stop a running workspace")
     .argument("<id>", "Workspace ID")
     .action(async (id) => {
-      const spinner = ora(`Stopping workspace: ${id}...`).start();
-
       try {
-        await apiClient.deleteWorkspace(id);
-        spinner.succeed(`Workspace '${chalk.cyan(id)}' stopped.`);
-        log.dim("  Data preserved. Launch again to resume.");
+        await stopWorkspace(id);
       } catch (err) {
-        spinner.fail("Failed to stop workspace");
         log.error(err.message);
         process.exit(1);
       }
@@ -60,39 +137,9 @@ export function registerWorkspaceCommand(program) {
     .command("list")
     .description("List all workspaces")
     .action(async () => {
-      const spinner = ora("Fetching workspaces...").start();
-
       try {
-        const { workspaces } = await apiClient.listWorkspaces();
-        spinner.stop();
-
-        log.blank();
-        log.brand("Workspaces");
-        log.blank();
-
-        if (workspaces.length === 0) {
-          log.dim("  No workspaces found. Run 'cheri workspace launch owner/repo' to create one.");
-          log.blank();
-          return;
-        }
-
-        // Table header
-        console.log(
-          `  ${chalk.dim("ID".padEnd(24))} ${chalk.dim("REPO".padEnd(24))} ${chalk.dim("STATUS".padEnd(10))} ${chalk.dim("URL")}`
-        );
-        console.log(chalk.dim("  " + "-".repeat(90)));
-
-        workspaces.forEach((ws) => {
-          const statusColor =
-            ws.status === "running" ? chalk.green : chalk.dim;
-          console.log(
-            `  ${ws.id.padEnd(24)} ${(ws.repo || "").padEnd(24)} ${statusColor(ws.status.padEnd(10))} ${chalk.cyan(ws.url || "")}`
-          );
-        });
-
-        log.blank();
+        await listWorkspaces();
       } catch (err) {
-        spinner.fail("Failed to fetch workspaces");
         log.error(err.message);
         process.exit(1);
       }
@@ -103,22 +150,9 @@ export function registerWorkspaceCommand(program) {
     .description("Get workspace status")
     .argument("<id>", "Workspace ID")
     .action(async (id) => {
-      const spinner = ora("Fetching workspace status...").start();
-
       try {
-        const { workspace: ws } = await apiClient.getWorkspaceStatus(id);
-        spinner.stop();
-
-        log.blank();
-        log.brand(`Workspace: ${ws.id}`);
-        log.blank();
-        log.keyValue("Status", ws.status === "running" ? chalk.green(ws.status) : chalk.dim(ws.status));
-        log.keyValue("Repo", chalk.cyan(ws.repo || ""));
-        log.keyValue("URL", chalk.cyan.underline(ws.url || ""));
-        log.keyValue("Created", new Date(ws.createdAt).toLocaleString());
-        log.blank();
+        await getWorkspaceStatus(id);
       } catch (err) {
-        spinner.fail("Failed to fetch workspace status");
         log.error(err.message);
         process.exit(1);
       }

package/src/lib/api-client.js

@@ -83,4 +83,9 @@ export const apiClient = {
   async clearMemory() {
     return request("/api/memory", { method: "DELETE" });
   },
+
+  // Usage
+  async getUsage() {
+    return request("/api/usage");
+  },
 };

package/src/lib/logger.js

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

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);
+  });
+}