@heysalad/cheri-cli 0.9.0 → 1.0.0

package/src/lib/diff-tracker.js

@@ -0,0 +1,157 @@
+// File diff tracking — tracks changes made by the agent for review and rollback
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { createTwoFilesPatch, structuredPatch } from "diff";
+import { homedir } from "os";
+
+const SNAPSHOTS_DIR = join(homedir(), ".cheri", "snapshots");
+
+// In-memory change log for current session
+let sessionChanges = [];
+
+/**
+ * Take a snapshot of a file before modification
+ */
+export function snapshotFile(filePath) {
+  const absPath = filePath.startsWith("/") ? filePath : join(process.cwd(), filePath);
+  let content = "";
+  let existed = false;
+
+  if (existsSync(absPath)) {
+    try {
+      content = readFileSync(absPath, "utf-8");
+      existed = true;
+    } catch {
+      content = "";
+    }
+  }
+
+  return { path: absPath, content, existed, timestamp: Date.now() };
+}
+
+/**
+ * Record a file change (call after modification)
+ */
+export function recordChange(snapshot, newContent, operation = "edit") {
+  const change = {
+    path: snapshot.path,
+    operation,
+    before: snapshot.content,
+    after: newContent,
+    existed: snapshot.existed,
+    timestamp: Date.now(),
+  };
+
+  sessionChanges.push(change);
+
+  // 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");
+  } catch {}
+
+  return change;
+}
+
+/**
+ * Generate a unified diff for a change
+ */
+export function generateDiff(change) {
+  return createTwoFilesPatch(
+    change.path,
+    change.path,
+    change.before,
+    change.after,
+    "before",
+    "after"
+  );
+}
+
+/**
+ * Get summary of changes in current session
+ */
+export function getSessionChanges() {
+  return sessionChanges.map(c => ({
+    path: c.path,
+    operation: c.operation,
+    linesAdded: countLines(c.after) - countLines(c.before),
+    timestamp: c.timestamp,
+  }));
+}
+
+/**
+ * Get detailed diff for a specific change
+ */
+export function getChangeDiff(index) {
+  if (index < 0 || index >= sessionChanges.length) return null;
+  return generateDiff(sessionChanges[index]);
+}
+
+/**
+ * Rollback a specific change
+ */
+export function rollbackChange(index) {
+  if (index < 0 || index >= sessionChanges.length) {
+    return { error: "Invalid change index" };
+  }
+
+  const change = sessionChanges[index];
+
+  try {
+    if (!change.existed) {
+      // File was created — delete it
+      const { unlinkSync } = require("fs");
+      unlinkSync(change.path);
+    } else {
+      // Restore original content
+      const dir = dirname(change.path);
+      if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+      writeFileSync(change.path, change.before, "utf-8");
+    }
+
+    // Remove from session changes
+    sessionChanges.splice(index, 1);
+    return { success: true, path: change.path };
+  } catch (err) {
+    return { error: err.message };
+  }
+}
+
+/**
+ * Rollback all changes in reverse order
+ */
+export function rollbackAll() {
+  const results = [];
+  for (let i = sessionChanges.length - 1; i >= 0; i--) {
+    results.push(rollbackChange(i));
+  }
+  return results;
+}
+
+/**
+ * Clear session changes (without rolling back)
+ */
+export function clearSessionChanges() {
+  sessionChanges = [];
+}
+
+/**
+ * Get a structured diff with hunks
+ */
+export function getStructuredDiff(change) {
+  return structuredPatch(
+    change.path, change.path,
+    change.before, change.after,
+    "before", "after"
+  );
+}
+
+function countLines(text) {
+  if (!text) return 0;
+  return text.split("\n").length;
+}
+
+function sanitizeFilename(path) {
+  return path.replace(/[^a-zA-Z0-9.-]/g, "_").slice(-60);
+}

package/src/lib/logger.js

@@ -1,4 +1,17 @@
 import chalk from "chalk";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+let _version;
+function getVersion() {
+  if (!_version) {
+    try { _version = JSON.parse(readFileSync(join(__dirname, "..", "..", "package.json"), "utf-8")).version; }
+    catch { _version = "0.0.0"; }
+  }
+  return _version;
+}
 
 export const log = {
   info(msg) {
@@ -36,7 +49,8 @@ export const log = {
       console.log(chalk.dim(prefix) + " " + item);
     });
   },
-  banner(version = "0.1.0") {
+  banner(version) {
+    if (!version) version = getVersion();
     console.log();
     console.log(`   ${chalk.red("🍒")} ${chalk.red.bold("Cheri")}`);
     console.log(`   ${chalk.dim("AI-powered cloud IDE by HeySalad")}`);

package/src/lib/markdown.js

@@ -0,0 +1,62 @@
+// 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
+ */
+export function renderMarkdown(text) {
+  if (!text) return "";
+  try {
+    return marked.parse(text).trim();
+  } catch {
+    return text;
+  }
+}
+
+/**
+ * Stream-friendly markdown rendering for partial text
+ * Returns the text as-is for streaming (full render at end)
+ */
+export function streamText(text) {
+  return text;
+}
+
+/**
+ * Render a code block with language label
+ */
+export function renderCodeBlock(code, language = "") {
+  const header = language ? chalk.dim(`  ${language}`) + "\n" : "";
+  const lines = code.split("\n").map(l => chalk.cyan("  " + l)).join("\n");
+  return header + lines;
+}
+
+/**
+ * Render a diff with color coding
+ */
+export function renderDiff(diffText) {
+  return diffText.split("\n").map(line => {
+    if (line.startsWith("+") && !line.startsWith("+++")) return chalk.green(line);
+    if (line.startsWith("-") && !line.startsWith("---")) return chalk.red(line);
+    if (line.startsWith("@@")) return chalk.cyan(line);
+    if (line.startsWith("diff")) return chalk.bold(line);
+    return chalk.dim(line);
+  }).join("\n");
+}

package/src/lib/mcp/client.js

@@ -0,0 +1,239 @@
+// MCP (Model Context Protocol) client
+// Connects to MCP servers via stdio transport, discovers tools, and calls them
+import { spawn } from "child_process";
+import { log } from "../logger.js";
+
+const JSONRPC_VERSION = "2.0";
+let requestId = 0;
+
+/**
+ * MCP Server connection
+ */
+export class McpServer {
+  constructor(name, command, args = [], env = {}) {
+    this.name = name;
+    this.command = command;
+    this.args = args;
+    this.env = { ...process.env, ...env };
+    this.process = null;
+    this.tools = [];
+    this.resources = [];
+    this.pendingRequests = new Map();
+    this._buffer = "";
+  }
+
+  async connect() {
+    return new Promise((resolve, reject) => {
+      this.process = spawn(this.command, this.args, {
+        env: this.env,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+
+      this.process.stdout.on("data", (data) => {
+        this._buffer += data.toString();
+        this._processBuffer();
+      });
+
+      this.process.stderr.on("data", (data) => {
+        log.dim(`[mcp:${this.name}] ${data.toString().trim()}`);
+      });
+
+      this.process.on("error", (err) => {
+        reject(new Error(`MCP server ${this.name} failed to start: ${err.message}`));
+      });
+
+      this.process.on("close", (code) => {
+        for (const [, { reject: r }] of this.pendingRequests) {
+          r(new Error(`MCP server ${this.name} exited with code ${code}`));
+        }
+        this.pendingRequests.clear();
+      });
+
+      // Initialize the connection
+      setTimeout(async () => {
+        try {
+          await this._initialize();
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      }, 500);
+    });
+  }
+
+  async _initialize() {
+    const result = await this._request("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "cheri", version: "0.10.0" },
+    });
+
+    // Send initialized notification
+    this._notify("notifications/initialized", {});
+
+    // Discover tools
+    try {
+      const toolsResult = await this._request("tools/list", {});
+      this.tools = toolsResult.tools || [];
+    } catch {
+      this.tools = [];
+    }
+
+    // Discover resources
+    try {
+      const resourcesResult = await this._request("resources/list", {});
+      this.resources = resourcesResult.resources || [];
+    } catch {
+      this.resources = [];
+    }
+
+    return result;
+  }
+
+  async callTool(name, args = {}) {
+    return this._request("tools/call", { name, arguments: args });
+  }
+
+  async readResource(uri) {
+    return this._request("resources/read", { uri });
+  }
+
+  _request(method, params) {
+    return new Promise((resolve, reject) => {
+      const id = ++requestId;
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`MCP request ${method} timed out`));
+      }, 30000);
+
+      this.pendingRequests.set(id, {
+        resolve: (result) => { clearTimeout(timeout); resolve(result); },
+        reject: (err) => { clearTimeout(timeout); reject(err); },
+      });
+
+      const message = JSON.stringify({
+        jsonrpc: JSONRPC_VERSION,
+        id,
+        method,
+        params,
+      });
+
+      this.process.stdin.write(message + "\n");
+    });
+  }
+
+  _notify(method, params) {
+    const message = JSON.stringify({
+      jsonrpc: JSONRPC_VERSION,
+      method,
+      params,
+    });
+    this.process.stdin.write(message + "\n");
+  }
+
+  _processBuffer() {
+    const lines = this._buffer.split("\n");
+    this._buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const msg = JSON.parse(line);
+        if (msg.id && this.pendingRequests.has(msg.id)) {
+          const { resolve, reject } = this.pendingRequests.get(msg.id);
+          this.pendingRequests.delete(msg.id);
+          if (msg.error) {
+            reject(new Error(msg.error.message || "MCP error"));
+          } else {
+            resolve(msg.result);
+          }
+        }
+      } catch {}
+    }
+  }
+
+  getToolDefinitions() {
+    return this.tools.map(t => ({
+      name: `mcp_${this.name}_${t.name}`,
+      description: `[MCP:${this.name}] ${t.description || t.name}`,
+      parameters: t.inputSchema || { type: "object", properties: {} },
+      mcpServer: this.name,
+      mcpToolName: t.name,
+    }));
+  }
+
+  disconnect() {
+    if (this.process) {
+      try { this.process.kill(); } catch {}
+      this.process = null;
+    }
+  }
+}
+
+/**
+ * MCP Manager — manages multiple MCP server connections
+ */
+export class McpManager {
+  constructor() {
+    this.servers = new Map();
+  }
+
+  async addServer(name, config) {
+    const server = new McpServer(
+      name,
+      config.command,
+      config.args || [],
+      config.env || {}
+    );
+
+    try {
+      await server.connect();
+      this.servers.set(name, server);
+      log.success(`MCP server '${name}' connected (${server.tools.length} tools)`);
+      return server;
+    } catch (err) {
+      log.warn(`MCP server '${name}' failed: ${err.message}`);
+      return null;
+    }
+  }
+
+  getAllToolDefinitions() {
+    const tools = [];
+    for (const server of this.servers.values()) {
+      tools.push(...server.getToolDefinitions());
+    }
+    return tools;
+  }
+
+  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` };
+
+    try {
+      const result = await server.callTool(toolName, args);
+      // Extract text content from MCP response
+      if (result.content) {
+        return { result: result.content.map(c => c.text || JSON.stringify(c)).join("\n") };
+      }
+      return result;
+    } catch (err) {
+      return { error: err.message };
+    }
+  }
+
+  isMcpTool(name) {
+    return name.startsWith("mcp_");
+  }
+
+  disconnectAll() {
+    for (const server of this.servers.values()) {
+      server.disconnect();
+    }
+    this.servers.clear();
+  }
+}

package/src/lib/multi-agent.js

@@ -0,0 +1,153 @@
+// Multi-agent orchestration — spawn child agents for subtasks
+import { log } from "./logger.js";
+
+/**
+ * SubAgent — a lightweight agent that runs a focused subtask
+ * with its own message history but shares the parent's tools and API
+ */
+export class SubAgent {
+  constructor(name, systemPrompt, options = {}) {
+    this.name = name;
+    this.systemPrompt = systemPrompt;
+    this.maxIterations = options.maxIterations || 10;
+    this.tools = options.tools || [];
+    this.messages = [{ role: "system", content: systemPrompt }];
+    this.status = "idle"; // idle, running, done, error
+    this.result = null;
+  }
+}
+
+/**
+ * Agent orchestrator — manages parent + child agents
+ */
+export class AgentOrchestrator {
+  constructor(chatFn, executeTool) {
+    this.chatFn = chatFn;        // async function(messages, tools) => response
+    this.executeTool = executeTool; // async function(name, args) => result
+    this.agents = new Map();
+    this.parentId = "main";
+  }
+
+  /**
+   * Spawn a child agent for a subtask
+   */
+  createAgent(name, task, options = {}) {
+    const systemPrompt = `You are a sub-agent named "${name}" focused on a specific task.
+Your task: ${task}
+
+Complete this task using the available tools, then provide a concise summary of what you did and the results.
+Be focused and efficient. Do not ask questions — make reasonable decisions.
+Current working directory: ${process.cwd()}`;
+
+    const agent = new SubAgent(name, systemPrompt, {
+      maxIterations: options.maxIterations || 8,
+      tools: options.tools,
+    });
+
+    this.agents.set(name, agent);
+    return agent;
+  }
+
+  /**
+   * Run a child agent to completion
+   */
+  async runAgent(name, userMessage, allTools, parseSSEStream) {
+    const agent = this.agents.get(name);
+    if (!agent) throw new Error(`Agent '${name}' not found`);
+
+    agent.status = "running";
+    agent.messages.push({ role: "user", content: userMessage });
+
+    log.dim(`  [${name}] Starting subtask...`);
+
+    try {
+      for (let i = 0; i < agent.maxIterations; i++) {
+        const response = await this.chatFn(agent.messages, allTools);
+
+        let fullText = "";
+        const toolCalls = {};
+
+        for await (const chunk of parseSSEStream(response)) {
+          const delta = chunk.choices?.[0]?.delta;
+          const finishReason = chunk.choices?.[0]?.finish_reason;
+
+          if (delta?.content) fullText += delta.content;
+
+          if (delta?.tool_calls) {
+            for (const tc of delta.tool_calls) {
+              const idx = tc.index;
+              if (!toolCalls[idx]) toolCalls[idx] = { id: tc.id || "", name: "", arguments: "" };
+              if (tc.id) toolCalls[idx].id = tc.id;
+              if (tc.function?.name) toolCalls[idx].name = tc.function.name;
+              if (tc.function?.arguments) toolCalls[idx].arguments += tc.function.arguments;
+            }
+          }
+
+          if (finishReason) break;
+        }
+
+        const toolCallList = Object.values(toolCalls);
+
+        if (toolCallList.length === 0) {
+          agent.messages.push({ role: "assistant", content: fullText });
+          agent.status = "done";
+          agent.result = fullText;
+          log.dim(`  [${name}] Completed.`);
+          return fullText;
+        }
+
+        const assistantMsg = { role: "assistant", content: fullText || null };
+        assistantMsg.tool_calls = toolCallList.map(tc => ({
+          id: tc.id, type: "function", function: { name: tc.name, arguments: tc.arguments },
+        }));
+        agent.messages.push(assistantMsg);
+
+        // Execute tools (in parallel)
+        const toolPromises = toolCallList.map(async (tc) => {
+          let input = {};
+          try { input = JSON.parse(tc.arguments); } catch {}
+          log.dim(`  [${name}] → ${tc.name}`);
+          const result = await this.executeTool(tc.name, input);
+          return { id: tc.id, result };
+        });
+
+        const toolResults = await Promise.all(toolPromises);
+
+        for (const { id, result } of toolResults) {
+          const resultStr = JSON.stringify(result);
+          const truncated = resultStr.length > 6000 ? resultStr.slice(0, 6000) + "...(truncated)" : resultStr;
+          agent.messages.push({ role: "tool", tool_call_id: id, content: truncated });
+        }
+      }
+
+      agent.status = "done";
+      agent.result = "Reached maximum iterations";
+      return agent.result;
+    } catch (err) {
+      agent.status = "error";
+      agent.result = err.message;
+      log.warn(`  [${name}] Error: ${err.message}`);
+      return `Error: ${err.message}`;
+    }
+  }
+
+  /**
+   * Run multiple agents in parallel
+   */
+  async runParallel(tasks, allTools, parseSSEStream) {
+    const promises = tasks.map(({ name, task }) => {
+      this.createAgent(name, task);
+      return this.runAgent(name, task, allTools, parseSSEStream);
+    });
+
+    return Promise.all(promises);
+  }
+
+  getAgentStatus() {
+    const statuses = {};
+    for (const [name, agent] of this.agents) {
+      statuses[name] = { status: agent.status, result: agent.result?.slice(0, 200) };
+    }
+    return statuses;
+  }
+}