@heysalad/cheri-cli 0.2.0 → 0.3.1

package/src/lib/repl.js

@@ -1,225 +0,0 @@
-import readline from "readline";
-import chalk from "chalk";
-import ora from "ora";
-import { createProvider } from "./providers/index.js";
-import { getToolDefinitions, executeTool, requiresConfirmation } from "./tools/index.js";
-import { showStartupScreen } from "./branding.js";
-import { renderMarkdown, renderToolUse, renderToolResult } from "./renderer.js";
-
-export async function startRepl(options = {}) {
-  showStartupScreen(options);
-
-  let provider;
-  try {
-    provider = await createProvider(options);
-  } catch (err) {
-    console.error(chalk.red(`\n${err.message}`));
-    process.exit(1);
-  }
-
-  const messages = [];
-  const tools = getToolDefinitions();
-
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    prompt: "🍒 > ",
-  });
-
-  rl.prompt();
-
-  rl.on("line", async (line) => {
-    const input = line.trim();
-    if (!input) {
-      rl.prompt();
-      return;
-    }
-
-    // Slash commands
-    if (input.startsWith("/")) {
-      await handleSlashCommand(input, messages, provider, options, rl);
-      rl.prompt();
-      return;
-    }
-
-    // Add user message
-    messages.push({ role: "user", content: input });
-
-    // Run agent loop
-    await agentLoop(provider, messages, tools, rl);
-    rl.prompt();
-  });
-
-  rl.on("close", () => {
-    console.log(chalk.dim("\nGoodbye! 🍒"));
-    process.exit(0);
-  });
-}
-
-async function agentLoop(provider, messages, tools, rl) {
-  let continueLoop = true;
-
-  while (continueLoop) {
-    continueLoop = false;
-    const spinner = ora({ text: "Thinking...", color: "yellow" }).start();
-
-    let fullText = "";
-    const toolCalls = [];
-    let streamingStarted = false;
-
-    try {
-      for await (const event of provider.chat(messages, tools)) {
-        switch (event.type) {
-          case "text":
-            if (!streamingStarted) {
-              spinner.stop();
-              streamingStarted = true;
-            }
-            process.stdout.write(event.content);
-            fullText += event.content;
-            break;
-
-          case "tool_use_start":
-            if (!streamingStarted) {
-              spinner.stop();
-              streamingStarted = true;
-            }
-            toolCalls.push({ id: event.id, name: event.name, inputJson: "", input: {} });
-            break;
-
-          case "tool_input_delta":
-            if (toolCalls.length > 0) {
-              toolCalls[toolCalls.length - 1].inputJson += event.content;
-            }
-            break;
-
-          case "tool_use_end":
-            if (toolCalls.length > 0) {
-              const tc = toolCalls[toolCalls.length - 1];
-              tc.input = event.input;
-            }
-            break;
-
-          case "done":
-            spinner.stop();
-            if (event.stopReason === "tool_use" || toolCalls.length > 0) {
-              continueLoop = true;
-            }
-            break;
-        }
-      }
-    } catch (err) {
-      spinner.stop();
-      console.error(chalk.red(`\n❌ API Error: ${err.message}`));
-      // Remove the last user message on error so conversation stays valid
-      if (messages.length > 0 && messages[messages.length - 1].role === "user") {
-        messages.pop();
-      }
-      return;
-    }
-
-    // End text output with newline if we streamed any text
-    if (fullText) {
-      process.stdout.write("\n");
-    }
-
-    // Build assistant message content
-    const assistantContent = [];
-    if (fullText) {
-      assistantContent.push({ type: "text", text: fullText });
-    }
-    for (const tc of toolCalls) {
-      assistantContent.push({ type: "tool_use", id: tc.id, name: tc.name, input: tc.input });
-    }
-    if (assistantContent.length > 0) {
-      messages.push({ role: "assistant", content: assistantContent });
-    }
-
-    // Execute tool calls if any
-    if (toolCalls.length > 0) {
-      const toolResults = [];
-
-      for (const tc of toolCalls) {
-        console.log(renderToolUse(tc.name, tc.input));
-
-        // Confirmation for dangerous commands
-        if (requiresConfirmation(tc.name)) {
-          const confirmed = await askConfirmation(rl, `Run command: ${chalk.bold(tc.input.command || "")}`);
-          if (!confirmed) {
-            toolResults.push({
-              type: "tool_result",
-              tool_use_id: tc.id,
-              content: "User denied execution of this command.",
-            });
-            console.log(chalk.yellow("⏭️  Skipped"));
-            continue;
-          }
-          const cmdSpinner = ora({ text: `Running: ${tc.input.command}`, color: "red" }).start();
-          const result = await executeTool(tc.name, tc.input);
-          cmdSpinner.stop();
-          console.log(renderToolResult(tc.name, result));
-          toolResults.push({
-            type: "tool_result",
-            tool_use_id: tc.id,
-            content: JSON.stringify(result),
-          });
-        } else {
-          const toolSpinner = ora({ text: `${tc.name}...`, color: "magenta" }).start();
-          const result = await executeTool(tc.name, tc.input);
-          toolSpinner.stop();
-          console.log(renderToolResult(tc.name, result));
-          toolResults.push({
-            type: "tool_result",
-            tool_use_id: tc.id,
-            content: JSON.stringify(result),
-          });
-        }
-      }
-
-      messages.push({ role: "user", content: toolResults });
-    }
-  }
-}
-
-function askConfirmation(rl, message) {
-  return new Promise((resolve) => {
-    rl.question(`${chalk.yellow("⚡")} ${message} ${chalk.dim("[Y/n]")} `, (answer) => {
-      const a = answer.trim().toLowerCase();
-      resolve(a === "" || a === "y" || a === "yes");
-    });
-  });
-}
-
-async function handleSlashCommand(input, messages, provider, options, rl) {
-  const [cmd, ...args] = input.split(/\s+/);
-
-  switch (cmd) {
-    case "/help":
-      console.log(`
-${chalk.bold("Cheri REPL Commands:")}
-  ${chalk.cyan("/help")}    Show this help
-  ${chalk.cyan("/clear")}   Clear conversation history
-  ${chalk.cyan("/model")}   Show current model info
-  ${chalk.cyan("/exit")}    Exit the REPL
-`);
-      break;
-
-    case "/clear":
-      messages.length = 0;
-      console.log(chalk.dim("Conversation cleared."));
-      break;
-
-    case "/model":
-      console.log(`  Provider: ${chalk.cyan(options.provider || "anthropic")}`);
-      console.log(`  Model:    ${chalk.cyan(provider.getModel())}`);
-      break;
-
-    case "/exit":
-      console.log(chalk.dim("Goodbye! 🍒"));
-      process.exit(0);
-      break;
-
-    default:
-      console.log(chalk.yellow(`Unknown command: ${cmd}. Type /help for available commands.`));
-  }
-}

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

@@ -1,34 +0,0 @@
-import { execSync } from "child_process";
-
-export const runCommand = {
-  name: "run_command",
-  description: "Execute a shell command and return its output. Requires user confirmation before execution.",
-  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

@@ -1,73 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

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