@heysalad/cheri-cli 0.6.0 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heysalad/cheri-cli",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Cheri CLI - AI-powered cloud IDE by HeySalad. Like Claude Code, but for cloud workspaces.",
   "type": "module",
   "bin": {

package/src/commands/agent.js

@@ -1,151 +1,68 @@
 import { apiClient } from "../lib/api-client.js";
 import { log } from "../lib/logger.js";
+import { getToolDefinitions, executeTool as executeLocalTool, requiresConfirmation } from "../lib/tools/index.js";
 import chalk from "chalk";
+import readline from "readline";
+
+const SYSTEM_PROMPT = `You are Cheri, an AI coding assistant by HeySalad. You are a powerful agentic coding tool that can read, write, edit, and search code, execute shell commands, and manage cloud workspaces.
+
+You have two categories of tools:
+1. LOCAL CODING TOOLS — read_file, write_file, edit_file, run_command, search_files, search_content, list_directory. Use these to work directly with the user's local codebase.
+2. CLOUD PLATFORM TOOLS — get_account_info, list_workspaces, create_workspace, stop_workspace, get_workspace_status, get_memory, add_memory, clear_memory, get_usage, get_config, set_config. Use these to manage the Cheri cloud platform.
+
+Guidelines:
+- Read files before editing them. Understand existing code before making changes.
+- Use search_files and search_content to explore unfamiliar codebases.
+- Use list_directory to understand project structure.
+- When writing code, match existing style and patterns.
+- For shell commands, prefer specific commands over broad ones.
+- Be concise. Show what you did and the result.
+- Never guess file contents — always read first.
+- Current working directory: ${process.cwd()}`;
+
+// Cloud platform tools (executed via API)
+const CLOUD_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"] } },
+];
 
-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 CLOUD_TOOL_NAMES = new Set(CLOUD_TOOLS.map((t) => t.name));
 
-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: [] },
-    },
-  },
-  {
+// Build unified tool list in OpenAI function-calling format
+function buildTools() {
+  const localDefs = getToolDefinitions().map((t) => ({
     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"],
-      },
-    },
-  },
-  {
+    function: { name: t.name, description: t.description, parameters: t.parameters },
+  }));
+  const cloudDefs = CLOUD_TOOLS.map((t) => ({
     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"],
-      },
-    },
-  },
-];
+    function: { name: t.name, description: t.description, parameters: t.parameters },
+  }));
+  return [...localDefs, ...cloudDefs];
+}
 
-async function executeTool(name, args) {
+// Execute a cloud platform tool via the API
+async function executeCloudTool(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_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": {
         const { getConfigValue } = await import("../lib/config-store.js");
         return { key: args.key, value: getConfigValue(args.key) };
@@ -155,14 +72,42 @@ async function executeTool(name, args) {
         setConfigValue(args.key, args.value);
         return { key: args.key, value: args.value, status: "updated" };
       }
-      default:
-        return { error: `Unknown tool: ${name}` };
+      default: return { error: `Unknown cloud tool: ${name}` };
     }
   } catch (err) {
     return { error: err.message };
   }
 }
 
+// Ask user for confirmation before destructive operations
+async function confirmAction(toolName, input) {
+  const desc = toolName === "run_command" ? input.command : JSON.stringify(input);
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(chalk.yellow(`  Allow ${chalk.cyan(toolName)}: ${chalk.dim(desc)}? [Y/n] `), (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() !== "n");
+    });
+  });
+}
+
+// Unified tool executor
+async function executeTool(name, args) {
+  if (CLOUD_TOOL_NAMES.has(name)) {
+    return executeCloudTool(name, args);
+  }
+
+  // Local tool — check if it needs confirmation
+  if (requiresConfirmation(name)) {
+    const allowed = await confirmAction(name, args);
+    if (!allowed) {
+      return { error: "User denied execution" };
+    }
+  }
+
+  return executeLocalTool(name, args);
+}
+
 // Parse SSE stream from the cloud proxy
 async function* parseSSEStream(response) {
   const reader = response.body.getReader();
@@ -194,15 +139,17 @@ async function* parseSSEStream(response) {
 }
 
 export async function runAgent(userRequest) {
+  const ALL_TOOLS = buildTools();
+
   const messages = [
     { role: "system", content: SYSTEM_PROMPT },
     { role: "user", content: userRequest },
   ];
 
-  const MAX_ITERATIONS = 10;
+  const MAX_ITERATIONS = 15;
 
   for (let i = 0; i < MAX_ITERATIONS; i++) {
-    const response = await apiClient.chatStream(messages, TOOLS);
+    const response = await apiClient.chatStream(messages, ALL_TOOLS);
 
     let fullText = "";
     const toolCalls = {};
@@ -255,7 +202,9 @@ export async function runAgent(userRequest) {
       let input = {};
       try { input = JSON.parse(tc.arguments); } catch {}
 
-      log.info(`Calling ${chalk.cyan(tc.name)}${Object.keys(input).length ? chalk.dim(" " + JSON.stringify(input)) : ""}`);
+      const isLocal = !CLOUD_TOOL_NAMES.has(tc.name);
+      const prefix = isLocal ? chalk.magenta("local") : chalk.blue("cloud");
+      log.info(`${prefix} ${chalk.cyan(tc.name)}${Object.keys(input).length ? chalk.dim(" " + truncate(JSON.stringify(input), 80)) : ""}`);
 
       const result = await executeTool(tc.name, input);
 
@@ -265,22 +214,30 @@ export async function runAgent(userRequest) {
         log.success(tc.name);
       }
 
+      // Truncate large tool results to avoid blowing context
+      const resultStr = JSON.stringify(result);
+      const truncatedResult = resultStr.length > 8000 ? resultStr.slice(0, 8000) + "...(truncated)" : resultStr;
+
       messages.push({
         role: "tool",
         tool_call_id: tc.id,
-        content: JSON.stringify(result),
+        content: truncatedResult,
       });
     }
   }
 
-  log.warn("Agent reached maximum iterations (10). Stopping.");
+  log.warn("Agent reached maximum iterations (15). Stopping.");
+}
+
+function truncate(str, max) {
+  return str.length > max ? str.slice(0, max) + "..." : str;
 }
 
 export function registerAgentCommand(program) {
   program
     .command("agent")
     .argument("<request...>")
-    .description("AI agent — natural language command interface")
+    .description("AI coding agent — natural language command interface")
     .action(async (requestParts) => {
       const request = requestParts.join(" ");
       try {

package/src/commands/login.js

@@ -13,12 +13,10 @@ export async function loginFlow() {
 
   log.info("Step 1: Open this URL in your browser to authenticate:");
   log.blank();
-  console.log(`  ${chalk.cyan.underline(`${apiUrl}/auth/github`)}`);
+  console.log(`  ${chalk.cyan.underline(`${apiUrl}/auth/github?source=cli`)}`);
   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.info("Step 2: After GitHub login, your token will be shown automatically.");
+  log.info("        Copy it and paste it below.");
   log.blank();
 
   const { token } = await inquirer.prompt([

package/src/lib/tools/command-tools.js

@@ -0,0 +1,34 @@
+import { execSync } from "child_process";
+
+export const runCommand = {
+  name: "run_command",
+  description: "Execute a shell command and return its output. Use for running builds, tests, git commands, installing packages, etc.",
+  parameters: {
+    type: "object",
+    properties: {
+      command: { type: "string", description: "The shell command to execute" },
+      cwd: { type: "string", description: "Working directory (optional, defaults to current directory)" },
+    },
+    required: ["command"],
+  },
+  requiresConfirmation: true,
+  handler: async ({ command, cwd }) => {
+    try {
+      const output = execSync(command, {
+        cwd: cwd || process.cwd(),
+        encoding: "utf-8",
+        timeout: 120_000,
+        maxBuffer: 1024 * 1024 * 10,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+      return { command, exitCode: 0, stdout: output, stderr: "" };
+    } catch (err) {
+      return {
+        command,
+        exitCode: err.status ?? 1,
+        stdout: err.stdout || "",
+        stderr: err.stderr || err.message,
+      };
+    }
+  },
+};

package/src/lib/tools/file-tools.js

@@ -0,0 +1,72 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { dirname, resolve } from "path";
+
+export const readFile = {
+  name: "read_file",
+  description: "Read the contents of a file at the given path. Returns the file contents as a string.",
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Absolute or relative file path to read" },
+    },
+    required: ["path"],
+  },
+  handler: async ({ path }) => {
+    const resolved = resolve(path);
+    if (!existsSync(resolved)) {
+      return { error: `File not found: ${resolved}` };
+    }
+    const content = readFileSync(resolved, "utf-8");
+    return { path: resolved, content, lines: content.split("\n").length };
+  },
+};
+
+export const writeFile = {
+  name: "write_file",
+  description: "Create or overwrite a file with the given content. Creates parent directories if needed.",
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Absolute or relative file path to write" },
+      content: { type: "string", description: "The content to write to the file" },
+    },
+    required: ["path", "content"],
+  },
+  handler: async ({ path, content }) => {
+    const resolved = resolve(path);
+    const dir = dirname(resolved);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(resolved, content, "utf-8");
+    return { path: resolved, bytesWritten: Buffer.byteLength(content, "utf-8") };
+  },
+};
+
+export const editFile = {
+  name: "edit_file",
+  description: "Edit a file by replacing an exact string match with new content. The old_string must match exactly (including whitespace and indentation).",
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Absolute or relative file path to edit" },
+      old_string: { type: "string", description: "The exact string to find and replace" },
+      new_string: { type: "string", description: "The replacement string" },
+    },
+    required: ["path", "old_string", "new_string"],
+  },
+  handler: async ({ path, old_string, new_string }) => {
+    const resolved = resolve(path);
+    if (!existsSync(resolved)) {
+      return { error: `File not found: ${resolved}` };
+    }
+    const content = readFileSync(resolved, "utf-8");
+    if (!content.includes(old_string)) {
+      return { error: "old_string not found in file. Make sure it matches exactly, including whitespace." };
+    }
+    const count = content.split(old_string).length - 1;
+    const newContent = content.replace(old_string, new_string);
+    writeFileSync(resolved, newContent, "utf-8");
+    return { path: resolved, replacements: 1, totalOccurrences: count };
+  },
+};

package/src/lib/tools/index.js

@@ -0,0 +1,32 @@
+import { readFile, writeFile, editFile } from "./file-tools.js";
+import { runCommand } from "./command-tools.js";
+import { searchFiles, searchContent, listDirectory } from "./search-tools.js";
+
+const tools = [readFile, writeFile, editFile, runCommand, searchFiles, searchContent, listDirectory];
+
+const toolMap = new Map(tools.map((t) => [t.name, t]));
+
+export function getToolDefinitions() {
+  return tools.map(({ name, description, parameters }) => ({ name, description, parameters }));
+}
+
+export function getTool(name) {
+  return toolMap.get(name);
+}
+
+export async function executeTool(name, input) {
+  const tool = toolMap.get(name);
+  if (!tool) {
+    return { error: `Unknown tool: ${name}` };
+  }
+  try {
+    return await tool.handler(input);
+  } catch (err) {
+    return { error: err.message };
+  }
+}
+
+export function requiresConfirmation(name) {
+  const tool = toolMap.get(name);
+  return tool?.requiresConfirmation === true;
+}

package/src/lib/tools/search-tools.js

@@ -0,0 +1,95 @@
+import { readdirSync, statSync, existsSync } from "fs";
+import { resolve, join } from "path";
+import { execSync } from "child_process";
+
+export const searchFiles = {
+  name: "search_files",
+  description: "Search for files matching a glob/name pattern. Returns matching file paths.",
+  parameters: {
+    type: "object",
+    properties: {
+      pattern: { type: "string", description: "File name pattern to search for (e.g., '*.js', 'config*', 'test')" },
+      path: { type: "string", description: "Directory to search in (defaults to current directory)" },
+    },
+    required: ["pattern"],
+  },
+  handler: async ({ pattern, path }) => {
+    const dir = resolve(path || ".");
+    try {
+      const result = execSync(`find ${JSON.stringify(dir)} -name ${JSON.stringify(pattern)} -not -path '*/node_modules/*' -not -path '*/.git/*' 2>/dev/null | head -50`, {
+        encoding: "utf-8",
+        timeout: 10_000,
+      });
+      const files = result.trim().split("\n").filter(Boolean);
+      return { pattern, searchPath: dir, matches: files, count: files.length };
+    } catch {
+      return { pattern, searchPath: dir, matches: [], count: 0 };
+    }
+  },
+};
+
+export const searchContent = {
+  name: "search_content",
+  description: "Search for a text pattern inside files (like grep). Returns matching lines with file paths and line numbers.",
+  parameters: {
+    type: "object",
+    properties: {
+      pattern: { type: "string", description: "Text or regex pattern to search for" },
+      path: { type: "string", description: "Directory to search in (defaults to current directory)" },
+      include: { type: "string", description: "File glob to filter (e.g., '*.js')" },
+    },
+    required: ["pattern"],
+  },
+  handler: async ({ pattern, path, include }) => {
+    const dir = resolve(path || ".");
+    try {
+      let cmd = `grep -rn --include='${include || "*"}' ${JSON.stringify(pattern)} ${JSON.stringify(dir)} 2>/dev/null | head -50`;
+      const result = execSync(cmd, { encoding: "utf-8", timeout: 10_000 });
+      const lines = result.trim().split("\n").filter(Boolean);
+      const matches = lines.map((line) => {
+        const match = line.match(/^(.+?):(\d+):(.*)$/);
+        if (match) return { file: match[1], line: parseInt(match[2]), content: match[3].trim() };
+        return { raw: line };
+      });
+      return { pattern, searchPath: dir, matches, count: matches.length };
+    } catch {
+      return { pattern, searchPath: dir, matches: [], count: 0 };
+    }
+  },
+};
+
+export const listDirectory = {
+  name: "list_directory",
+  description: "List files and directories at the given path. Shows names, types, and sizes.",
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Directory path to list (defaults to current directory)" },
+    },
+    required: [],
+  },
+  handler: async ({ path }) => {
+    const dir = resolve(path || ".");
+    if (!existsSync(dir)) {
+      return { error: `Directory not found: ${dir}` };
+    }
+    try {
+      const entries = readdirSync(dir).map((name) => {
+        try {
+          const fullPath = join(dir, name);
+          const stat = statSync(fullPath);
+          return {
+            name,
+            type: stat.isDirectory() ? "directory" : "file",
+            size: stat.isDirectory() ? undefined : stat.size,
+          };
+        } catch {
+          return { name, type: "unknown" };
+        }
+      });
+      return { path: dir, entries, count: entries.length };
+    } catch (err) {
+      return { error: err.message };
+    }
+  },
+};

package/src/repl.js

@@ -180,7 +180,8 @@ async function dispatch(input) {
     }
 
     default:
-      log.warn(`Unknown command: '${cmd}'. Type ${chalk.cyan("help")} for available commands.`);
+      // Treat any unrecognized input as an agent request
+      await runAgent(input);
   }
 }