@heysalad/cheri-cli 0.3.0 → 0.4.0

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

@@ -0,0 +1,73 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { dirname } from "path";
+import { 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, relative } 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

@@ -9,7 +9,7 @@ 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";
+import { runAgent } from "./commands/agent.js";
 
 const COMMANDS = {
   "workspace launch": { args: "<repo>", desc: "Launch a new cloud workspace" },
@@ -21,12 +21,13 @@ const COMMANDS = {
   "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" },
+  "chat":             { args: "",       desc: "Start AI coding session" },
+  "agent":            { args: "<request>", desc: "AI agent - natural language command" },
   "help":             { args: "",       desc: "Show this help" },
   "clear":            { args: "",       desc: "Clear the terminal" },
   "exit":             { args: "",       desc: "Exit Cheri" },
@@ -75,10 +76,6 @@ async function dispatch(input) {
       await showStatus();
       return;
 
-    case "usage":
-      await showUsage();
-      return;
-
     case "login":
       await loginFlow();
       return;
@@ -87,6 +84,25 @@ async function dispatch(input) {
       await initProject();
       return;
 
+    case "chat": {
+      const { startRepl: startChatRepl } = await import("./lib/repl.js");
+      await startChatRepl({
+        provider: sub || undefined,
+        model: rest || undefined,
+      });
+      return;
+    }
+
+    case "agent": {
+      const agentInput = parts.slice(1).join(" ");
+      if (!agentInput) {
+        log.error("Usage: agent <request>");
+        return;
+      }
+      await runAgent(agentInput);
+      return;
+    }
+
     case "workspace":
       switch (sub) {
         case "launch":
@@ -209,7 +225,7 @@ export async function startCommandRepl() {
     process.exit(0);
   });
 
-  // Handle Ctrl+C gracefully
+  // Handle Ctrl+C gracefully — don't crash, just exit
   rl.on("SIGINT", () => {
     console.log(chalk.dim("\nGoodbye! 🍒\n"));
     process.exit(0);

package/src/commands/usage.js

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