@heysalad/cheri-cli 0.7.0 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heysalad/cheri-cli",
-  "version": "0.7.0",
+  "version": "0.9.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,72 @@
 import { apiClient } from "../lib/api-client.js";
 import { log } from "../lib/logger.js";
+import { getToolDefinitions, executeTool as executeLocalTool, requiresConfirmation as toolRequiresConfirmation } from "../lib/tools/index.js";
+import { generateSessionId, saveSession, loadSession, listSessions } from "../lib/sessions/index.js";
+import { compactMessages, shouldCompact, estimateMessagesTokens } from "../lib/context.js";
+import { loadHooks, runHooks } from "../lib/hooks/index.js";
+import { loadPlugins, getSkillContext, getSlashCommand } from "../lib/plugins/index.js";
+import { checkPermission, loadPermissions } from "../lib/permissions.js";
+import { getMemoryContext } from "../lib/memory.js";
 import chalk from "chalk";
+import readline from "readline";
 
-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 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.
 
-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: [] },
-    },
-  },
-  {
-    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"],
-      },
-    },
-  },
-  {
-    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: [] },
-    },
-  },
-  {
+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
+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 CLOUD_TOOL_NAMES = new Set(CLOUD_TOOLS.map((t) => t.name));
+
+function buildTools() {
+  const localDefs = getToolDefinitions().map((t) => ({
     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"],
-      },
-    },
-  },
-  {
+    function: { name: t.name, description: t.description, parameters: t.parameters },
+  }));
+  const cloudDefs = CLOUD_TOOLS.map((t) => ({
     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) {
+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,15 +76,55 @@ 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 };
   }
 }
 
-// Parse SSE stream from the cloud proxy
+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(truncate(desc, 60))}? [Y/n] `), (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() !== "n");
+    });
+  });
+}
+
+async function executeTool(name, args) {
+  // Check permission rules
+  const permission = checkPermission(name, args);
+  if (permission === "deny") {
+    return { error: `Tool ${name} is denied by permission rules` };
+  }
+
+  // Run PreToolUse hooks
+  const hookResult = await runHooks("PreToolUse", { toolName: name, input: args });
+  if (!hookResult.allowed) {
+    return { error: hookResult.reason || `Blocked by hook` };
+  }
+
+  // Cloud tools
+  if (CLOUD_TOOL_NAMES.has(name)) {
+    const result = await executeCloudTool(name, args);
+    await runHooks("PostToolUse", { toolName: name, input: args, result });
+    return result;
+  }
+
+  // Local tools — check if confirmation needed
+  if (permission === "ask" || (permission !== "allow" && toolRequiresConfirmation(name))) {
+    const allowed = await confirmAction(name, args);
+    if (!allowed) return { error: "User denied execution" };
+  }
+
+  const result = await executeLocalTool(name, args);
+  await runHooks("PostToolUse", { toolName: name, input: args, result });
+  return result;
+}
+
 async function* parseSSEStream(response) {
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
@@ -182,9 +143,7 @@ async function* parseSSEStream(response) {
         if (line.startsWith("data: ")) {
           const data = line.slice(6).trim();
           if (data === "[DONE]") return;
-          try {
-            yield JSON.parse(data);
-          } catch {}
+          try { yield JSON.parse(data); } catch {}
         }
       }
     }
@@ -193,16 +152,108 @@ async function* parseSSEStream(response) {
   }
 }
 
-export async function runAgent(userRequest) {
-  const messages = [
-    { role: "system", content: SYSTEM_PROMPT },
-    { role: "user", content: userRequest },
-  ];
+// Active session state
+let currentSession = null;
+
+export async function runAgent(userRequest, options = {}) {
+  // Initialize systems
+  loadHooks();
+  loadPermissions();
+  const plugins = loadPlugins();
+  const memoryContext = getMemoryContext();
+  const skillContext = getSkillContext(plugins.skills, userRequest);
 
-  const MAX_ITERATIONS = 10;
+  // Check for slash commands
+  if (userRequest.startsWith("/")) {
+    const cmdName = userRequest.slice(1).split(/\s+/)[0];
+    const cmdArgs = userRequest.slice(1 + cmdName.length).trim();
+
+    // Built-in slash commands
+    if (cmdName === "sessions" || cmdName === "history") {
+      const sessions = listSessions();
+      if (sessions.length === 0) { log.info("No saved sessions."); return; }
+      log.brand("Sessions");
+      sessions.slice(0, 10).forEach((s) => {
+        console.log(`  ${chalk.dim(s.id.slice(0, 12))}  ${s.title}  ${chalk.dim(`(${s.messageCount} msgs)`)}`);
+      });
+      return;
+    }
+    if (cmdName === "resume") {
+      const sessions = listSessions();
+      if (sessions.length === 0) { log.info("No sessions to resume."); return; }
+      const target = cmdArgs ? sessions.find((s) => s.id.includes(cmdArgs)) : sessions[0];
+      if (!target) { log.error("Session not found."); return; }
+      const data = loadSession(target.id);
+      if (data) {
+        currentSession = { id: target.id, messages: data.messages, title: data.title };
+        log.success(`Resumed session: ${target.title}`);
+        log.dim(`${data.messages.length} messages loaded`);
+      }
+      return;
+    }
+    if (cmdName === "compact") {
+      if (!currentSession) { log.info("No active session to compact."); return; }
+      const before = estimateMessagesTokens(currentSession.messages);
+      const { messages } = compactMessages(currentSession.messages, 50000);
+      currentSession.messages = messages;
+      const after = estimateMessagesTokens(messages);
+      log.success(`Compacted: ~${Math.round(before / 1000)}k → ~${Math.round(after / 1000)}k tokens`);
+      return;
+    }
+    if (cmdName === "new") {
+      currentSession = null;
+      log.success("Started new session.");
+      return;
+    }
+
+    // Plugin slash commands
+    const cmd = getSlashCommand(plugins.commands, cmdName);
+    if (cmd) {
+      log.info(`Running /${cmdName}`);
+      userRequest = cmd.content.replace(/\$ARGUMENTS/g, cmdArgs).replace(/\$1/g, cmdArgs);
+    }
+  }
+
+  // Run SessionStart hooks on first message
+  if (!currentSession) {
+    await runHooks("SessionStart", { cwd: process.cwd() });
+  }
+
+  // Build or continue session
+  if (!currentSession) {
+    currentSession = {
+      id: generateSessionId(),
+      messages: [{ role: "system", content: SYSTEM_PROMPT + memoryContext + skillContext }],
+      title: userRequest.slice(0, 60),
+      createdAt: Date.now(),
+    };
+  } else {
+    // Inject fresh skill context if relevant
+    if (skillContext) {
+      const sysMsg = currentSession.messages.find((m) => m.role === "system");
+      if (sysMsg && !sysMsg.content.includes(skillContext)) {
+        sysMsg.content += skillContext;
+      }
+    }
+  }
+
+  currentSession.messages.push({ role: "user", content: userRequest });
+  currentSession.updatedAt = Date.now();
+
+  // Auto-compact if conversation is too long
+  if (shouldCompact(currentSession.messages)) {
+    const { messages, compacted } = compactMessages(currentSession.messages);
+    if (compacted) {
+      currentSession.messages = messages;
+      log.dim("Context auto-compacted to fit window.");
+    }
+  }
+
+  const ALL_TOOLS = buildTools();
+  const MAX_ITERATIONS = 15;
 
   for (let i = 0; i < MAX_ITERATIONS; i++) {
-    const response = await apiClient.chatStream(messages, TOOLS);
+    const response = await apiClient.chatStream(currentSession.messages, ALL_TOOLS);
 
     let fullText = "";
     const toolCalls = {};
@@ -219,9 +270,7 @@ export async function runAgent(userRequest) {
       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 (!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;
@@ -233,29 +282,29 @@ export async function runAgent(userRequest) {
 
     const toolCallList = Object.values(toolCalls);
 
-    // No tool calls — final text response, done
     if (toolCallList.length === 0) {
       if (fullText) process.stdout.write("\n");
+      // Save assistant response to session
+      currentSession.messages.push({ role: "assistant", content: fullText });
+      saveSession(currentSession.id, currentSession);
       return;
     }
 
     if (fullText) process.stdout.write("\n");
 
-    // Build assistant message with tool calls
     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 },
+      id: tc.id, type: "function", function: { name: tc.name, arguments: tc.arguments },
     }));
-    messages.push(assistantMsg);
+    currentSession.messages.push(assistantMsg);
 
-    // Execute each tool and add results
     for (const tc of toolCallList) {
       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,28 +314,32 @@ export async function runAgent(userRequest) {
         log.success(tc.name);
       }
 
-      messages.push({
-        role: "tool",
-        tool_call_id: tc.id,
-        content: JSON.stringify(result),
-      });
+      const resultStr = JSON.stringify(result);
+      const truncatedResult = resultStr.length > 8000 ? resultStr.slice(0, 8000) + "...(truncated)" : resultStr;
+
+      currentSession.messages.push({ role: "tool", tool_call_id: tc.id, content: truncatedResult });
     }
+
+    // Save session after each tool round
+    saveSession(currentSession.id, currentSession);
   }
 
-  log.warn("Agent reached maximum iterations (10). Stopping.");
+  log.warn("Agent reached maximum iterations (15). Stopping.");
+  await runHooks("Stop", { reason: "max_iterations" });
+}
+
+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 {
-        await runAgent(request);
-      } catch (err) {
-        log.error(err.message);
-      }
+      try { await runAgent(request); }
+      catch (err) { log.error(err.message); }
     });
 }

package/src/lib/context.js

@@ -0,0 +1,56 @@
+// Simple token estimation (~4 chars per token for English)
+function estimateTokens(text) {
+  return Math.ceil((text || "").length / 4);
+}
+
+export function estimateMessagesTokens(messages) {
+  return messages.reduce((sum, m) => {
+    const content = typeof m.content === "string" ? m.content : JSON.stringify(m.content || "");
+    return sum + estimateTokens(content) + 4; // 4 tokens overhead per message
+  }, 0);
+}
+
+// Compress conversation by summarizing old tool results and trimming history
+export function compactMessages(messages, maxTokens = 100000) {
+  const currentTokens = estimateMessagesTokens(messages);
+  if (currentTokens <= maxTokens) return { messages, compacted: false };
+
+  const compacted = [];
+  const systemMsg = messages.find((m) => m.role === "system");
+  if (systemMsg) compacted.push(systemMsg);
+
+  // Keep recent messages (last 20), compress older ones
+  const nonSystem = messages.filter((m) => m.role !== "system");
+  const keepRecent = 20;
+  const old = nonSystem.slice(0, -keepRecent);
+  const recent = nonSystem.slice(-keepRecent);
+
+  if (old.length > 0) {
+    // Build a summary of old messages
+    const userMessages = old.filter((m) => m.role === "user" && typeof m.content === "string");
+    const toolResults = old.filter((m) => m.role === "tool");
+
+    let summary = "[Conversation history compacted]\n";
+    summary += `Previous turns: ${old.length} messages\n`;
+
+    if (userMessages.length > 0) {
+      summary += "Topics discussed:\n";
+      userMessages.forEach((m) => {
+        summary += `- ${m.content.slice(0, 100)}\n`;
+      });
+    }
+
+    summary += `Tool calls made: ${toolResults.length}\n`;
+
+    compacted.push({ role: "user", content: summary });
+    compacted.push({ role: "assistant", content: "Understood. I have context from the previous conversation. Let's continue." });
+  }
+
+  compacted.push(...recent);
+  return { messages: compacted, compacted: true };
+}
+
+// Check if we should auto-compact
+export function shouldCompact(messages, threshold = 80000) {
+  return estimateMessagesTokens(messages) > threshold;
+}

package/src/lib/hooks/index.js

@@ -0,0 +1,82 @@
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { execSync } from "child_process";
+import { log } from "../logger.js";
+
+// Hook events: PreToolUse, PostToolUse, Stop, SessionStart, SessionEnd
+// Hooks are loaded from .cheri/hooks.json in the project directory
+
+const HOOKS_FILE = ".cheri/hooks.json";
+
+let loadedHooks = null;
+
+export function loadHooks(projectDir = process.cwd()) {
+  const hooksPath = join(projectDir, HOOKS_FILE);
+  if (!existsSync(hooksPath)) {
+    loadedHooks = {};
+    return loadedHooks;
+  }
+  try {
+    loadedHooks = JSON.parse(readFileSync(hooksPath, "utf-8"));
+  } catch {
+    loadedHooks = {};
+  }
+  return loadedHooks;
+}
+
+export function getHooks(event) {
+  if (!loadedHooks) loadHooks();
+  return loadedHooks[event] || [];
+}
+
+// Run hooks for an event. Returns { allowed: bool, reason?: string }
+export async function runHooks(event, context = {}) {
+  const hooks = getHooks(event);
+  if (hooks.length === 0) return { allowed: true };
+
+  for (const hook of hooks) {
+    // Check matcher
+    if (hook.matcher && context.toolName) {
+      const matchers = hook.matcher.split("|");
+      if (!matchers.some((m) => context.toolName.match(new RegExp(m)))) {
+        continue;
+      }
+    }
+
+    for (const h of hook.hooks || [hook]) {
+      try {
+        if (h.type === "command") {
+          const input = JSON.stringify(context);
+          const timeout = (h.timeout || 10) * 1000;
+          const result = execSync(h.command, {
+            input,
+            encoding: "utf-8",
+            timeout,
+            stdio: ["pipe", "pipe", "pipe"],
+            cwd: process.cwd(),
+          });
+
+          try {
+            const output = JSON.parse(result.trim());
+            if (output.decision === "block") {
+              return { allowed: false, reason: output.reason || "Blocked by hook" };
+            }
+          } catch {
+            // Non-JSON output is fine, treat as allow
+          }
+        }
+      } catch (err) {
+        if (err.status === 2) {
+          // Exit code 2 = block
+          return { allowed: false, reason: err.stderr || "Blocked by hook" };
+        }
+        // Exit code 1 = warn but allow
+        if (err.status === 1 && err.stderr) {
+          log.warn(`Hook: ${err.stderr.trim()}`);
+        }
+      }
+    }
+  }
+
+  return { allowed: true };
+}

package/src/lib/memory.js

@@ -0,0 +1,73 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// Memory scopes:
+// - user: ~/.cheri/memory.json (global, follows user)
+// - project: .cheri/memory.json (per-project, in git)
+// - local: .cheri/memory.local.json (per-project, gitignored)
+
+const USER_MEMORY_PATH = join(homedir(), ".cheri", "memory.json");
+const PROJECT_MEMORY_FILE = ".cheri/memory.json";
+const LOCAL_MEMORY_FILE = ".cheri/memory.local.json";
+
+function loadMemoryFile(filePath) {
+  if (!existsSync(filePath)) return [];
+  try {
+    return JSON.parse(readFileSync(filePath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+
+function saveMemoryFile(filePath, entries) {
+  const dir = join(filePath, "..");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(filePath, JSON.stringify(entries, null, 2), "utf-8");
+}
+
+export function getMemory(scope = "all", projectDir = process.cwd()) {
+  const memories = {};
+
+  if (scope === "all" || scope === "user") {
+    memories.user = loadMemoryFile(USER_MEMORY_PATH);
+  }
+  if (scope === "all" || scope === "project") {
+    memories.project = loadMemoryFile(join(projectDir, PROJECT_MEMORY_FILE));
+  }
+  if (scope === "all" || scope === "local") {
+    memories.local = loadMemoryFile(join(projectDir, LOCAL_MEMORY_FILE));
+  }
+
+  return memories;
+}
+
+export function addMemory(content, scope = "project", category = "general", projectDir = process.cwd()) {
+  const filePath = scope === "user" ? USER_MEMORY_PATH :
+    scope === "local" ? join(projectDir, LOCAL_MEMORY_FILE) :
+    join(projectDir, PROJECT_MEMORY_FILE);
+
+  const entries = loadMemoryFile(filePath);
+  entries.push({ content, category, scope, createdAt: new Date().toISOString() });
+  saveMemoryFile(filePath, entries);
+  return entries.length;
+}
+
+export function clearMemory(scope = "all", projectDir = process.cwd()) {
+  if (scope === "all" || scope === "user") saveMemoryFile(USER_MEMORY_PATH, []);
+  if (scope === "all" || scope === "project") saveMemoryFile(join(projectDir, PROJECT_MEMORY_FILE), []);
+  if (scope === "all" || scope === "local") saveMemoryFile(join(projectDir, LOCAL_MEMORY_FILE), []);
+}
+
+// Build memory context string for system prompt
+export function getMemoryContext(projectDir = process.cwd()) {
+  const all = getMemory("all", projectDir);
+  const entries = [...(all.user || []), ...(all.project || []), ...(all.local || [])];
+  if (entries.length === 0) return "";
+
+  let context = "\n\n## Memory\nThe following are remembered preferences and context:\n";
+  for (const entry of entries) {
+    context += `- [${entry.scope}/${entry.category}] ${entry.content}\n`;
+  }
+  return context;
+}

package/src/lib/permissions.js

@@ -0,0 +1,69 @@
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+
+// Permission rules loaded from .cheri/permissions.json
+// Format: { "allow": ["read_file", "list_directory"], "ask": ["run_command", "write_file"], "deny": ["clear_memory"] }
+// Bash patterns: "run_command(npm:*)" allows npm commands
+
+const PERMISSIONS_FILE = ".cheri/permissions.json";
+let rules = null;
+
+export function loadPermissions(projectDir = process.cwd()) {
+  const filePath = join(projectDir, PERMISSIONS_FILE);
+  if (!existsSync(filePath)) {
+    rules = { allow: [], ask: [], deny: [] };
+    return rules;
+  }
+  try {
+    rules = JSON.parse(readFileSync(filePath, "utf-8"));
+  } catch {
+    rules = { allow: [], ask: [], deny: [] };
+  }
+  return rules;
+}
+
+export function checkPermission(toolName, input = {}) {
+  if (!rules) loadPermissions();
+
+  // Check deny first
+  for (const pattern of rules.deny || []) {
+    if (matchesPattern(toolName, input, pattern)) {
+      return "deny";
+    }
+  }
+
+  // Check allow
+  for (const pattern of rules.allow || []) {
+    if (matchesPattern(toolName, input, pattern)) {
+      return "allow";
+    }
+  }
+
+  // Check ask
+  for (const pattern of rules.ask || []) {
+    if (matchesPattern(toolName, input, pattern)) {
+      return "ask";
+    }
+  }
+
+  // Default: allow for read-only tools, ask for others
+  const readOnlyTools = ["read_file", "list_directory", "search_files", "search_content", "get_account_info", "list_workspaces", "get_memory", "get_usage", "get_config", "get_workspace_status"];
+  return readOnlyTools.includes(toolName) ? "allow" : "ask";
+}
+
+function matchesPattern(toolName, input, pattern) {
+  // Simple match: "read_file"
+  if (pattern === toolName) return true;
+
+  // Pattern match: "run_command(npm:*)"
+  const match = pattern.match(/^(\w+)\((.+)\)$/);
+  if (match && match[1] === toolName) {
+    const argPattern = match[2];
+    const command = input.command || "";
+    // Convert glob to regex
+    const regex = new RegExp("^" + argPattern.replace(/\*/g, ".*").replace(/:/g, "\\s*") + "$");
+    return regex.test(command);
+  }
+
+  return false;
+}

package/src/lib/plugins/index.js

@@ -0,0 +1,138 @@
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join, resolve } from "path";
+import { log } from "../logger.js";
+
+const PLUGIN_DIR = ".cheri";
+const SKILLS_DIR = "skills";
+const COMMANDS_DIR = "commands";
+const AGENTS_DIR = "agents";
+
+// Load all plugins from .cheri/ directory
+export function loadPlugins(projectDir = process.cwd()) {
+  const cheriDir = join(projectDir, PLUGIN_DIR);
+  if (!existsSync(cheriDir)) return { skills: [], commands: [], agents: [] };
+
+  return {
+    skills: loadSkills(cheriDir),
+    commands: loadCommands(cheriDir),
+    agents: loadAgents(cheriDir),
+  };
+}
+
+// Load skills from .cheri/skills/
+function loadSkills(cheriDir) {
+  const skillsDir = join(cheriDir, SKILLS_DIR);
+  if (!existsSync(skillsDir)) return [];
+
+  const skills = [];
+  for (const entry of readdirSync(skillsDir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      const skillFile = join(skillsDir, entry.name, "SKILL.md");
+      if (existsSync(skillFile)) {
+        const parsed = parseMarkdownWithFrontmatter(readFileSync(skillFile, "utf-8"));
+        skills.push({
+          name: parsed.frontmatter.name || entry.name,
+          description: parsed.frontmatter.description || "",
+          trigger: parsed.frontmatter.trigger || "",
+          content: parsed.body,
+          dir: join(skillsDir, entry.name),
+        });
+      }
+    }
+  }
+  return skills;
+}
+
+// Load slash commands from .cheri/commands/
+function loadCommands(cheriDir) {
+  const commandsDir = join(cheriDir, COMMANDS_DIR);
+  if (!existsSync(commandsDir)) return [];
+
+  const commands = [];
+  for (const file of readdirSync(commandsDir)) {
+    if (file.endsWith(".md")) {
+      const content = readFileSync(join(commandsDir, file), "utf-8");
+      const parsed = parseMarkdownWithFrontmatter(content);
+      commands.push({
+        name: file.replace(".md", ""),
+        description: parsed.frontmatter.description || "",
+        allowedTools: parsed.frontmatter["allowed-tools"] || "",
+        content: parsed.body,
+      });
+    }
+  }
+  return commands;
+}
+
+// Load agent definitions from .cheri/agents/
+function loadAgents(cheriDir) {
+  const agentsDir = join(cheriDir, AGENTS_DIR);
+  if (!existsSync(agentsDir)) return [];
+
+  const agents = [];
+  for (const file of readdirSync(agentsDir)) {
+    if (file.endsWith(".md")) {
+      const content = readFileSync(join(agentsDir, file), "utf-8");
+      const parsed = parseMarkdownWithFrontmatter(content);
+      agents.push({
+        name: parsed.frontmatter.name || file.replace(".md", ""),
+        description: parsed.frontmatter.description || "",
+        model: parsed.frontmatter.model || "inherit",
+        tools: parsed.frontmatter.tools || [],
+        systemPrompt: parsed.body,
+      });
+    }
+  }
+  return agents;
+}
+
+// Parse markdown with YAML frontmatter (--- delimited)
+function parseMarkdownWithFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) return { frontmatter: {}, body: content };
+
+  const frontmatter = {};
+  for (const line of match[1].split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx > 0) {
+      const key = line.slice(0, colonIdx).trim();
+      let value = line.slice(colonIdx + 1).trim();
+      // Parse arrays
+      if (value.startsWith("[") && value.endsWith("]")) {
+        try { value = JSON.parse(value); } catch {}
+      }
+      frontmatter[key] = value;
+    }
+  }
+
+  return { frontmatter, body: match[2].trim() };
+}
+
+// Get extra system prompt context from skills that match the user's request
+export function getSkillContext(skills, userMessage) {
+  const matched = [];
+  const lowerMsg = userMessage.toLowerCase();
+
+  for (const skill of skills) {
+    // Match by trigger keyword or description
+    const triggers = skill.trigger ? skill.trigger.split(",").map((t) => t.trim().toLowerCase()) : [];
+    const descWords = skill.description.toLowerCase().split(/\s+/);
+    const nameMatch = lowerMsg.includes(skill.name.toLowerCase());
+    const triggerMatch = triggers.some((t) => lowerMsg.includes(t));
+    const descMatch = descWords.filter((w) => w.length > 4).some((w) => lowerMsg.includes(w));
+
+    if (nameMatch || triggerMatch || descMatch) {
+      matched.push(skill);
+    }
+  }
+
+  if (matched.length === 0) return "";
+
+  return "\n\n## Active Skills\n" +
+    matched.map((s) => `### ${s.name}\n${s.content}`).join("\n\n");
+}
+
+// Execute a slash command
+export function getSlashCommand(commands, name) {
+  return commands.find((c) => c.name === name);
+}

package/src/lib/sessions/index.js

@@ -0,0 +1,56 @@
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const SESSIONS_DIR = join(homedir(), ".cheri", "sessions");
+
+function ensureDir() {
+  if (!existsSync(SESSIONS_DIR)) {
+    mkdirSync(SESSIONS_DIR, { recursive: true });
+  }
+}
+
+export function generateSessionId() {
+  return `s-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+export function saveSession(sessionId, data) {
+  ensureDir();
+  const filePath = join(SESSIONS_DIR, `${sessionId}.json`);
+  writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+}
+
+export function loadSession(sessionId) {
+  const filePath = join(SESSIONS_DIR, `${sessionId}.json`);
+  if (!existsSync(filePath)) return null;
+  return JSON.parse(readFileSync(filePath, "utf-8"));
+}
+
+export function listSessions() {
+  ensureDir();
+  const files = readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".json"));
+  return files.map((f) => {
+    try {
+      const data = JSON.parse(readFileSync(join(SESSIONS_DIR, f), "utf-8"));
+      return {
+        id: f.replace(".json", ""),
+        title: data.title || data.messages?.[1]?.content?.slice(0, 60) || "Untitled",
+        messageCount: data.messages?.length || 0,
+        createdAt: data.createdAt,
+        updatedAt: data.updatedAt,
+      };
+    } catch {
+      return { id: f.replace(".json", ""), title: "Corrupted", messageCount: 0 };
+    }
+  }).sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
+}
+
+export function deleteSession(sessionId) {
+  const filePath = join(SESSIONS_DIR, `${sessionId}.json`);
+  if (existsSync(filePath)) {
+    const { unlinkSync } = require("fs");
+    unlinkSync(filePath);
+    return true;
+  }
+  return false;
+}

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

@@ -54,6 +54,11 @@ function showHelp() {
 }
 
 async function dispatch(input) {
+  // Strip "cheri " prefix if user types it inside the REPL
+  if (input.startsWith("cheri ")) {
+    input = input.slice(6);
+  }
+
   const parts = input.split(/\s+/);
   const cmd = parts[0];
   const sub = parts[1];
@@ -179,9 +184,16 @@ async function dispatch(input) {
       return;
     }
 
-    default:
+    default: {
       // Treat any unrecognized input as an agent request
+      const { getConfigValue } = await import("./lib/config-store.js");
+      const token = getConfigValue("token");
+      if (!token) {
+        log.warn("Not logged in. Type " + chalk.cyan("login") + " first to authenticate.");
+        return;
+      }
       await runAgent(input);
+    }
   }
 }