@heysalad/cheri-cli 1.0.0 → 1.1.0

package/src/lib/diff-tracker.js

@@ -1,5 +1,5 @@
 // File diff tracking — tracks changes made by the agent for review and rollback
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync } from "fs";
 import { join, dirname } from "path";
 import { createTwoFilesPatch, structuredPatch } from "diff";
 import { homedir } from "os";
@@ -47,8 +47,8 @@ export function recordChange(snapshot, newContent, operation = "edit") {
   // Persist snapshot for rollback
   try {
     if (!existsSync(SNAPSHOTS_DIR)) mkdirSync(SNAPSHOTS_DIR, { recursive: true });
-    const snapshotFile = join(SNAPSHOTS_DIR, `${Date.now()}-${sanitizeFilename(snapshot.path)}`);
-    writeFileSync(snapshotFile, JSON.stringify(change), "utf-8");
+    const snapshotPath = join(SNAPSHOTS_DIR, `${Date.now()}-${sanitizeFilename(snapshot.path)}`);
+    writeFileSync(snapshotPath, JSON.stringify(change), "utf-8");
   } catch {}
 
   return change;
@@ -101,7 +101,6 @@ export function rollbackChange(index) {
   try {
     if (!change.existed) {
       // File was created — delete it
-      const { unlinkSync } = require("fs");
       unlinkSync(change.path);
     } else {
       // Restore original content

package/src/lib/logger.js

@@ -13,51 +13,70 @@ function getVersion() {
   return _version;
 }
 
+// Gradient colors
+const gradients = {
+  cheri: (text) => chalk.hex('#FF6B6B')(text),
+  purple: (text) => chalk.hex('#A855F7')(text),
+  blue: (text) => chalk.hex('#3B82F6')(text),
+  green: (text) => chalk.hex('#10B981')(text),
+  yellow: (text) => chalk.hex('#F59E0B')(text),
+  cyan: (text) => chalk.hex('#06B6D4')(text),
+};
+
+// Enhanced icons
+const icons = {
+  info: 'ℹ',
+  success: '✓',
+  warning: '⚠',
+  error: '✗',
+  tip: '💡',
+};
+
 export const log = {
   info(msg) {
-    console.log(chalk.blue("info") + "  " + msg);
+    console.log(gradients.blue(`${icons.info} info`) + "  " + chalk.dim(msg));
   },
   success(msg) {
-    console.log(chalk.green("done") + "  " + msg);
+    console.log(gradients.green(`${icons.success} done`) + "  " + msg);
   },
   warn(msg) {
-    console.log(chalk.yellow("warn") + "  " + msg);
+    console.log(gradients.yellow(`${icons.warning} warn`) + "  " + msg);
   },
   error(msg) {
-    console.log(chalk.red("error") + " " + msg);
+    console.log(gradients.cheri(`${icons.error} error`) + " " + chalk.red(msg));
   },
   dim(msg) {
     console.log(chalk.dim(msg));
   },
   brand(msg) {
-    console.log(chalk.red.bold("cheri") + " " + msg);
+    console.log(gradients.cheri("🍒 cheri") + " " + chalk.bold(msg));
   },
   blank() {
     console.log();
   },
   header(title) {
     console.log();
-    console.log(chalk.bold(title));
-    console.log(chalk.dim("─".repeat(title.length)));
+    console.log(gradients.cyan("╭─") + " " + chalk.bold(title));
+    console.log(gradients.cyan("│"));
   },
   keyValue(key, value) {
-    console.log(`  ${chalk.dim(key.padEnd(16))} ${value}`);
+    console.log(`  ${chalk.dim(key.padEnd(18))} ${gradients.cyan("→")} ${value}`);
   },
   tree(items) {
     items.forEach((item, i) => {
       const prefix = i === items.length - 1 ? "  └─" : "  ├─";
-      console.log(chalk.dim(prefix) + " " + item);
+      console.log(gradients.cyan(prefix) + " " + item);
     });
   },
   banner(version) {
     if (!version) version = getVersion();
     console.log();
-    console.log(`   ${chalk.red("🍒")} ${chalk.red.bold("Cheri")}`);
+    console.log(`   ${gradients.cheri("🍒")} ${chalk.red.bold("Cheri")}`);
     console.log(`   ${chalk.dim("AI-powered cloud IDE by HeySalad")}`);
-    console.log(`   ${chalk.dim("v" + version)}`);
+    console.log(`   ${gradients.cyan("✨")} ${chalk.dim("v" + version)}`);
     console.log();
   },
   tip(msg) {
-    console.log(`  ${chalk.blue("tip")}  ${chalk.dim(msg)}`);
+    console.log(`  ${gradients.yellow(`${icons.tip} tip`)}  ${chalk.dim(msg)}`);
   },
 };

package/src/lib/markdown.js

@@ -1,32 +1,50 @@
 // Rich markdown rendering for terminal output
-import { Marked } from "marked";
-import { markedTerminal } from "marked-terminal";
 import chalk from "chalk";
 
-const marked = new Marked(markedTerminal({
-  reflowText: true,
-  width: Math.min(process.stdout.columns || 100, 120),
-  showSectionPrefix: false,
-  tab: 2,
-  code: chalk.cyan,
-  codespan: chalk.cyan,
-  blockquote: chalk.dim.italic,
-  strong: chalk.bold,
-  em: chalk.italic,
-  del: chalk.strikethrough,
-  link: chalk.blue.underline,
-  href: chalk.blue.underline,
-  listitem: (text) => `  ${chalk.dim("•")} ${text}`,
-}));
-
 /**
- * Render markdown text to terminal-formatted string
+ * Simple markdown renderer for terminal
+ * Handles basic formatting without external renderer
  */
 export function renderMarkdown(text) {
   if (!text) return "";
+
   try {
-    return marked.parse(text).trim();
-  } catch {
+    let output = text;
+
+    // Code blocks ```code```
+    output = output.replace(/```(\w+)?\n([\s\S]*?)```/g, (match, lang, code) => {
+      const header = lang ? chalk.dim(`  ${lang}`) + "\n" : "";
+      const lines = code.split("\n").map(l => chalk.cyan("  " + l)).join("\n");
+      return "\n" + header + lines + "\n";
+    });
+
+    // Inline code `code`
+    output = output.replace(/`([^`]+)`/g, (match, code) => chalk.cyan(code));
+
+    // Bold **text**
+    output = output.replace(/\*\*([^*]+)\*\*/g, (match, text) => chalk.bold(text));
+
+    // Italic *text*
+    output = output.replace(/\*([^*]+)\*/g, (match, text) => chalk.italic(text));
+
+    // Links [text](url)
+    output = output.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (match, text, url) =>
+      chalk.blue.underline(text) + chalk.dim(` (${url})`)
+    );
+
+    // Headers ### text
+    output = output.replace(/^(#{1,6})\s+(.+)$/gm, (match, hashes, text) => {
+      return chalk.bold.cyan(text);
+    });
+
+    // List items - text or * text
+    output = output.replace(/^[\-\*]\s+(.+)$/gm, (match, text) =>
+      `  ${chalk.dim("•")} ${text}`
+    );
+
+    return output.trim();
+  } catch (err) {
+    // Fallback to plain text if rendering fails
     return text;
   }
 }

package/src/lib/mcp/client.js

@@ -118,7 +118,13 @@ export class McpServer {
         params,
       });
 
-      this.process.stdin.write(message + "\n");
+      try {
+        this.process.stdin.write(message + "\n");
+      } catch (err) {
+        this.pendingRequests.delete(id);
+        clearTimeout(timeout);
+        reject(new Error(`Failed to write to MCP server '${this.name}': ${err.message}`));
+      }
     });
   }
 
@@ -128,7 +134,9 @@ export class McpServer {
       method,
       params,
     });
-    this.process.stdin.write(message + "\n");
+    try {
+      this.process.stdin.write(message + "\n");
+    } catch {}
   }
 
   _processBuffer() {
@@ -148,7 +156,9 @@ export class McpServer {
             resolve(msg.result);
           }
         }
-      } catch {}
+      } catch (err) {
+        log.dim(`[mcp:${this.name}] Failed to parse response: ${line.slice(0, 100)}`);
+      }
     }
   }
 
@@ -206,13 +216,22 @@ export class McpManager {
   }
 
   async callTool(fullName, args) {
-    // Parse mcp_{server}_{tool} format
-    const match = fullName.match(/^mcp_([^_]+)_(.+)$/);
-    if (!match) return { error: `Invalid MCP tool name: ${fullName}` };
-
-    const [, serverName, toolName] = match;
-    const server = this.servers.get(serverName);
-    if (!server) return { error: `MCP server '${serverName}' not connected` };
+    // Find the server by checking registered tool names (avoids underscore ambiguity)
+    let server = null;
+    let toolName = null;
+    for (const s of this.servers.values()) {
+      const def = s.getToolDefinitions().find(t => t.name === fullName);
+      if (def) { server = s; toolName = def.mcpToolName; break; }
+    }
+    if (!server || !toolName) {
+      // Fallback: try regex parse
+      const match = fullName.match(/^mcp_([^_]+)_(.+)$/);
+      if (!match) return { error: `Invalid MCP tool name: ${fullName}` };
+      const [, serverName, tn] = match;
+      server = this.servers.get(serverName);
+      toolName = tn;
+      if (!server) return { error: `MCP server '${serverName}' not connected` };
+    }
 
     try {
       const result = await server.callTool(toolName, args);

package/src/lib/providers/index.js

@@ -210,8 +210,13 @@ class AnthropicProvider {
           }
         }
         await writer.write(encoder.encode("data: [DONE]\n\n"));
-      } catch {} finally {
-        await writer.close();
+      } catch (err) {
+        try {
+          const errChunk = { choices: [{ index: 0, delta: { content: `\n[Stream error: ${err.message || "unknown"}]` }, finish_reason: "stop" }] };
+          await writer.write(encoder.encode(`data: ${JSON.stringify(errChunk)}\n\n`));
+        } catch {}
+      } finally {
+        try { await writer.close(); } catch {}
       }
     })();
 

package/src/lib/sessions/index.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync } from "fs";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, unlinkSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 
@@ -48,7 +48,6 @@ export function listSessions() {
 export function deleteSession(sessionId) {
   const filePath = join(SESSIONS_DIR, `${sessionId}.json`);
   if (existsSync(filePath)) {
-    const { unlinkSync } = require("fs");
     unlinkSync(filePath);
     return true;
   }

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

@@ -1,6 +1,8 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, statSync } from "fs";
 import { dirname, resolve } from "path";
 
+const MAX_FILE_SIZE = 5 * 1024 * 1024; // 5MB limit
+
 export const readFile = {
   name: "read_file",
   description: "Read the contents of a file at the given path. Returns the file contents as a string.",
@@ -12,12 +14,32 @@ export const readFile = {
     required: ["path"],
   },
   handler: async ({ path }) => {
-    const resolved = resolve(path);
-    if (!existsSync(resolved)) {
-      return { error: `File not found: ${resolved}` };
+    try {
+      const resolved = resolve(path);
+      if (!existsSync(resolved)) {
+        return { error: `File not found: ${resolved}` };
+      }
+      const stat = statSync(resolved);
+      if (stat.isDirectory()) {
+        return { error: `Path is a directory, not a file: ${resolved}` };
+      }
+      if (stat.size > MAX_FILE_SIZE) {
+        return { error: `File too large (${(stat.size / 1024 / 1024).toFixed(1)}MB). Max: 5MB` };
+      }
+      // Detect binary files by checking for null bytes in first 8KB
+      const buf = Buffer.alloc(Math.min(8192, stat.size));
+      const fd = await import("fs").then(fs => fs.openSync(resolved, "r"));
+      const { readSync, closeSync } = await import("fs");
+      readSync(fd, buf, 0, buf.length, 0);
+      closeSync(fd);
+      if (buf.includes(0)) {
+        return { error: `Binary file detected: ${resolved}. Cannot read binary files as text.` };
+      }
+      const content = readFileSync(resolved, "utf-8");
+      return { path: resolved, content, lines: content.split("\n").length };
+    } catch (err) {
+      return { error: `Failed to read file: ${err.message}` };
     }
-    const content = readFileSync(resolved, "utf-8");
-    return { path: resolved, content, lines: content.split("\n").length };
   },
 };
 
@@ -33,13 +55,17 @@ export const writeFile = {
     required: ["path", "content"],
   },
   handler: async ({ path, content }) => {
-    const resolved = resolve(path);
-    const dir = dirname(resolved);
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
+    try {
+      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") };
+    } catch (err) {
+      return { error: `Failed to write file: ${err.message}` };
     }
-    writeFileSync(resolved, content, "utf-8");
-    return { path: resolved, bytesWritten: Buffer.byteLength(content, "utf-8") };
   },
 };
 
@@ -56,17 +82,24 @@ export const editFile = {
     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." };
+    try {
+      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;
+      if (count > 1) {
+        return { error: `old_string found ${count} times. It must be unique — add more surrounding context.` };
+      }
+      const newContent = content.replace(old_string, new_string);
+      writeFileSync(resolved, newContent, "utf-8");
+      return { path: resolved, replacements: 1 };
+    } catch (err) {
+      return { error: `Failed to edit file: ${err.message}` };
     }
-    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/search-tools.js

@@ -43,7 +43,7 @@ export const searchContent = {
   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`;
+      let cmd = `grep -rn --include=${JSON.stringify(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) => {