@gemdoq/codi 0.1.0

package/dist/cli.js

@@ -0,0 +1,4569 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/ui/renderer.ts
+var renderer_exports = {};
+__export(renderer_exports, {
+  renderAssistantPrefix: () => renderAssistantPrefix,
+  renderCodeBlock: () => renderCodeBlock,
+  renderDiff: () => renderDiff,
+  renderError: () => renderError,
+  renderInfo: () => renderInfo,
+  renderMarkdown: () => renderMarkdown,
+  renderPrompt: () => renderPrompt,
+  renderSuccess: () => renderSuccess,
+  renderToolCall: () => renderToolCall,
+  renderToolResult: () => renderToolResult,
+  renderUserMessage: () => renderUserMessage,
+  renderWarning: () => renderWarning
+});
+import chalk2 from "chalk";
+import { marked } from "marked";
+import TerminalRenderer from "marked-terminal";
+import { highlight } from "cli-highlight";
+import { createTwoFilesPatch } from "diff";
+function renderMarkdown(text) {
+  try {
+    const rendered = marked.parse(text);
+    return (typeof rendered === "string" ? rendered : "").trimEnd();
+  } catch {
+    return text;
+  }
+}
+function renderDiff(filePath, oldContent, newContent) {
+  if (!filePath && !oldContent && newContent) {
+    return colorDiffLines(newContent);
+  }
+  const patch = createTwoFilesPatch(
+    `a/${filePath}`,
+    `b/${filePath}`,
+    oldContent,
+    newContent,
+    "",
+    "",
+    { context: 3 }
+  );
+  return colorDiffLines(patch);
+}
+function colorDiffLines(text) {
+  return text.split("\n").map((line) => {
+    if (line.startsWith("+++") || line.startsWith("---")) {
+      return chalk2.bold(line);
+    }
+    if (line.startsWith("+")) {
+      return chalk2.green(line);
+    }
+    if (line.startsWith("-")) {
+      return chalk2.red(line);
+    }
+    if (line.startsWith("@@")) {
+      return chalk2.cyan(line);
+    }
+    return chalk2.dim(line);
+  }).join("\n");
+}
+function renderCodeBlock(code, language) {
+  try {
+    return highlight(code, { language, ignoreIllegals: true });
+  } catch {
+    return chalk2.cyan(code);
+  }
+}
+function renderToolCall(toolName, args) {
+  const header = chalk2.yellow(`\u26A1 ${toolName}`);
+  const argStr = Object.entries(args).map(([k, v]) => {
+    const val = typeof v === "string" && v.length > 100 ? v.slice(0, 100) + "..." : String(v);
+    return chalk2.dim(`  ${k}: `) + val;
+  }).join("\n");
+  return `${header}
+${argStr}`;
+}
+function renderToolResult(toolName, result, isError) {
+  const icon = isError ? chalk2.red("\u2717") : chalk2.green("\u2713");
+  const header = `${icon} ${chalk2.yellow(toolName)}`;
+  const content = isError ? chalk2.red(result) : chalk2.dim(result);
+  const maxLen = 500;
+  const truncated = content.length > maxLen ? content.slice(0, maxLen) + chalk2.dim("\n... (truncated)") : content;
+  return `${header}
+${truncated}`;
+}
+function renderError(message) {
+  return chalk2.red(`\u2717 ${message}`);
+}
+function renderWarning(message) {
+  return chalk2.yellow(`\u26A0 ${message}`);
+}
+function renderInfo(message) {
+  return chalk2.blue(`\u2139 ${message}`);
+}
+function renderSuccess(message) {
+  return chalk2.green(`\u2713 ${message}`);
+}
+function renderUserMessage(message) {
+  return chalk2.white(message);
+}
+function renderAssistantPrefix() {
+  return chalk2.green.bold("codi");
+}
+function renderPrompt() {
+  return chalk2.cyan.bold("codi > ");
+}
+var renderer;
+var init_renderer = __esm({
+  "src/ui/renderer.ts"() {
+    "use strict";
+    init_esm_shims();
+    renderer = new TerminalRenderer({
+      codespan: chalk2.cyan,
+      strong: chalk2.bold,
+      em: chalk2.italic,
+      heading: chalk2.green.bold,
+      firstHeading: chalk2.magenta.underline.bold,
+      code: chalk2.yellow,
+      link: chalk2.blue,
+      href: chalk2.blue.underline,
+      unescape: true,
+      emoji: false,
+      width: process.stdout.columns || 100,
+      tab: 2
+    });
+    marked.setOptions({ renderer });
+  }
+});
+
+// src/tools/tool.ts
+function makeToolResult(output3, metadata) {
+  return { success: true, output: output3, metadata };
+}
+function makeToolError(error, metadata) {
+  return { success: false, output: error, error, metadata };
+}
+var init_tool = __esm({
+  "src/tools/tool.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/tools/task-tools.ts
+var task_tools_exports = {};
+__export(task_tools_exports, {
+  taskCreateTool: () => taskCreateTool,
+  taskGetTool: () => taskGetTool,
+  taskListTool: () => taskListTool,
+  taskManager: () => taskManager,
+  taskUpdateTool: () => taskUpdateTool
+});
+function formatTask(task) {
+  const lines = [
+    `#${task.id} [${task.status}] ${task.subject}`
+  ];
+  if (task.description) lines.push(`  ${task.description}`);
+  if (task.owner) lines.push(`  Owner: ${task.owner}`);
+  if (task.blocks.length) lines.push(`  Blocks: ${task.blocks.join(", ")}`);
+  if (task.blockedBy.length) lines.push(`  Blocked by: ${task.blockedBy.join(", ")}`);
+  return lines.join("\n");
+}
+var TaskManager, taskManager, taskCreateTool, taskUpdateTool, taskListTool, taskGetTool;
+var init_task_tools = __esm({
+  "src/tools/task-tools.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_tool();
+    TaskManager = class {
+      tasks = /* @__PURE__ */ new Map();
+      nextId = 1;
+      create(subject, description, activeForm) {
+        const id = String(this.nextId++);
+        const task = {
+          id,
+          subject,
+          description,
+          activeForm,
+          status: "pending",
+          blocks: [],
+          blockedBy: [],
+          metadata: {},
+          createdAt: Date.now(),
+          updatedAt: Date.now()
+        };
+        this.tasks.set(id, task);
+        return task;
+      }
+      get(id) {
+        return this.tasks.get(id);
+      }
+      update(id, updates) {
+        const task = this.tasks.get(id);
+        if (!task) return void 0;
+        if (updates.status) task.status = updates.status;
+        if (updates.subject) task.subject = updates.subject;
+        if (updates.description) task.description = updates.description;
+        if (updates.activeForm) task.activeForm = updates.activeForm;
+        if (updates.owner) task.owner = updates.owner;
+        if (updates.metadata) Object.assign(task.metadata, updates.metadata);
+        if (updates.addBlocks) {
+          task.blocks = [.../* @__PURE__ */ new Set([...task.blocks, ...updates.addBlocks])];
+        }
+        if (updates.addBlockedBy) {
+          task.blockedBy = [.../* @__PURE__ */ new Set([...task.blockedBy, ...updates.addBlockedBy])];
+        }
+        if (updates.status === "deleted") {
+          this.tasks.delete(id);
+        }
+        task.updatedAt = Date.now();
+        return task;
+      }
+      list() {
+        return [...this.tasks.values()].filter((t) => t.status !== "deleted");
+      }
+    };
+    taskManager = new TaskManager();
+    taskCreateTool = {
+      name: "task_create",
+      description: `Create a new task to track work.`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          subject: { type: "string", description: "Brief task title" },
+          description: { type: "string", description: "Detailed description" },
+          activeForm: { type: "string", description: 'Present continuous form (e.g., "Running tests")' }
+        },
+        required: ["subject", "description"]
+      },
+      dangerous: false,
+      readOnly: false,
+      async execute(input3) {
+        const task = taskManager.create(
+          String(input3["subject"]),
+          String(input3["description"]),
+          input3["activeForm"] ? String(input3["activeForm"]) : void 0
+        );
+        return makeToolResult(`Task #${task.id} created: ${task.subject}`);
+      }
+    };
+    taskUpdateTool = {
+      name: "task_update",
+      description: `Update a task's status, description, or dependencies.`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          taskId: { type: "string", description: "Task ID" },
+          status: { type: "string", enum: ["pending", "in_progress", "completed", "deleted"] },
+          subject: { type: "string" },
+          description: { type: "string" },
+          activeForm: { type: "string" },
+          owner: { type: "string" },
+          addBlocks: { type: "array", items: { type: "string" } },
+          addBlockedBy: { type: "array", items: { type: "string" } }
+        },
+        required: ["taskId"]
+      },
+      dangerous: false,
+      readOnly: false,
+      async execute(input3) {
+        const task = taskManager.update(String(input3["taskId"]), input3);
+        if (!task) return makeToolError(`Task not found: ${input3["taskId"]}`);
+        return makeToolResult(`Task #${task.id} updated: ${formatTask(task)}`);
+      }
+    };
+    taskListTool = {
+      name: "task_list",
+      description: `List all tasks with their status.`,
+      inputSchema: {
+        type: "object",
+        properties: {},
+        required: []
+      },
+      dangerous: false,
+      readOnly: true,
+      async execute() {
+        const tasks = taskManager.list();
+        if (tasks.length === 0) {
+          return makeToolResult("No tasks.");
+        }
+        return makeToolResult(tasks.map(formatTask).join("\n\n"));
+      }
+    };
+    taskGetTool = {
+      name: "task_get",
+      description: `Get full details of a specific task.`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          taskId: { type: "string", description: "Task ID" }
+        },
+        required: ["taskId"]
+      },
+      dangerous: false,
+      readOnly: true,
+      async execute(input3) {
+        const task = taskManager.get(String(input3["taskId"]));
+        if (!task) return makeToolError(`Task not found: ${input3["taskId"]}`);
+        return makeToolResult(formatTask(task));
+      }
+    };
+  }
+});
+
+// src/cli.ts
+init_esm_shims();
+import chalk13 from "chalk";
+
+// src/setup-wizard.ts
+init_esm_shims();
+import * as fs from "fs";
+import * as path2 from "path";
+import chalk from "chalk";
+import * as readline from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+var SETTINGS_DIR = path2.join(
+  process.env["HOME"] || process.env["USERPROFILE"] || "~",
+  ".codi"
+);
+var SETTINGS_PATH = path2.join(SETTINGS_DIR, "settings.json");
+async function needsSetup() {
+  if (process.env["GEMINI_API_KEY"]) return false;
+  if (process.env["OPENAI_API_KEY"]) return false;
+  if (process.env["ANTHROPIC_API_KEY"]) return false;
+  if (fs.existsSync(SETTINGS_PATH)) {
+    try {
+      const content = fs.readFileSync(SETTINGS_PATH, "utf-8");
+      const settings = JSON.parse(content);
+      if (settings.apiKeys?.openai || settings.apiKeys?.anthropic) {
+        return false;
+      }
+    } catch {
+    }
+  }
+  return true;
+}
+async function runSetupWizard() {
+  const rl = readline.createInterface({ input, output });
+  console.log("");
+  console.log(chalk.cyan.bold("  \u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E"));
+  console.log(chalk.cyan.bold("  \u2502") + chalk.white.bold("     Codi (\uCF54\uB514) - First Time Setup   ") + chalk.cyan.bold("\u2502"));
+  console.log(chalk.cyan.bold("  \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F"));
+  console.log("");
+  console.log(chalk.dim("  API key not found. Let's set one up!"));
+  console.log("");
+  console.log(chalk.bold("  Which AI provider would you like to use?"));
+  console.log("");
+  console.log(`  ${chalk.cyan("1.")} Google Gemini ${chalk.green("(Free tier available)")}`);
+  console.log(`  ${chalk.cyan("2.")} OpenAI (GPT-4o, etc.)`);
+  console.log(`  ${chalk.cyan("3.")} Anthropic (Claude)`);
+  console.log(`  ${chalk.cyan("4.")} Ollama ${chalk.green("(Free, local)")}`);
+  console.log("");
+  const choice = await rl.question(chalk.cyan("  Choice [1]: "));
+  const providerChoice = choice.trim() || "1";
+  let provider = "openai";
+  let envVarName = "GEMINI_API_KEY";
+  let keyName = "openai";
+  let signupUrl = "";
+  let model = "gemini-2.5-flash";
+  switch (providerChoice) {
+    case "1":
+      provider = "openai";
+      envVarName = "GEMINI_API_KEY";
+      keyName = "openai";
+      signupUrl = "https://aistudio.google.com/apikey";
+      model = "gemini-2.5-flash";
+      break;
+    case "2":
+      provider = "openai";
+      envVarName = "OPENAI_API_KEY";
+      keyName = "openai";
+      signupUrl = "https://platform.openai.com/api-keys";
+      model = "gpt-4o";
+      break;
+    case "3":
+      provider = "anthropic";
+      envVarName = "ANTHROPIC_API_KEY";
+      keyName = "anthropic";
+      signupUrl = "https://console.anthropic.com/settings/keys";
+      model = "claude-sonnet-4-20250514";
+      break;
+    case "4":
+      console.log("");
+      console.log(chalk.green("  \u2713 Ollama selected! No API key needed."));
+      console.log(chalk.dim("  Make sure Ollama is running: ollama serve"));
+      console.log(chalk.dim("  And pull a model: ollama pull llama3.1"));
+      console.log("");
+      console.log(chalk.dim("  Start Codi with:"));
+      console.log(chalk.cyan("    codi --provider ollama --model llama3.1"));
+      console.log("");
+      rl.close();
+      return null;
+    default:
+      console.log(chalk.yellow("  Invalid choice. Using Gemini (default)."));
+      break;
+  }
+  if (signupUrl) {
+    console.log("");
+    console.log(chalk.bold("  Get your API key:"));
+    console.log(chalk.cyan(`  \u2192 ${signupUrl}`));
+    console.log("");
+  }
+  const apiKey = await rl.question(chalk.cyan("  Paste your API key: "));
+  rl.close();
+  if (!apiKey.trim()) {
+    console.log(chalk.yellow("\n  No API key provided. Setup cancelled."));
+    console.log(chalk.dim(`  You can set it later: export ${envVarName}=your-key
+`));
+    return null;
+  }
+  const rl2 = readline.createInterface({ input, output });
+  console.log("");
+  console.log(chalk.bold("  How would you like to save it?"));
+  console.log("");
+  console.log(`  ${chalk.cyan("1.")} Save to ~/.codi/settings.json ${chalk.green("(Recommended)")}`);
+  console.log(`  ${chalk.cyan("2.")} Show export command (manual setup)`);
+  console.log("");
+  const saveChoice = await rl2.question(chalk.cyan("  Choice [1]: "));
+  rl2.close();
+  const trimmedKey = apiKey.trim();
+  if (saveChoice.trim() === "2") {
+    console.log("");
+    console.log(chalk.bold("  Add this to your shell profile (~/.zshrc or ~/.bashrc):"));
+    console.log("");
+    console.log(chalk.cyan(`    export ${envVarName}=${trimmedKey}`));
+    console.log("");
+    console.log(chalk.dim("  Then restart your terminal or run: source ~/.zshrc"));
+    console.log("");
+    return { apiKey: trimmedKey, provider };
+  }
+  try {
+    if (!fs.existsSync(SETTINGS_DIR)) {
+      fs.mkdirSync(SETTINGS_DIR, { recursive: true });
+    }
+    let settings = {};
+    if (fs.existsSync(SETTINGS_PATH)) {
+      try {
+        settings = JSON.parse(fs.readFileSync(SETTINGS_PATH, "utf-8"));
+      } catch {
+        settings = {};
+      }
+    }
+    if (!settings["apiKeys"] || typeof settings["apiKeys"] !== "object") {
+      settings["apiKeys"] = {};
+    }
+    settings["apiKeys"][keyName] = trimmedKey;
+    if (providerChoice === "2") {
+      settings["provider"] = "openai";
+      settings["model"] = model;
+      settings["baseUrls"] = {};
+    } else if (providerChoice === "3") {
+      settings["provider"] = "anthropic";
+      settings["model"] = model;
+    }
+    fs.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf-8");
+    console.log("");
+    console.log(chalk.green("  \u2713 Settings saved to ~/.codi/settings.json"));
+    console.log(chalk.dim(`  Provider: ${provider} | Model: ${model}`));
+    console.log("");
+  } catch (err) {
+    console.log(chalk.red(`
+  Failed to save settings: ${err}`));
+    console.log(chalk.dim(`  Set manually: export ${envVarName}=${trimmedKey}
+`));
+  }
+  return { apiKey: trimmedKey, provider };
+}
+
+// src/config/config.ts
+init_esm_shims();
+import * as fs2 from "fs";
+import * as path3 from "path";
+var DEFAULT_CONFIG = {
+  provider: "openai",
+  model: "gemini-2.5-flash",
+  maxTokens: 8192,
+  apiKeys: {},
+  baseUrls: {
+    openai: "https://generativelanguage.googleapis.com/v1beta/openai"
+  },
+  permissions: {
+    allow: ["read_file", "glob", "grep", "list_dir", "ask_user"],
+    deny: [],
+    ask: ["write_file", "edit_file", "multi_edit", "bash", "git", "web_fetch", "web_search", "notebook_edit"]
+  },
+  hooks: {},
+  mcpServers: {},
+  customCommands: [],
+  sandbox: false,
+  autoCompactThreshold: 0.7,
+  memoryEnabled: true
+};
+var ConfigManager = class {
+  config;
+  configPaths = [];
+  constructor() {
+    this.config = { ...DEFAULT_CONFIG };
+    this.loadAll();
+  }
+  loadAll() {
+    const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+    this.loadFile(path3.join(home, ".codi", "settings.json"));
+    this.loadFile(path3.join(process.cwd(), ".codi", "settings.json"));
+    this.loadFile(path3.join(process.cwd(), ".codi", "settings.local.json"));
+    if (process.env["GEMINI_API_KEY"]) {
+      this.config.apiKeys.openai = process.env["GEMINI_API_KEY"];
+    }
+    if (process.env["ANTHROPIC_API_KEY"]) {
+      this.config.apiKeys.anthropic = process.env["ANTHROPIC_API_KEY"];
+    }
+    if (process.env["OPENAI_API_KEY"]) {
+      this.config.apiKeys.openai = process.env["OPENAI_API_KEY"];
+    }
+    if (process.env["CODI_MODEL"]) {
+      this.config.model = process.env["CODI_MODEL"];
+    }
+    if (process.env["CODI_PROVIDER"]) {
+      this.config.provider = process.env["CODI_PROVIDER"];
+    }
+  }
+  loadFile(filePath) {
+    try {
+      if (!fs2.existsSync(filePath)) return;
+      const content = fs2.readFileSync(filePath, "utf-8");
+      const parsed = JSON.parse(content);
+      this.configPaths.push(filePath);
+      this.mergeConfig(parsed);
+    } catch {
+    }
+  }
+  mergeConfig(partial) {
+    for (const [key, value] of Object.entries(partial)) {
+      if (key === "permissions" && typeof value === "object" && value !== null) {
+        const perms = value;
+        if (Array.isArray(perms["allow"])) {
+          this.config.permissions.allow = [
+            .../* @__PURE__ */ new Set([...this.config.permissions.allow, ...perms["allow"]])
+          ];
+        }
+        if (Array.isArray(perms["deny"])) {
+          this.config.permissions.deny = [
+            .../* @__PURE__ */ new Set([...this.config.permissions.deny, ...perms["deny"]])
+          ];
+        }
+        if (Array.isArray(perms["ask"])) {
+          this.config.permissions.ask = [
+            .../* @__PURE__ */ new Set([...this.config.permissions.ask, ...perms["ask"]])
+          ];
+        }
+      } else if (key === "hooks" && typeof value === "object" && value !== null) {
+        Object.assign(this.config.hooks, value);
+      } else if (key === "mcpServers" && typeof value === "object" && value !== null) {
+        Object.assign(this.config.mcpServers, value);
+      } else if (key === "apiKeys" && typeof value === "object" && value !== null) {
+        Object.assign(this.config.apiKeys, value);
+      } else if (key === "baseUrls" && typeof value === "object" && value !== null) {
+        Object.assign(this.config.baseUrls, value);
+      } else if (key in this.config) {
+        this.config[key] = value;
+      }
+    }
+  }
+  get() {
+    return this.config;
+  }
+  reload() {
+    this.config = { ...DEFAULT_CONFIG };
+    this.configPaths = [];
+    this.loadAll();
+  }
+  set(key, value) {
+    this.config[key] = value;
+  }
+  getConfigPaths() {
+    return this.configPaths;
+  }
+  save(scope) {
+    const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+    let filePath;
+    switch (scope) {
+      case "user":
+        filePath = path3.join(home, ".codi", "settings.json");
+        break;
+      case "project":
+        filePath = path3.join(process.cwd(), ".codi", "settings.json");
+        break;
+      case "local":
+        filePath = path3.join(process.cwd(), ".codi", "settings.local.json");
+        break;
+    }
+    const dir = path3.dirname(filePath);
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+    fs2.writeFileSync(filePath, JSON.stringify(this.config, null, 2), "utf-8");
+  }
+};
+var configManager = new ConfigManager();
+
+// src/repl.ts
+init_esm_shims();
+import * as readline2 from "readline/promises";
+import { stdin as input2, stdout as output2 } from "process";
+import chalk4 from "chalk";
+import { execSync } from "child_process";
+import { edit } from "external-editor";
+
+// src/ui/keybindings.ts
+init_esm_shims();
+var KeyBindingManager = class {
+  bindings = /* @__PURE__ */ new Map();
+  register(binding) {
+    const id = this.makeId(binding);
+    this.bindings.set(id, binding);
+  }
+  makeId(binding) {
+    const parts = [];
+    if (binding.ctrl) parts.push("ctrl");
+    if (binding.meta) parts.push("meta");
+    if (binding.shift) parts.push("shift");
+    parts.push(binding.key);
+    return parts.join("+");
+  }
+  async handle(str, key) {
+    const id = this.makeId({
+      key: key.name ?? str,
+      ctrl: key.ctrl,
+      meta: key.meta,
+      shift: key.shift
+    });
+    const binding = this.bindings.get(id);
+    if (binding) {
+      await binding.handler();
+      return true;
+    }
+    return false;
+  }
+  listBindings() {
+    return [...this.bindings.values()];
+  }
+};
+
+// src/repl.ts
+init_renderer();
+
+// src/ui/status-line.ts
+init_esm_shims();
+import chalk3 from "chalk";
+var StatusLine = class {
+  info = {
+    model: "",
+    provider: "",
+    inputTokens: 0,
+    outputTokens: 0,
+    cost: 0
+  };
+  enabled = true;
+  update(partial) {
+    Object.assign(this.info, partial);
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  render() {
+    if (!this.enabled) return "";
+    const { model, inputTokens, outputTokens, cost, mode } = this.info;
+    const parts = [];
+    if (model) parts.push(chalk3.cyan(`[${model}]`));
+    if (mode === "plan") parts.push(chalk3.yellow("[PLAN]"));
+    parts.push(chalk3.dim(`in:${this.formatTokens(inputTokens)}`));
+    parts.push(chalk3.dim(`out:${this.formatTokens(outputTokens)}`));
+    if (cost > 0) parts.push(chalk3.green(`$${cost.toFixed(4)}`));
+    return parts.join(chalk3.dim(" | "));
+  }
+  formatTokens(n) {
+    if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+    if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+    return String(n);
+  }
+  getInfo() {
+    return { ...this.info };
+  }
+};
+var statusLine = new StatusLine();
+
+// src/ui/completer.ts
+init_esm_shims();
+import * as fs3 from "fs";
+import * as path4 from "path";
+var SLASH_COMMANDS = [
+  "/help",
+  "/quit",
+  "/exit",
+  "/clear",
+  "/reset",
+  "/new",
+  "/model",
+  "/compact",
+  "/cost",
+  "/config",
+  "/permissions",
+  "/diff",
+  "/save",
+  "/resume",
+  "/continue",
+  "/fork",
+  "/plan",
+  "/memory",
+  "/init",
+  "/export",
+  "/tasks",
+  "/status",
+  "/context",
+  "/rewind",
+  "/mcp"
+];
+function completer(line) {
+  if (line.startsWith("/")) {
+    const matches = SLASH_COMMANDS.filter((cmd) => cmd.startsWith(line));
+    return [matches, line];
+  }
+  if (line.includes("@")) {
+    const atIndex = line.lastIndexOf("@");
+    const partial = line.slice(atIndex + 1);
+    const dir = path4.dirname(partial) || ".";
+    const base = path4.basename(partial);
+    try {
+      const entries = fs3.readdirSync(dir === "" ? "." : dir);
+      const matches = entries.filter((e) => e.startsWith(base)).map((e) => {
+        const full = dir === "." ? e : path4.join(dir, e);
+        try {
+          return fs3.statSync(full).isDirectory() ? full + "/" : full;
+        } catch {
+          return full;
+        }
+      }).map((p) => line.slice(0, atIndex + 1) + p);
+      return [matches, line];
+    } catch {
+      return [[], line];
+    }
+  }
+  return [[], line];
+}
+
+// src/repl.ts
+var Repl = class {
+  rl = null;
+  keyBindings = new KeyBindingManager();
+  running = false;
+  multilineBuffer = [];
+  inMultiline = false;
+  pasteMode = false;
+  options;
+  lastInterruptTime = 0;
+  constructor(options) {
+    this.options = options;
+    this.setupKeyBindings();
+  }
+  setupKeyBindings() {
+    this.keyBindings.register({
+      key: "l",
+      ctrl: true,
+      handler: () => {
+        process.stdout.write("\x1B[2J\x1B[0f");
+      },
+      description: "Clear screen"
+    });
+  }
+  async start() {
+    this.running = true;
+    this.rl = readline2.createInterface({
+      input: input2,
+      output: output2,
+      prompt: renderPrompt(),
+      completer: (line) => completer(line),
+      terminal: true
+    });
+    if (process.stdin.isTTY) {
+      process.stdout.write("\x1B[?2004h");
+    }
+    this.printWelcome();
+    while (this.running) {
+      try {
+        const statusStr = statusLine.render();
+        if (statusStr) {
+          output2.write(chalk4.dim(statusStr) + "\n");
+        }
+        this.rl.setPrompt(renderPrompt());
+        this.rl.prompt();
+        const line = await new Promise((resolve10, reject) => {
+          const onLine = (data) => {
+            cleanup();
+            resolve10(data);
+          };
+          const onClose = () => {
+            cleanup();
+            reject(new Error("closed"));
+          };
+          const onSigint = () => {
+            cleanup();
+            const now = Date.now();
+            if (now - this.lastInterruptTime < 2e3) {
+              this.gracefulExit().catch(() => process.exit(1));
+              return;
+            }
+            this.lastInterruptTime = now;
+            this.options.onInterrupt();
+            console.log(chalk4.dim("\n(Press Ctrl+C again to exit)"));
+            resolve10("");
+          };
+          const cleanup = () => {
+            this.rl.removeListener("line", onLine);
+            this.rl.removeListener("close", onClose);
+            this.rl.removeListener("SIGINT", onSigint);
+          };
+          this.rl.on("line", onLine);
+          this.rl.on("close", onClose);
+          this.rl.on("SIGINT", onSigint);
+        });
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        if (trimmed.endsWith("\\")) {
+          this.multilineBuffer.push(trimmed.slice(0, -1));
+          this.inMultiline = true;
+          this.rl.setPrompt(chalk4.dim("... "));
+          continue;
+        }
+        let fullInput;
+        if (this.inMultiline) {
+          this.multilineBuffer.push(trimmed);
+          fullInput = this.multilineBuffer.join("\n");
+          this.multilineBuffer = [];
+          this.inMultiline = false;
+        } else {
+          fullInput = trimmed;
+        }
+        await this.processInput(fullInput);
+      } catch (err) {
+        if (err instanceof Error && err.message === "closed") {
+          await this.gracefulExit();
+          return;
+        }
+      }
+    }
+    if (process.stdin.isTTY) {
+      process.stdout.write("\x1B[?2004l");
+    }
+  }
+  async processInput(input3) {
+    const lower = input3.toLowerCase();
+    if (lower === "exit" || lower === "quit" || lower === "q") {
+      await this.gracefulExit();
+      return;
+    }
+    if (input3.startsWith("/")) {
+      const spaceIdx = input3.indexOf(" ");
+      const command = spaceIdx === -1 ? input3 : input3.slice(0, spaceIdx);
+      const args = spaceIdx === -1 ? "" : input3.slice(spaceIdx + 1).trim();
+      const handled = await this.options.onSlashCommand(command, args);
+      if (handled) return;
+      console.log(renderError(`Unknown command: ${command}. Type /help for available commands.`));
+      return;
+    }
+    if (input3.startsWith("!")) {
+      const cmd = input3.slice(1).trim();
+      if (!cmd) return;
+      try {
+        const result = execSync(cmd, {
+          encoding: "utf-8",
+          stdio: ["inherit", "pipe", "pipe"],
+          timeout: 3e4
+        });
+        console.log(result);
+      } catch (err) {
+        if (err.stderr) console.error(chalk4.red(err.stderr));
+        else if (err.stdout) console.log(err.stdout);
+        else console.error(renderError(String(err.message)));
+      }
+      return;
+    }
+    let message = input3;
+    const atMatches = input3.match(/@([\w./-]+)/g);
+    if (atMatches) {
+      for (const match of atMatches) {
+        const filePath = match.slice(1);
+        try {
+          const { readFileSync: readFileSync12 } = await import("fs");
+          const content = readFileSync12(filePath, "utf-8");
+          message = message.replace(match, `
+[File: ${filePath}]
+\`\`\`
+${content}
+\`\`\`
+`);
+        } catch {
+        }
+      }
+    }
+    await this.options.onMessage(message);
+  }
+  openEditor() {
+    try {
+      const text = edit("", { postfix: ".md" });
+      return text.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+  stop() {
+    this.running = false;
+    if (this.rl) {
+      this.rl.close();
+      this.rl = null;
+    }
+  }
+  async gracefulExit() {
+    this.stop();
+    if (this.options.onExit) {
+      await this.options.onExit();
+    }
+    console.log(chalk4.dim("\nGoodbye!\n"));
+    process.exit(0);
+  }
+  printWelcome() {
+    console.log("");
+    console.log(chalk4.cyan.bold("  \u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E"));
+    console.log(chalk4.cyan.bold("  \u2502") + chalk4.white.bold("    Codi (\uCF54\uB514) v0.1.0       ") + chalk4.cyan.bold("\u2502"));
+    console.log(chalk4.cyan.bold("  \u2502") + chalk4.dim("   AI Code Agent for Terminal ") + chalk4.cyan.bold("\u2502"));
+    console.log(chalk4.cyan.bold("  \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F"));
+    console.log("");
+    console.log(chalk4.dim("  Type /help for commands, Ctrl+D to quit"));
+    console.log(chalk4.dim("  Use \\ at end of line for multiline input"));
+    console.log("");
+  }
+};
+
+// src/agent/agent-loop.ts
+init_esm_shims();
+
+// src/agent/conversation.ts
+init_esm_shims();
+var Conversation = class _Conversation {
+  messages = [];
+  systemPrompt = "";
+  setSystemPrompt(prompt) {
+    this.systemPrompt = prompt;
+  }
+  getSystemPrompt() {
+    return this.systemPrompt;
+  }
+  addUserMessage(content) {
+    this.messages.push({ role: "user", content });
+  }
+  addAssistantMessage(content) {
+    this.messages.push({ role: "assistant", content });
+  }
+  addToolResults(results) {
+    const blocks = results.map((r) => ({
+      type: "tool_result",
+      tool_use_id: r.tool_use_id,
+      content: r.content,
+      is_error: r.is_error
+    }));
+    this.messages.push({ role: "user", content: blocks });
+  }
+  getMessages() {
+    return [...this.messages];
+  }
+  getLastMessage() {
+    return this.messages[this.messages.length - 1];
+  }
+  getMessageCount() {
+    return this.messages.length;
+  }
+  clear() {
+    this.messages = [];
+  }
+  /**
+   * Replace old messages with a summary, keeping recent messages intact.
+   */
+  compact(summary, keepRecent = 4) {
+    if (this.messages.length <= keepRecent) return;
+    const recent = this.messages.slice(-keepRecent);
+    this.messages = [
+      { role: "user", content: `[Previous conversation summary]
+${summary}` },
+      { role: "assistant", content: "Understood. I have the context from our previous conversation." },
+      ...recent
+    ];
+  }
+  /**
+   * Fork the conversation at the current point.
+   */
+  fork() {
+    const forked = new _Conversation();
+    forked.systemPrompt = this.systemPrompt;
+    forked.messages = [...this.messages.map((m) => ({ ...m }))];
+    return forked;
+  }
+  /**
+   * Truncate to a specific number of messages from the end.
+   */
+  truncateTo(count) {
+    if (this.messages.length > count) {
+      this.messages = this.messages.slice(-count);
+    }
+  }
+  /**
+   * Serialize for session saving.
+   */
+  serialize() {
+    return {
+      systemPrompt: this.systemPrompt,
+      messages: this.messages
+    };
+  }
+  /**
+   * Restore from serialized data.
+   */
+  static deserialize(data) {
+    const conv = new _Conversation();
+    conv.systemPrompt = data.systemPrompt;
+    conv.messages = data.messages;
+    return conv;
+  }
+  /**
+   * Estimate rough token count (very approximate).
+   */
+  estimateTokens() {
+    let chars = this.systemPrompt.length;
+    for (const msg of this.messages) {
+      if (typeof msg.content === "string") {
+        chars += msg.content.length;
+      } else {
+        for (const block of msg.content) {
+          if (block.type === "text") chars += block.text.length;
+          else if (block.type === "tool_use") chars += JSON.stringify(block.input).length;
+          else if (block.type === "tool_result") {
+            chars += typeof block.content === "string" ? block.content.length : JSON.stringify(block.content).length;
+          }
+        }
+      }
+    }
+    return Math.ceil(chars / 4);
+  }
+};
+
+// src/tools/executor.ts
+init_esm_shims();
+init_tool();
+init_renderer();
+import chalk5 from "chalk";
+var ToolExecutor = class {
+  constructor(registry, options = {}) {
+    this.registry = registry;
+    this.options = options;
+  }
+  async executeOne(toolCall) {
+    const tool = this.registry.get(toolCall.name);
+    if (!tool) {
+      return {
+        toolUseId: toolCall.id,
+        toolName: toolCall.name,
+        result: makeToolError(`Unknown tool: ${toolCall.name}. Available tools: ${this.registry.listNames().join(", ")}`)
+      };
+    }
+    if (this.options.planMode && !tool.readOnly) {
+      return {
+        toolUseId: toolCall.id,
+        toolName: toolCall.name,
+        result: makeToolError(`Tool '${toolCall.name}' is not available in plan mode (read-only). Use only read-only tools.`)
+      };
+    }
+    if (tool.dangerous && this.options.permissionCheck) {
+      const allowed = await this.options.permissionCheck(tool, toolCall.input);
+      if (!allowed) {
+        return {
+          toolUseId: toolCall.id,
+          toolName: toolCall.name,
+          result: makeToolError(`Permission denied for tool: ${toolCall.name}`)
+        };
+      }
+    }
+    let input3 = toolCall.input;
+    if (this.options.preHook) {
+      try {
+        const hookResult = await this.options.preHook(toolCall.name, input3);
+        if (!hookResult.proceed) {
+          return {
+            toolUseId: toolCall.id,
+            toolName: toolCall.name,
+            result: makeToolError(`Tool execution blocked by hook for: ${toolCall.name}`)
+          };
+        }
+        if (hookResult.updatedInput) {
+          input3 = hookResult.updatedInput;
+        }
+      } catch (err) {
+        console.error(chalk5.yellow(`Hook error for ${toolCall.name}: ${err}`));
+      }
+    }
+    if (this.options.showToolCalls) {
+      console.log(renderToolCall(toolCall.name, input3));
+    }
+    let result;
+    try {
+      result = await tool.execute(input3);
+    } catch (err) {
+      result = makeToolError(
+        `Tool '${toolCall.name}' threw an error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    if (this.options.showToolCalls) {
+      console.log(renderToolResult(toolCall.name, result.output, !result.success));
+    }
+    if (this.options.postHook) {
+      try {
+        await this.options.postHook(toolCall.name, input3, result);
+      } catch {
+      }
+    }
+    return {
+      toolUseId: toolCall.id,
+      toolName: toolCall.name,
+      result
+    };
+  }
+  async executeMany(toolCalls) {
+    const safeCalls = [];
+    const dangerousCalls = [];
+    for (const tc of toolCalls) {
+      const tool = this.registry.get(tc.name);
+      if (tool?.dangerous) {
+        dangerousCalls.push(tc);
+      } else {
+        safeCalls.push(tc);
+      }
+    }
+    const safePromises = safeCalls.map((tc) => this.executeOne(tc));
+    const dangerousResults = [];
+    for (const tc of dangerousCalls) {
+      const result = await this.executeOne(tc);
+      dangerousResults.push(result);
+    }
+    const safeResults = await Promise.allSettled(safePromises);
+    const results = [];
+    for (let i = 0; i < safeResults.length; i++) {
+      const r = safeResults[i];
+      if (r.status === "fulfilled") {
+        results.push(r.value);
+      } else {
+        results.push({
+          toolUseId: safeCalls[i].id,
+          toolName: safeCalls[i].name,
+          result: makeToolError(`Tool execution failed: ${r.reason}`)
+        });
+      }
+    }
+    results.push(...dangerousResults);
+    const orderMap = new Map(toolCalls.map((tc, i) => [tc.id, i]));
+    results.sort((a, b) => (orderMap.get(a.toolUseId) ?? 0) - (orderMap.get(b.toolUseId) ?? 0));
+    return results;
+  }
+  setOptions(options) {
+    Object.assign(this.options, options);
+  }
+};
+
+// src/agent/token-tracker.ts
+init_esm_shims();
+
+// src/llm/types.ts
+init_esm_shims();
+var MODEL_COSTS = {
+  "claude-sonnet-4-20250514": { input: 3e-3, output: 0.015 },
+  "claude-opus-4-20250514": { input: 0.015, output: 0.075 },
+  "claude-haiku-3-5-20241022": { input: 8e-4, output: 4e-3 },
+  "gpt-4o": { input: 25e-4, output: 0.01 },
+  "gpt-4o-mini": { input: 15e-5, output: 6e-4 },
+  "gpt-4.1": { input: 2e-3, output: 8e-3 },
+  "gpt-4.1-mini": { input: 4e-4, output: 16e-4 },
+  "gpt-4.1-nano": { input: 1e-4, output: 4e-4 }
+};
+function getModelCost(model) {
+  return MODEL_COSTS[model] ?? { input: 0, output: 0 };
+}
+
+// src/agent/token-tracker.ts
+var TokenTracker = class {
+  inputTokens = 0;
+  outputTokens = 0;
+  requests = 0;
+  model = "";
+  setModel(model) {
+    this.model = model;
+  }
+  track(usage) {
+    this.inputTokens += usage.input_tokens;
+    this.outputTokens += usage.output_tokens;
+    this.requests++;
+  }
+  getStats() {
+    const costs = getModelCost(this.model);
+    const cost = this.inputTokens / 1e3 * costs.input + this.outputTokens / 1e3 * costs.output;
+    return {
+      inputTokens: this.inputTokens,
+      outputTokens: this.outputTokens,
+      totalTokens: this.inputTokens + this.outputTokens,
+      cost,
+      requests: this.requests
+    };
+  }
+  getCost() {
+    return this.getStats().cost;
+  }
+  reset() {
+    this.inputTokens = 0;
+    this.outputTokens = 0;
+    this.requests = 0;
+  }
+  format() {
+    const stats = this.getStats();
+    const parts = [
+      `Requests: ${stats.requests}`,
+      `Input: ${this.formatTokens(stats.inputTokens)}`,
+      `Output: ${this.formatTokens(stats.outputTokens)}`,
+      `Total: ${this.formatTokens(stats.totalTokens)}`
+    ];
+    if (stats.cost > 0) {
+      parts.push(`Cost: $${stats.cost.toFixed(4)}`);
+    }
+    return parts.join(" | ");
+  }
+  formatTokens(n) {
+    if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+    if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+    return String(n);
+  }
+};
+var tokenTracker = new TokenTracker();
+
+// src/ui/spinner.ts
+init_esm_shims();
+import ora from "ora";
+import chalk6 from "chalk";
+var currentSpinner = null;
+function startSpinner(text) {
+  stopSpinner();
+  currentSpinner = ora({
+    text: chalk6.dim(text),
+    spinner: "dots",
+    color: "cyan"
+  }).start();
+  return currentSpinner;
+}
+function updateSpinner(text) {
+  if (currentSpinner) {
+    currentSpinner.text = chalk6.dim(text);
+  }
+}
+function stopSpinner(symbol) {
+  if (currentSpinner) {
+    if (symbol) {
+      currentSpinner.stopAndPersist({ symbol });
+    } else {
+      currentSpinner.stop();
+    }
+    currentSpinner = null;
+  }
+}
+
+// src/agent/agent-loop.ts
+init_renderer();
+import chalk7 from "chalk";
+var MAX_RETRIES = 3;
+var RETRY_DELAYS = [1e3, 2e3, 4e3];
+async function agentLoop(userMessage, options) {
+  const {
+    provider,
+    registry,
+    maxIterations = 25,
+    stream = true,
+    showOutput = true
+  } = options;
+  const conversation = options.conversation ?? new Conversation();
+  if (options.systemPrompt) {
+    conversation.setSystemPrompt(options.systemPrompt);
+  }
+  const executor = new ToolExecutor(registry, {
+    permissionCheck: options.permissionCheck,
+    preHook: options.preHook,
+    postHook: options.postHook,
+    planMode: options.planMode,
+    showToolCalls: showOutput
+  });
+  conversation.addUserMessage(userMessage);
+  let iterations = 0;
+  let finalText = "";
+  while (iterations < maxIterations) {
+    iterations++;
+    let response;
+    const spinner = showOutput ? startSpinner("Thinking...") : null;
+    try {
+      response = await callLlmWithRetry(provider, conversation, registry, stream, options, showOutput);
+    } catch (err) {
+      stopSpinner();
+      const errMsg = err instanceof Error ? err.message : String(err);
+      if (showOutput) {
+        console.error(chalk7.red(`
+LLM Error: ${errMsg}`));
+      }
+      return `Error communicating with LLM: ${errMsg}`;
+    }
+    stopSpinner();
+    if (response.usage) {
+      tokenTracker.track(response.usage);
+      const stats = tokenTracker.getStats();
+      statusLine.update({
+        inputTokens: stats.inputTokens,
+        outputTokens: stats.outputTokens,
+        cost: stats.cost
+      });
+    }
+    conversation.addAssistantMessage(response.content);
+    const wasStreamed = response._streamed === true;
+    if (response.text) {
+      finalText = response.text;
+    }
+    if (response.stopReason === "end_turn" || !response.toolCalls || response.toolCalls.length === 0) {
+      if (showOutput && finalText && !wasStreamed) {
+        console.log("");
+        console.log(renderAssistantPrefix());
+        console.log(renderMarkdown(finalText));
+        console.log("");
+      }
+      if (wasStreamed && showOutput) {
+        console.log("");
+      }
+      break;
+    }
+    if (response.stopReason === "max_tokens") {
+      if (showOutput) {
+        console.log(chalk7.yellow("\n\u26A0 Response truncated (max tokens reached)"));
+      }
+    }
+    if (response.toolCalls && response.toolCalls.length > 0) {
+      if (showOutput) {
+        console.log("");
+      }
+      const results = await executor.executeMany(response.toolCalls);
+      const toolResults = results.map((r) => ({
+        tool_use_id: r.toolUseId,
+        content: r.result.output,
+        is_error: !r.result.success
+      }));
+      conversation.addToolResults(toolResults);
+    }
+  }
+  if (iterations >= maxIterations) {
+    if (showOutput) {
+      console.log(chalk7.yellow(`
+\u26A0 Agent loop reached maximum iterations (${maxIterations})`));
+    }
+  }
+  return finalText;
+}
+async function callLlmWithRetry(provider, conversation, registry, stream, options, showOutput) {
+  let lastError = null;
+  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+    try {
+      let streamedText = "";
+      const response = await provider.chat({
+        messages: conversation.getMessages(),
+        systemPrompt: conversation.getSystemPrompt(),
+        tools: registry.getToolDefinitions(options.planMode ? { readOnly: true } : void 0),
+        stream,
+        callbacks: stream ? {
+          onToken: (text) => {
+            stopSpinner();
+            if (showOutput && !streamedText) {
+              process.stdout.write("\n" + renderAssistantPrefix() + "\n");
+            }
+            streamedText += text;
+            if (showOutput) {
+              process.stdout.write(text);
+            }
+            options.onToken?.(text);
+          }
+        } : void 0
+      });
+      if (streamedText) {
+        if (showOutput) {
+          process.stdout.write("\n");
+        }
+        return { ...response, _streamed: true };
+      }
+      return response;
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      const status = err.status || err.statusCode;
+      if (status === 429 || status >= 500 && status < 600) {
+        const delay = RETRY_DELAYS[attempt] || 4e3;
+        if (showOutput) {
+          updateSpinner(`API error (${status}), retrying in ${delay / 1e3}s...`);
+        }
+        await sleep(delay);
+        continue;
+      }
+      throw lastError;
+    }
+  }
+  throw lastError || new Error("Max retries exceeded");
+}
+function sleep(ms) {
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
+}
+
+// src/agent/system-prompt.ts
+init_esm_shims();
+import * as os from "os";
+import { execSync as execSync2 } from "child_process";
+var ROLE_DEFINITION = `You are Codi (\uCF54\uB514), a terminal-based AI coding agent. You help users with software engineering tasks including writing code, debugging, refactoring, and explaining code. You have access to tools for file manipulation, code search, shell execution, and more.`;
+var TOOL_HIERARCHY = `# Tool Usage Rules
+- Use read_file instead of bash cat/head/tail
+- Use edit_file instead of bash sed/awk
+- Use write_file instead of bash echo/cat heredoc
+- Use glob instead of bash find/ls for file search
+- Use grep instead of bash grep/rg for content search
+- Reserve bash for system commands that have no dedicated tool
+- Use sub_agent for complex multi-step exploration tasks
+- Call multiple tools in parallel when they are independent`;
+var CODE_RULES = `# Code Modification Rules
+- ALWAYS read a file before editing it
+- Prefer edit_file over write_file for existing files
+- Make only the changes that are directly requested
+- Do NOT add unnecessary docstrings, comments, type annotations, or error handling
+- Do NOT over-engineer or add features beyond what was asked
+- Be careful about security vulnerabilities (XSS, SQL injection, command injection)
+- Avoid backwards-compatibility hacks for removed code`;
+var GIT_SAFETY = `# Git Safety
+- NEVER amend existing commits - create new commits
+- NEVER force push
+- NEVER skip hooks (--no-verify)
+- NEVER use interactive mode (-i)
+- NEVER use destructive operations (reset --hard, clean -f, checkout .) without explicit user request
+- Always create new commits rather than amending
+- Stage specific files instead of using 'git add -A'
+- Only commit when explicitly asked`;
+var RESPONSE_STYLE = `# Response Style
+- Keep responses short and concise
+- Reference code with file_path:line_number format
+- Do NOT use emojis unless the user requests them
+- Do NOT create documentation files unless requested
+- Do NOT give time estimates
+- If blocked, try alternative approaches rather than retrying the same thing`;
+var SAFETY_RULES = `# Safety & Caution
+- For irreversible or destructive operations, confirm with the user first
+- Do NOT brute-force solutions - if something fails, try a different approach
+- Be careful with operations that affect shared state (push, PR creation, etc.)
+- Investigate unexpected state before deleting or overwriting
+- Measure twice, cut once`;
+function buildSystemPrompt(context) {
+  const fragments = [];
+  fragments.push(ROLE_DEFINITION);
+  fragments.push(buildEnvironmentInfo(context));
+  fragments.push(TOOL_HIERARCHY);
+  fragments.push(CODE_RULES);
+  fragments.push(GIT_SAFETY);
+  fragments.push(RESPONSE_STYLE);
+  fragments.push(SAFETY_RULES);
+  if (context.planMode) {
+    fragments.push(`# Plan Mode
+You are in PLAN MODE (read-only). You can only use read-only tools (read_file, glob, grep, list_dir, ask_user).
+You CANNOT modify files, run commands, or make any changes.
+Analyze the codebase and create a detailed plan for the user to approve.`);
+  }
+  if (context.codiMd) {
+    fragments.push(`# Project Instructions (CODI.md)
+${context.codiMd}`);
+  }
+  if (context.memory) {
+    fragments.push(`# Auto Memory
+${context.memory}`);
+  }
+  if (context.gitStatus) {
+    fragments.push(`# Current Git Status
+${context.gitStatus}`);
+  }
+  return fragments.join("\n\n---\n\n");
+}
+function buildEnvironmentInfo(context) {
+  const lines = [
+    "# Environment",
+    `- Date: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`,
+    `- OS: ${os.platform()} ${os.release()}`,
+    `- Shell: ${process.env["SHELL"] || "unknown"}`,
+    `- Working Directory: ${context.cwd}`,
+    `- Model: ${context.model}`,
+    `- Provider: ${context.provider}`
+  ];
+  try {
+    execSync2("git rev-parse --is-inside-work-tree", { cwd: context.cwd, stdio: "pipe" });
+    const branch = execSync2("git branch --show-current", { cwd: context.cwd, encoding: "utf-8" }).trim();
+    lines.push(`- Git Branch: ${branch}`);
+    lines.push(`- Is Git Repo: true`);
+  } catch {
+    lines.push(`- Is Git Repo: false`);
+  }
+  return lines.join("\n");
+}
+var EXPLORE_SYSTEM_PROMPT = `You are an Explore agent - a fast, read-only agent specialized for codebase exploration. Your job is to quickly find files, search code, and answer questions about the codebase. You have access to: read_file, glob, grep, list_dir. Be thorough but efficient. Return your findings concisely.`;
+var PLAN_SYSTEM_PROMPT = `You are a Plan agent - a software architect agent for designing implementation plans. Analyze the codebase, identify critical files, consider trade-offs, and return a step-by-step implementation plan. You have access to: read_file, glob, grep, list_dir, web_fetch. Be thorough in your analysis.`;
+var GENERAL_SYSTEM_PROMPT = `You are a General sub-agent handling a specific task autonomously. Complete the task fully and return a concise summary of what you did. You have access to all tools except creating more sub-agents.`;
+
+// src/agent/context-compressor.ts
+init_esm_shims();
+var DEFAULT_OPTIONS = {
+  threshold: 0.7,
+  maxContextTokens: 2e5,
+  keepRecentMessages: 6
+};
+var ContextCompressor = class {
+  options;
+  constructor(options) {
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+  shouldCompress(conversation) {
+    const estimatedTokens = conversation.estimateTokens();
+    return estimatedTokens > this.options.maxContextTokens * this.options.threshold;
+  }
+  async compress(conversation, provider, focusHint) {
+    const messages = conversation.getMessages();
+    if (messages.length <= this.options.keepRecentMessages) return;
+    const toSummarize = messages.slice(0, -this.options.keepRecentMessages);
+    const summaryContent = toSummarize.map((m) => {
+      const role = m.role;
+      const content = typeof m.content === "string" ? m.content : m.content.map((b) => {
+        if (b.type === "text") return b.text;
+        if (b.type === "tool_use") return `[Tool: ${b.name}]`;
+        if (b.type === "tool_result") return `[Result: ${typeof b.content === "string" ? b.content.slice(0, 200) : "..."}]`;
+        return "";
+      }).filter(Boolean).join("\n");
+      return `${role}: ${content}`;
+    }).join("\n\n");
+    const prompt = focusHint ? `Summarize this conversation concisely, focusing on: ${focusHint}
+
+${summaryContent}` : `Summarize this conversation concisely, preserving key decisions, code changes, file paths, and important context:
+
+${summaryContent}`;
+    try {
+      const response = await provider.chat({
+        messages: [{ role: "user", content: prompt }],
+        systemPrompt: "You are a conversation summarizer. Create a concise but complete summary that preserves all important technical details, file paths, decisions made, and context needed to continue the conversation.",
+        maxTokens: 2e3
+      });
+      const summary = response.text || "Previous conversation context.";
+      conversation.compact(summary, this.options.keepRecentMessages);
+    } catch {
+      conversation.truncateTo(this.options.keepRecentMessages + 2);
+    }
+  }
+};
+
+// src/agent/memory.ts
+init_esm_shims();
+import * as fs4 from "fs";
+import * as path5 from "path";
+import * as crypto from "crypto";
+var MemoryManager = class {
+  memoryDir;
+  constructor() {
+    const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+    const projectHash = crypto.createHash("md5").update(process.cwd()).digest("hex").slice(0, 8);
+    const projectName = path5.basename(process.cwd());
+    this.memoryDir = path5.join(home, ".codi", "projects", `${projectName}-${projectHash}`, "memory");
+  }
+  ensureDir() {
+    if (!fs4.existsSync(this.memoryDir)) {
+      fs4.mkdirSync(this.memoryDir, { recursive: true });
+    }
+  }
+  getMemoryDir() {
+    return this.memoryDir;
+  }
+  loadIndex() {
+    const indexPath = path5.join(this.memoryDir, "MEMORY.md");
+    if (!fs4.existsSync(indexPath)) return "";
+    const content = fs4.readFileSync(indexPath, "utf-8");
+    const lines = content.split("\n");
+    return lines.slice(0, 200).join("\n");
+  }
+  saveIndex(content) {
+    this.ensureDir();
+    const indexPath = path5.join(this.memoryDir, "MEMORY.md");
+    fs4.writeFileSync(indexPath, content, "utf-8");
+  }
+  loadTopic(name) {
+    const topicPath = path5.join(this.memoryDir, `${name}.md`);
+    if (!fs4.existsSync(topicPath)) return null;
+    return fs4.readFileSync(topicPath, "utf-8");
+  }
+  saveTopic(name, content) {
+    this.ensureDir();
+    const topicPath = path5.join(this.memoryDir, `${name}.md`);
+    fs4.writeFileSync(topicPath, content, "utf-8");
+  }
+  listTopics() {
+    if (!fs4.existsSync(this.memoryDir)) return [];
+    return fs4.readdirSync(this.memoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md").map((f) => f.replace(".md", ""));
+  }
+  buildMemoryPrompt() {
+    const index = this.loadIndex();
+    if (!index) return "";
+    const lines = [
+      `You have a persistent memory directory at ${this.memoryDir}.`,
+      "Use write_file/edit_file to update memory files as you learn patterns.",
+      "",
+      "Current MEMORY.md:",
+      index
+    ];
+    return lines.join("\n");
+  }
+};
+var memoryManager = new MemoryManager();
+
+// src/agent/session.ts
+init_esm_shims();
+import * as fs5 from "fs";
+import * as path6 from "path";
+import * as crypto2 from "crypto";
+var SessionManager = class {
+  sessionsDir;
+  constructor() {
+    const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+    this.sessionsDir = path6.join(home, ".codi", "sessions");
+  }
+  ensureDir() {
+    if (!fs5.existsSync(this.sessionsDir)) {
+      fs5.mkdirSync(this.sessionsDir, { recursive: true });
+    }
+  }
+  save(conversation, name, model) {
+    this.ensureDir();
+    const id = name || crypto2.randomUUID().slice(0, 8);
+    const filePath = path6.join(this.sessionsDir, `${id}.jsonl`);
+    const data = conversation.serialize();
+    const meta = {
+      id,
+      name,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      messageCount: data.messages.length,
+      cwd: process.cwd(),
+      model: model || "unknown"
+    };
+    const lines = [
+      JSON.stringify({ type: "meta", ...meta }),
+      JSON.stringify({ type: "system", content: data.systemPrompt }),
+      ...data.messages.map((m) => JSON.stringify({ type: "message", ...m }))
+    ];
+    fs5.writeFileSync(filePath, lines.join("\n") + "\n", "utf-8");
+    return id;
+  }
+  load(id) {
+    const filePath = path6.join(this.sessionsDir, `${id}.jsonl`);
+    if (!fs5.existsSync(filePath)) return null;
+    const content = fs5.readFileSync(filePath, "utf-8");
+    const lines = content.trim().split("\n").filter(Boolean);
+    let meta = null;
+    let systemPrompt = "";
+    const messages = [];
+    for (const line of lines) {
+      try {
+        const obj = JSON.parse(line);
+        if (obj.type === "meta") {
+          meta = obj;
+        } else if (obj.type === "system") {
+          systemPrompt = obj.content;
+        } else if (obj.type === "message") {
+          messages.push({ role: obj.role, content: obj.content });
+        }
+      } catch {
+        continue;
+      }
+    }
+    if (!meta) return null;
+    const conversation = Conversation.deserialize({ systemPrompt, messages });
+    return { conversation, meta };
+  }
+  list() {
+    this.ensureDir();
+    const files = fs5.readdirSync(this.sessionsDir).filter((f) => f.endsWith(".jsonl"));
+    const sessions = [];
+    for (const file of files) {
+      const filePath = path6.join(this.sessionsDir, file);
+      try {
+        const firstLine = fs5.readFileSync(filePath, "utf-8").split("\n")[0];
+        if (firstLine) {
+          const meta = JSON.parse(firstLine);
+          if (meta.type === "meta") {
+            sessions.push(meta);
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+    return sessions.sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+  getLatest() {
+    const sessions = this.list();
+    return sessions[0] ?? null;
+  }
+  delete(id) {
+    const filePath = path6.join(this.sessionsDir, `${id}.jsonl`);
+    if (fs5.existsSync(filePath)) {
+      fs5.unlinkSync(filePath);
+      return true;
+    }
+    return false;
+  }
+  cleanup(maxAgeDays = 30) {
+    const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3;
+    const sessions = this.list();
+    let deleted = 0;
+    for (const session of sessions) {
+      if (session.updatedAt < cutoff) {
+        this.delete(session.id);
+        deleted++;
+      }
+    }
+    return deleted;
+  }
+};
+var sessionManager = new SessionManager();
+
+// src/agent/checkpoint.ts
+init_esm_shims();
+import { execSync as execSync3 } from "child_process";
+var CheckpointManager = class {
+  checkpoints = [];
+  nextId = 1;
+  isGitRepo;
+  constructor() {
+    try {
+      execSync3("git rev-parse --is-inside-work-tree", { stdio: "pipe" });
+      this.isGitRepo = true;
+    } catch {
+      this.isGitRepo = false;
+    }
+  }
+  create(conversation, description) {
+    const checkpoint = {
+      id: this.nextId++,
+      timestamp: Date.now(),
+      conversation: conversation.serialize(),
+      description
+    };
+    if (this.isGitRepo) {
+      try {
+        execSync3('git stash push -m "codi-checkpoint" --include-untracked', {
+          stdio: "pipe",
+          encoding: "utf-8"
+        });
+        const ref = execSync3("git stash list --format=%H", {
+          encoding: "utf-8"
+        }).split("\n")[0]?.trim();
+        if (ref) {
+          checkpoint.gitRef = ref;
+        }
+        try {
+          execSync3("git stash pop", { stdio: "pipe" });
+        } catch {
+        }
+      } catch {
+      }
+    }
+    this.checkpoints.push(checkpoint);
+    if (this.checkpoints.length > 20) {
+      this.checkpoints = this.checkpoints.slice(-20);
+    }
+    return checkpoint.id;
+  }
+  rewind(id) {
+    let checkpoint;
+    if (id !== void 0) {
+      checkpoint = this.checkpoints.find((cp) => cp.id === id);
+    } else {
+      checkpoint = this.checkpoints[this.checkpoints.length - 2];
+    }
+    if (!checkpoint) return null;
+    if (checkpoint.gitRef && this.isGitRepo) {
+      try {
+        execSync3(`git checkout ${checkpoint.gitRef} -- .`, { stdio: "pipe" });
+      } catch {
+      }
+    }
+    const idx = this.checkpoints.indexOf(checkpoint);
+    if (idx >= 0) {
+      this.checkpoints = this.checkpoints.slice(0, idx + 1);
+    }
+    return {
+      conversation: Conversation.deserialize(checkpoint.conversation),
+      description: checkpoint.description
+    };
+  }
+  list() {
+    return this.checkpoints.map((cp) => ({
+      id: cp.id,
+      timestamp: cp.timestamp,
+      description: cp.description
+    }));
+  }
+};
+var checkpointManager = new CheckpointManager();
+
+// src/agent/codi-md.ts
+init_esm_shims();
+import * as fs6 from "fs";
+import * as path7 from "path";
+function loadCodiMd() {
+  const fragments = [];
+  let dir = process.cwd();
+  const root = path7.parse(dir).root;
+  while (dir !== root) {
+    loadFromDir(dir, fragments);
+    const parent = path7.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return fragments.join("\n\n---\n\n");
+}
+function loadFromDir(dir, fragments) {
+  const codiPath = path7.join(dir, "CODI.md");
+  if (fs6.existsSync(codiPath)) {
+    try {
+      let content = fs6.readFileSync(codiPath, "utf-8");
+      content = processImports(content, dir);
+      fragments.push(`[CODI.md from ${dir}]
+${content}`);
+    } catch {
+    }
+  }
+  const localPath = path7.join(dir, "CODI.local.md");
+  if (fs6.existsSync(localPath)) {
+    try {
+      const content = fs6.readFileSync(localPath, "utf-8");
+      fragments.push(`[CODI.local.md from ${dir}]
+${content}`);
+    } catch {
+    }
+  }
+  const rulesDir = path7.join(dir, ".codi", "rules");
+  if (fs6.existsSync(rulesDir)) {
+    try {
+      const files = fs6.readdirSync(rulesDir).filter((f) => f.endsWith(".md")).sort();
+      for (const file of files) {
+        const content = fs6.readFileSync(path7.join(rulesDir, file), "utf-8");
+        fragments.push(`[Rule: ${file}]
+${content}`);
+      }
+    } catch {
+    }
+  }
+}
+function processImports(content, baseDir) {
+  return content.replace(/@([\w./-]+)/g, (match, importPath) => {
+    const resolved = path7.resolve(baseDir, importPath);
+    if (fs6.existsSync(resolved)) {
+      try {
+        return fs6.readFileSync(resolved, "utf-8");
+      } catch {
+        return match;
+      }
+    }
+    return match;
+  });
+}
+
+// src/agent/mode-manager.ts
+init_esm_shims();
+var currentMode = "execute";
+function getMode() {
+  return currentMode;
+}
+function setMode(mode) {
+  currentMode = mode;
+}
+
+// src/tools/registry.ts
+init_esm_shims();
+var ToolRegistry = class _ToolRegistry {
+  tools = /* @__PURE__ */ new Map();
+  register(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  registerAll(tools) {
+    for (const tool of tools) {
+      this.register(tool);
+    }
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  has(name) {
+    return this.tools.has(name);
+  }
+  remove(name) {
+    return this.tools.delete(name);
+  }
+  list() {
+    return [...this.tools.values()];
+  }
+  listNames() {
+    return [...this.tools.keys()];
+  }
+  getToolDefinitions(options) {
+    let tools = [...this.tools.values()];
+    if (options?.readOnly) {
+      tools = tools.filter((t) => t.readOnly);
+    }
+    if (options?.names) {
+      const nameSet = new Set(options.names);
+      tools = tools.filter((t) => nameSet.has(t.name));
+    }
+    return tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.inputSchema
+    }));
+  }
+  clone() {
+    const newRegistry = new _ToolRegistry();
+    for (const [, tool] of this.tools) {
+      newRegistry.register(tool);
+    }
+    return newRegistry;
+  }
+  subset(names) {
+    const newRegistry = new _ToolRegistry();
+    for (const name of names) {
+      const tool = this.tools.get(name);
+      if (tool) newRegistry.register(tool);
+    }
+    return newRegistry;
+  }
+};
+
+// src/security/permission-manager.ts
+init_esm_shims();
+import * as readline3 from "readline/promises";
+import chalk8 from "chalk";
+
+// src/config/permissions.ts
+init_esm_shims();
+function parseRule(rule) {
+  const match = rule.match(/^(\w+)(?:\((.+)\))?$/);
+  if (match) {
+    return { tool: match[1], pattern: match[2] };
+  }
+  return { tool: rule };
+}
+function matchesRule(rule, toolName, input3) {
+  if (rule.tool !== toolName) return false;
+  if (!rule.pattern) return true;
+  const pattern = new RegExp(rule.pattern.replace(/\*/g, ".*"));
+  for (const value of Object.values(input3)) {
+    if (typeof value === "string" && pattern.test(value)) {
+      return true;
+    }
+  }
+  return false;
+}
+function evaluatePermission(toolName, input3, rules) {
+  for (const rule of rules.deny) {
+    if (matchesRule(parseRule(rule), toolName, input3)) {
+      return "deny";
+    }
+  }
+  for (const rule of rules.ask) {
+    if (matchesRule(parseRule(rule), toolName, input3)) {
+      return "ask";
+    }
+  }
+  for (const rule of rules.allow) {
+    if (matchesRule(parseRule(rule), toolName, input3)) {
+      return "allow";
+    }
+  }
+  return "ask";
+}
+
+// src/security/permission-manager.ts
+var sessionAllowed = /* @__PURE__ */ new Set();
+var sessionDenied = /* @__PURE__ */ new Set();
+var currentMode2 = "default";
+function setPermissionMode(mode) {
+  currentMode2 = mode;
+}
+async function checkPermission(tool, input3) {
+  if (!tool.dangerous) return true;
+  if (currentMode2 === "yolo") return true;
+  if (currentMode2 === "acceptEdits" && ["write_file", "edit_file", "multi_edit"].includes(tool.name)) {
+    return true;
+  }
+  if (currentMode2 === "plan" && !tool.readOnly) {
+    return false;
+  }
+  const config = configManager.get();
+  const decision = evaluatePermission(tool.name, input3, config.permissions);
+  if (decision === "allow") return true;
+  if (decision === "deny") {
+    console.log(chalk8.red(`\u2717 Permission denied for ${tool.name} (denied by rule)`));
+    return false;
+  }
+  const key = `${tool.name}:${JSON.stringify(input3)}`;
+  if (sessionAllowed.has(tool.name)) return true;
+  if (sessionDenied.has(tool.name)) return false;
+  return promptUser(tool, input3);
+}
+async function promptUser(tool, input3) {
+  console.log("");
+  console.log(chalk8.yellow.bold(`\u26A0 Permission Required: ${tool.name}`));
+  const relevantParams = Object.entries(input3).filter(([, v]) => v !== void 0);
+  for (const [key, value] of relevantParams) {
+    const displayValue = typeof value === "string" && value.length > 200 ? value.slice(0, 200) + "..." : String(value);
+    console.log(chalk8.dim(`  ${key}: `) + displayValue);
+  }
+  console.log("");
+  const rl = readline3.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const answer = await rl.question(
+      chalk8.yellow(`Allow? [${chalk8.bold("Y")}es / ${chalk8.bold("n")}o / ${chalk8.bold("a")}lways for this tool] `)
+    );
+    rl.close();
+    const choice = answer.trim().toLowerCase();
+    if (choice === "a" || choice === "always") {
+      sessionAllowed.add(tool.name);
+      return true;
+    }
+    if (choice === "n" || choice === "no") {
+      return false;
+    }
+    return true;
+  } catch {
+    rl.close();
+    return false;
+  }
+}
+
+// src/hooks/hook-manager.ts
+init_esm_shims();
+import { exec } from "child_process";
+var HookManager = class {
+  async runHooks(event, context) {
+    const config = configManager.get();
+    const hookConfigs = config.hooks[event];
+    if (!hookConfigs || hookConfigs.length === 0) {
+      return { proceed: true };
+    }
+    for (const hookConfig of hookConfigs) {
+      if (context.tool && hookConfig.matcher) {
+        const matcher = new RegExp(hookConfig.matcher);
+        if (!matcher.test(context.tool)) continue;
+      }
+      for (const hook of hookConfig.hooks) {
+        if (hook.type === "command" && hook.command) {
+          const result = await this.runCommandHook(hook.command, context, hook.timeout);
+          if (!result.proceed) return result;
+          if (result.updatedInput) {
+            context.args = result.updatedInput;
+          }
+        }
+      }
+    }
+    return { proceed: true };
+  }
+  async runCommandHook(command, context, timeout) {
+    return new Promise((resolve10) => {
+      const stdinData = JSON.stringify({
+        tool: context["tool"],
+        args: context["args"],
+        session_id: context["sessionId"],
+        cwd: context["cwd"] || process.cwd()
+      });
+      const proc = exec(command, {
+        timeout: timeout || 5e3,
+        cwd: process.cwd(),
+        env: { ...process.env }
+      }, (err, stdout, stderr) => {
+        if (err) {
+          if (err.code === 2) {
+            resolve10({
+              proceed: false,
+              reason: stderr || stdout || "Blocked by hook"
+            });
+            return;
+          }
+          resolve10({ proceed: true });
+          return;
+        }
+        try {
+          const output3 = JSON.parse(stdout);
+          resolve10({
+            proceed: output3.decision !== "block",
+            reason: output3.reason,
+            updatedInput: output3.updatedInput
+          });
+        } catch {
+          resolve10({ proceed: true });
+        }
+      });
+      if (proc.stdin) {
+        proc.stdin.write(stdinData);
+        proc.stdin.end();
+      }
+    });
+  }
+};
+var hookManager = new HookManager();
+
+// src/mcp/mcp-manager.ts
+init_esm_shims();
+init_tool();
+import * as fs7 from "fs";
+import * as path8 from "path";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import chalk9 from "chalk";
+var McpManager = class {
+  servers = /* @__PURE__ */ new Map();
+  async initialize(registry) {
+    const config = configManager.get();
+    const mcpConfigs = this.loadMcpConfigs();
+    const allServers = { ...mcpConfigs, ...config.mcpServers };
+    for (const [name, serverConfig] of Object.entries(allServers)) {
+      try {
+        await this.connectServer(name, serverConfig, registry);
+      } catch (err) {
+        console.error(chalk9.yellow(`  \u26A0 Failed to connect MCP server '${name}': ${err instanceof Error ? err.message : String(err)}`));
+      }
+    }
+  }
+  loadMcpConfigs() {
+    const configs = {};
+    const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+    const paths = [
+      path8.join(home, ".codi", "mcp.json"),
+      path8.join(process.cwd(), ".codi", "mcp.json")
+    ];
+    for (const p of paths) {
+      try {
+        if (fs7.existsSync(p)) {
+          const content = JSON.parse(fs7.readFileSync(p, "utf-8"));
+          if (content.mcpServers) {
+            Object.assign(configs, content.mcpServers);
+          }
+        }
+      } catch {
+      }
+    }
+    return configs;
+  }
+  async connectServer(name, config, registry) {
+    const transport = new StdioClientTransport({
+      command: config.command,
+      args: config.args,
+      env: { ...process.env, ...config.env || {} }
+    });
+    const client = new Client({
+      name: "codi",
+      version: "0.1.0"
+    });
+    await client.connect(transport);
+    const toolsResult = await client.listTools();
+    const toolNames = [];
+    for (const mcpTool of toolsResult.tools) {
+      const toolName = `mcp__${name}__${mcpTool.name}`;
+      toolNames.push(toolName);
+      const tool = {
+        name: toolName,
+        description: `[MCP:${name}] ${mcpTool.description || mcpTool.name}`,
+        inputSchema: mcpTool.inputSchema || { type: "object", properties: {} },
+        dangerous: true,
+        readOnly: false,
+        async execute(input3) {
+          try {
+            const result = await client.callTool({
+              name: mcpTool.name,
+              arguments: input3
+            });
+            const contentArr = Array.isArray(result.content) ? result.content : [];
+            const text = contentArr.map((c) => {
+              if (c.type === "text") return c.text;
+              return JSON.stringify(c);
+            }).join("\n") || "";
+            return makeToolResult(text);
+          } catch (err) {
+            return makeToolError(`MCP tool error: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+      };
+      registry.register(tool);
+    }
+    this.servers.set(name, { name, client, transport, tools: toolNames });
+    console.log(chalk9.dim(`  \u2713 MCP server '${name}' connected (${toolNames.length} tools)`));
+  }
+  async disconnect(name) {
+    const server = this.servers.get(name);
+    if (!server) return;
+    try {
+      await server.transport.close();
+    } catch {
+    }
+    this.servers.delete(name);
+  }
+  async disconnectAll() {
+    for (const [name] of this.servers) {
+      await this.disconnect(name);
+    }
+  }
+  listServers() {
+    return [...this.servers.values()].map((s) => ({
+      name: s.name,
+      tools: s.tools
+    }));
+  }
+  getServerCount() {
+    return this.servers.size;
+  }
+};
+var mcpManager = new McpManager();
+
+// src/agent/sub-agent.ts
+init_esm_shims();
+init_tool();
+import chalk10 from "chalk";
+var AGENT_PRESETS = {
+  explore: {
+    tools: ["read_file", "glob", "grep", "list_dir"],
+    systemPrompt: EXPLORE_SYSTEM_PROMPT,
+    maxIterations: 15
+  },
+  plan: {
+    tools: ["read_file", "glob", "grep", "list_dir", "web_fetch"],
+    systemPrompt: PLAN_SYSTEM_PROMPT,
+    maxIterations: 20
+  },
+  general: {
+    tools: [],
+    // Empty means all tools except sub_agent
+    systemPrompt: GENERAL_SYSTEM_PROMPT,
+    maxIterations: 25
+  }
+};
+var backgroundAgents = /* @__PURE__ */ new Map();
+var bgCounter = 0;
+function createSubAgentHandler(provider, mainRegistry) {
+  return async (input3) => {
+    const type = String(input3["type"]);
+    const task = String(input3["task"]);
+    const background = input3["background"] === true;
+    const preset = AGENT_PRESETS[type];
+    if (!preset) {
+      return makeToolError(`Unknown agent type: ${type}. Use 'explore', 'plan', or 'general'.`);
+    }
+    let registry;
+    if (preset.tools.length > 0) {
+      registry = mainRegistry.subset(preset.tools);
+    } else {
+      registry = mainRegistry.clone();
+      registry.remove("sub_agent");
+    }
+    const conversation = new Conversation();
+    const maxIterations = input3["maxIterations"] || preset.maxIterations;
+    console.log(chalk10.dim(`
+  \u25B8 Launching ${type} agent: ${task.slice(0, 80)}...`));
+    const runAgent = async () => {
+      const result = await agentLoop(task, {
+        provider,
+        conversation,
+        registry,
+        systemPrompt: preset.systemPrompt,
+        maxIterations,
+        stream: false,
+        showOutput: false
+      });
+      return result;
+    };
+    if (background) {
+      const taskId = `agent_${++bgCounter}`;
+      const entry = { promise: runAgent(), status: "running", result: void 0 };
+      backgroundAgents.set(taskId, entry);
+      entry.promise.then((result) => {
+        entry.status = "done";
+        entry.result = result;
+      }).catch((err) => {
+        entry.status = "error";
+        entry.result = String(err);
+      });
+      return makeToolResult(`Background agent started with ID: ${taskId}. Use task output to check results.`);
+    }
+    try {
+      const result = await runAgent();
+      console.log(chalk10.dim(`  \u25B8 ${type} agent completed.`));
+      return makeToolResult(result);
+    } catch (err) {
+      return makeToolError(`Sub-agent failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  };
+}
+
+// src/tools/sub-agent-tool.ts
+init_esm_shims();
+init_tool();
+var subAgentHandler = null;
+function setSubAgentHandler(handler) {
+  subAgentHandler = handler;
+}
+var subAgentTool = {
+  name: "sub_agent",
+  description: `Launch a sub-agent to handle complex tasks autonomously. Types: 'explore' (read-only codebase exploration), 'plan' (architecture planning), 'general' (full capabilities). Sub-agents run in independent contexts.`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      type: {
+        type: "string",
+        enum: ["explore", "plan", "general"],
+        description: "Agent type: explore (fast, read-only), plan (analysis), general (full access)"
+      },
+      task: { type: "string", description: "Detailed task description for the agent" },
+      model: { type: "string", description: "Optional model override" },
+      background: { type: "boolean", description: "Run in background and return task ID" }
+    },
+    required: ["type", "task"]
+  },
+  dangerous: false,
+  readOnly: true,
+  async execute(input3) {
+    if (!subAgentHandler) {
+      return makeToolError("Sub-agent system not initialized. This feature will be available after setup.");
+    }
+    return subAgentHandler(input3);
+  }
+};
+
+// src/config/slash-commands.ts
+init_esm_shims();
+import * as fs8 from "fs";
+import * as path9 from "path";
+import chalk11 from "chalk";
+function createBuiltinCommands() {
+  return [
+    {
+      name: "/help",
+      description: "Show available commands",
+      handler: async () => {
+        const commands = createBuiltinCommands();
+        console.log(chalk11.bold("\nAvailable Commands:\n"));
+        for (const cmd of commands) {
+          const aliases = cmd.aliases ? chalk11.dim(` (${cmd.aliases.join(", ")})`) : "";
+          console.log(`  ${chalk11.cyan(cmd.name)}${aliases} - ${cmd.description}`);
+        }
+        console.log("");
+        console.log(chalk11.dim("  Prefixes: ! (bash), @ (file reference)"));
+        console.log(chalk11.dim("  Use \\ at end of line for multiline input"));
+        console.log("");
+        return true;
+      }
+    },
+    {
+      name: "/quit",
+      aliases: ["/exit"],
+      description: "Exit Codi",
+      handler: async (_args, ctx) => {
+        if (ctx.exitFn) {
+          await ctx.exitFn();
+        }
+        console.log(chalk11.dim("\nGoodbye!\n"));
+        process.exit(0);
+      }
+    },
+    {
+      name: "/clear",
+      aliases: ["/reset", "/new"],
+      description: "Clear conversation history",
+      handler: async (_args, ctx) => {
+        ctx.conversation.clear();
+        ctx.reloadSystemPrompt();
+        console.log(chalk11.green("\u2713 Conversation cleared"));
+        return true;
+      }
+    },
+    {
+      name: "/model",
+      description: "Switch model or provider (e.g., /model gpt-4o, /model ollama:llama3.1)",
+      handler: async (args, ctx) => {
+        if (!args) {
+          const info = statusLine.getInfo();
+          console.log(chalk11.cyan(`Current model: ${info.model} (${info.provider})`));
+          return true;
+        }
+        if (args.includes(":")) {
+          const [provider, model] = args.split(":");
+          ctx.setProvider(provider, model);
+        } else {
+          ctx.setProvider("", args);
+        }
+        console.log(chalk11.green(`\u2713 Model switched to: ${args}`));
+        return true;
+      }
+    },
+    {
+      name: "/compact",
+      description: "Compress conversation history (optional: focus hint)",
+      handler: async (args, ctx) => {
+        console.log(chalk11.dim("Compressing conversation..."));
+        await ctx.compressor.compress(ctx.conversation, ctx.provider, args || void 0);
+        ctx.reloadSystemPrompt();
+        console.log(chalk11.green("\u2713 Conversation compressed"));
+        return true;
+      }
+    },
+    {
+      name: "/cost",
+      description: "Show token usage and cost",
+      handler: async () => {
+        console.log(chalk11.cyan(`
+${tokenTracker.format()}
+`));
+        return true;
+      }
+    },
+    {
+      name: "/config",
+      description: "Show current configuration",
+      handler: async () => {
+        const config = configManager.get();
+        console.log(chalk11.bold("\nConfiguration:\n"));
+        console.log(chalk11.dim(JSON.stringify(config, null, 2)));
+        console.log(chalk11.dim(`
+Config files: ${configManager.getConfigPaths().join(", ") || "(none)"}`));
+        console.log("");
+        return true;
+      }
+    },
+    {
+      name: "/permissions",
+      description: "Show permission rules",
+      handler: async () => {
+        const config = configManager.get();
+        console.log(chalk11.bold("\nPermission Rules:\n"));
+        console.log(chalk11.green("  Allow: ") + config.permissions.allow.join(", "));
+        console.log(chalk11.red("  Deny:  ") + (config.permissions.deny.join(", ") || "(none)"));
+        console.log(chalk11.yellow("  Ask:   ") + config.permissions.ask.join(", "));
+        console.log("");
+        return true;
+      }
+    },
+    {
+      name: "/save",
+      description: "Save current session",
+      handler: async (args, ctx) => {
+        const name = args || void 0;
+        const id = sessionManager.save(ctx.conversation, name, statusLine.getInfo().model);
+        console.log(chalk11.green(`\u2713 Session saved: ${id}`));
+        return true;
+      }
+    },
+    {
+      name: "/resume",
+      aliases: ["/continue"],
+      description: "Resume a saved session",
+      handler: async (args, ctx) => {
+        const id = args || sessionManager.getLatest()?.id;
+        if (!id) {
+          console.log(chalk11.yellow("No sessions found. Use /save to save a session first."));
+          return true;
+        }
+        const session = sessionManager.load(id);
+        if (!session) {
+          console.log(chalk11.red(`Session not found: ${id}`));
+          return true;
+        }
+        const data = session.conversation.serialize();
+        ctx.conversation.clear();
+        ctx.conversation.setSystemPrompt(data.systemPrompt);
+        for (const msg of data.messages) {
+          if (msg.role === "user") ctx.conversation.addUserMessage(msg.content);
+          else if (msg.role === "assistant") ctx.conversation.addAssistantMessage(msg.content);
+        }
+        console.log(chalk11.green(`\u2713 Resumed session: ${id} (${session.meta.messageCount} messages)`));
+        return true;
+      }
+    },
+    {
+      name: "/fork",
+      description: "Fork current conversation into a new session",
+      handler: async (args, ctx) => {
+        const name = args || `fork-${Date.now()}`;
+        const id = sessionManager.save(ctx.conversation, name, statusLine.getInfo().model);
+        console.log(chalk11.green(`\u2713 Conversation forked: ${id}`));
+        return true;
+      }
+    },
+    {
+      name: "/plan",
+      description: "Toggle plan mode (read-only analysis)",
+      handler: async () => {
+        const current = getMode();
+        const newMode = current === "plan" ? "execute" : "plan";
+        setMode(newMode);
+        statusLine.update({ mode: newMode });
+        console.log(chalk11.cyan(`Mode: ${newMode === "plan" ? "PLAN (read-only)" : "EXECUTE"}`));
+        return true;
+      }
+    },
+    {
+      name: "/memory",
+      description: "Show or edit auto memory",
+      handler: async () => {
+        const index = memoryManager.loadIndex();
+        const topics = memoryManager.listTopics();
+        console.log(chalk11.bold("\nAuto Memory:\n"));
+        console.log(chalk11.dim(`Directory: ${memoryManager.getMemoryDir()}`));
+        if (index) {
+          console.log(chalk11.dim("\nMEMORY.md:"));
+          console.log(index);
+        } else {
+          console.log(chalk11.dim("\nNo memory saved yet."));
+        }
+        if (topics.length > 0) {
+          console.log(chalk11.dim(`
+Topics: ${topics.join(", ")}`));
+        }
+        console.log("");
+        return true;
+      }
+    },
+    {
+      name: "/init",
+      description: "Initialize CODI.md in the current project",
+      handler: async () => {
+        const codiPath = path9.join(process.cwd(), "CODI.md");
+        if (fs8.existsSync(codiPath)) {
+          console.log(chalk11.yellow("CODI.md already exists"));
+          return true;
+        }
+        const content = `# Project: ${path9.basename(process.cwd())}
+
+## Overview
+<!-- Describe your project here -->
+
+## Architecture
+<!-- Key architectural decisions -->
+
+## Development
+<!-- Development guidelines, commands, etc. -->
+
+## Conventions
+<!-- Code style, naming conventions, etc. -->
+`;
+        fs8.writeFileSync(codiPath, content, "utf-8");
+        console.log(chalk11.green("\u2713 Created CODI.md"));
+        return true;
+      }
+    },
+    {
+      name: "/export",
+      description: "Export conversation to a file",
+      handler: async (args, ctx) => {
+        const filePath = args || `conversation-${Date.now()}.md`;
+        const messages = ctx.conversation.getMessages();
+        let md = `# Codi Conversation Export
+
+Date: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+---
+
+`;
+        for (const msg of messages) {
+          const role = msg.role === "user" ? "User" : msg.role === "assistant" ? "Codi" : "System";
+          const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content, null, 2);
+          md += `## ${role}
+
+${content}
+
+---
+
+`;
+        }
+        fs8.writeFileSync(filePath, md, "utf-8");
+        console.log(chalk11.green(`\u2713 Exported to ${filePath}`));
+        return true;
+      }
+    },
+    {
+      name: "/tasks",
+      description: "Show task list",
+      handler: async () => {
+        const { taskManager: taskManager2 } = await Promise.resolve().then(() => (init_task_tools(), task_tools_exports));
+        const tasks = taskManager2.list();
+        if (tasks.length === 0) {
+          console.log(chalk11.dim("\nNo tasks.\n"));
+          return true;
+        }
+        console.log(chalk11.bold("\nTasks:\n"));
+        for (const task of tasks) {
+          const statusIcon = task.status === "completed" ? chalk11.green("\u2713") : task.status === "in_progress" ? chalk11.yellow("\u27F3") : chalk11.dim("\u25CB");
+          console.log(`  ${statusIcon} #${task.id} ${task.subject} [${task.status}]`);
+        }
+        console.log("");
+        return true;
+      }
+    },
+    {
+      name: "/status",
+      description: "Show system status",
+      handler: async () => {
+        const config = configManager.get();
+        const info = statusLine.getInfo();
+        const stats = tokenTracker.getStats();
+        const mcpServers = mcpManager.listServers();
+        console.log(chalk11.bold("\nCodi Status:\n"));
+        console.log(`  Version:  0.1.0`);
+        console.log(`  Model:    ${info.model}`);
+        console.log(`  Provider: ${config.provider}`);
+        console.log(`  Mode:     ${getMode()}`);
+        console.log(`  Tokens:   ${tokenTracker.format()}`);
+        console.log(`  MCP:      ${mcpServers.length} server(s)`);
+        for (const s of mcpServers) {
+          console.log(`    - ${s.name} (${s.tools.length} tools)`);
+        }
+        console.log("");
+        return true;
+      }
+    },
+    {
+      name: "/context",
+      description: "Show context window usage",
+      handler: async (_args, ctx) => {
+        const estimated = ctx.conversation.estimateTokens();
+        const max = 2e5;
+        const pct = Math.round(estimated / max * 100);
+        const bar = "\u2588".repeat(Math.round(pct / 5)) + "\u2591".repeat(20 - Math.round(pct / 5));
+        console.log(chalk11.bold("\nContext Window:\n"));
+        console.log(`  ${bar} ${pct}%`);
+        console.log(`  ~${estimated.toLocaleString()} / ${max.toLocaleString()} tokens`);
+        console.log(`  Messages: ${ctx.conversation.getMessageCount()}`);
+        console.log("");
+        return true;
+      }
+    },
+    {
+      name: "/rewind",
+      description: "Rewind to a previous checkpoint",
+      handler: async (_args, ctx) => {
+        const checkpoints = checkpointManager.list();
+        if (checkpoints.length === 0) {
+          console.log(chalk11.yellow("No checkpoints available."));
+          return true;
+        }
+        const result = checkpointManager.rewind();
+        if (!result) {
+          console.log(chalk11.yellow("No checkpoint to rewind to."));
+          return true;
+        }
+        const data = result.conversation.serialize();
+        ctx.conversation.clear();
+        ctx.conversation.setSystemPrompt(data.systemPrompt);
+        for (const msg of data.messages) {
+          if (msg.role === "user") ctx.conversation.addUserMessage(msg.content);
+          else if (msg.role === "assistant") ctx.conversation.addAssistantMessage(msg.content);
+        }
+        console.log(chalk11.green(`\u2713 Rewound to checkpoint${result.description ? `: ${result.description}` : ""}`));
+        return true;
+      }
+    },
+    {
+      name: "/diff",
+      description: "Show git diff of current changes",
+      handler: async () => {
+        try {
+          const { execSync: execSync5 } = await import("child_process");
+          const diff = execSync5("git diff", { encoding: "utf-8", cwd: process.cwd() });
+          if (!diff.trim()) {
+            console.log(chalk11.dim("\nNo changes.\n"));
+          } else {
+            const { renderDiff: renderDiff2 } = await Promise.resolve().then(() => (init_renderer(), renderer_exports));
+            console.log("\n" + renderDiff2("", "", diff) + "\n");
+          }
+        } catch {
+          console.log(chalk11.yellow("Not a git repository or git not available."));
+        }
+        return true;
+      }
+    },
+    {
+      name: "/mcp",
+      description: "Show MCP server status",
+      handler: async () => {
+        const servers = mcpManager.listServers();
+        if (servers.length === 0) {
+          console.log(chalk11.dim("\nNo MCP servers connected.\n"));
+          console.log(chalk11.dim("Add servers in .codi/mcp.json or ~/.codi/mcp.json"));
+          return true;
+        }
+        console.log(chalk11.bold("\nMCP Servers:\n"));
+        for (const s of servers) {
+          console.log(`  ${chalk11.green("\u25CF")} ${s.name}`);
+          for (const t of s.tools) {
+            console.log(chalk11.dim(`    - ${t}`));
+          }
+        }
+        console.log("");
+        return true;
+      }
+    }
+  ];
+}
+function loadCustomCommands() {
+  const commands = [];
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+  const dirs = [
+    path9.join(home, ".codi", "commands"),
+    path9.join(process.cwd(), ".codi", "commands")
+  ];
+  for (const dir of dirs) {
+    if (!fs8.existsSync(dir)) continue;
+    const files = fs8.readdirSync(dir).filter((f) => f.endsWith(".md"));
+    for (const file of files) {
+      const name = "/" + file.replace(".md", "");
+      const filePath = path9.join(dir, file);
+      commands.push({
+        name,
+        description: `Custom command from ${path9.relative(process.cwd(), filePath)}`,
+        handler: async (_args, ctx) => {
+          let content = fs8.readFileSync(filePath, "utf-8");
+          content = content.replace(/\{\{cwd\}\}/g, process.cwd()).replace(/\{\{date\}\}/g, (/* @__PURE__ */ new Date()).toISOString().split("T")[0]).replace(/\{\{file_path\}\}/g, _args || "");
+          await ctx.conversation.addUserMessage(content);
+          return false;
+        }
+      });
+    }
+  }
+  return commands;
+}
+
+// src/tools/file-read.ts
+init_esm_shims();
+init_tool();
+import * as fs9 from "fs";
+import * as path10 from "path";
+var fileReadTool = {
+  name: "read_file",
+  description: `Read a file from the filesystem. Supports text files with line numbers (cat -n format), PDF files, images (returns base64 for multimodal), and Jupyter notebooks (.ipynb). Use offset/limit for large files.`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      file_path: { type: "string", description: "Absolute or relative path to the file" },
+      offset: { type: "number", description: "Line number to start reading from (1-based)" },
+      limit: { type: "number", description: "Number of lines to read" },
+      pages: { type: "string", description: 'Page range for PDF files (e.g., "1-5")' }
+    },
+    required: ["file_path"]
+  },
+  dangerous: false,
+  readOnly: true,
+  async execute(input3) {
+    const filePath = String(input3["file_path"]);
+    const offset = input3["offset"];
+    const limit = input3["limit"];
+    const resolved = path10.resolve(filePath);
+    if (!fs9.existsSync(resolved)) {
+      return makeToolError(`File not found: ${resolved}`);
+    }
+    const stat = fs9.statSync(resolved);
+    if (stat.isDirectory()) {
+      return makeToolError(`Path is a directory, not a file: ${resolved}. Use list_dir instead.`);
+    }
+    const ext = path10.extname(resolved).toLowerCase();
+    if ([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".svg"].includes(ext)) {
+      const data = fs9.readFileSync(resolved);
+      const base64 = data.toString("base64");
+      const mimeMap = {
+        ".png": "image/png",
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".gif": "image/gif",
+        ".webp": "image/webp",
+        ".bmp": "image/bmp",
+        ".svg": "image/svg+xml"
+      };
+      return makeToolResult(`[Image: ${path10.basename(resolved)}]`, {
+        filePath: resolved,
+        isImage: true,
+        imageData: base64,
+        imageMimeType: mimeMap[ext] || "image/png"
+      });
+    }
+    if (ext === ".pdf") {
+      try {
+        const pdfModule = await import("pdf-parse");
+        const pdfParse = pdfModule.default || pdfModule;
+        const buffer = fs9.readFileSync(resolved);
+        const data = await pdfParse(buffer);
+        const pages = input3["pages"];
+        let text = data.text;
+        if (pages) {
+          const allPages = text.split("\f");
+          const [start, end] = pages.split("-").map(Number);
+          const s = (start || 1) - 1;
+          const e = end || start || allPages.length;
+          text = allPages.slice(s, e).join("\n\n--- Page Break ---\n\n");
+        }
+        return makeToolResult(text, { filePath: resolved });
+      } catch (err) {
+        return makeToolError(`Failed to parse PDF: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    if (ext === ".ipynb") {
+      try {
+        const content = fs9.readFileSync(resolved, "utf-8");
+        const nb = JSON.parse(content);
+        const output3 = [];
+        for (let i = 0; i < (nb.cells || []).length; i++) {
+          const cell = nb.cells[i];
+          const cellType = cell.cell_type || "code";
+          const source = Array.isArray(cell.source) ? cell.source.join("") : cell.source || "";
+          output3.push(`--- Cell ${i + 1} [${cellType}] ---`);
+          output3.push(source);
+          if (cell.outputs && cell.outputs.length > 0) {
+            output3.push("--- Output ---");
+            for (const out of cell.outputs) {
+              if (out.text) {
+                output3.push(Array.isArray(out.text) ? out.text.join("") : out.text);
+              } else if (out.data?.["text/plain"]) {
+                const plain = out.data["text/plain"];
+                output3.push(Array.isArray(plain) ? plain.join("") : plain);
+              }
+            }
+          }
+          output3.push("");
+        }
+        return makeToolResult(output3.join("\n"), { filePath: resolved });
+      } catch (err) {
+        return makeToolError(`Failed to parse notebook: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    try {
+      const content = fs9.readFileSync(resolved, "utf-8");
+      const lines = content.split("\n");
+      const totalLines = lines.length;
+      const startLine = Math.max(1, offset || 1);
+      const endLine = limit ? Math.min(startLine + limit - 1, totalLines) : Math.min(startLine + 1999, totalLines);
+      const selectedLines = lines.slice(startLine - 1, endLine);
+      const numbered = selectedLines.map((line, i) => {
+        const lineNum = startLine + i;
+        const numStr = String(lineNum).padStart(String(endLine).length, " ");
+        return `${numStr}	${line}`;
+      });
+      let result = numbered.join("\n");
+      if (endLine < totalLines) {
+        result += `
+
+... (${totalLines - endLine} more lines)`;
+      }
+      return makeToolResult(result, { filePath: resolved });
+    } catch (err) {
+      return makeToolError(`Failed to read file: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+};
+
+// src/tools/file-write.ts
+init_esm_shims();
+init_tool();
+import * as fs10 from "fs";
+import * as path11 from "path";
+var fileWriteTool = {
+  name: "write_file",
+  description: `Create a new file or overwrite an existing file. Creates parent directories if needed. For modifying existing files, prefer edit_file instead.`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      file_path: { type: "string", description: "Absolute or relative path to the file" },
+      content: { type: "string", description: "The content to write to the file" }
+    },
+    required: ["file_path", "content"]
+  },
+  dangerous: true,
+  readOnly: false,
+  async execute(input3) {
+    const filePath = String(input3["file_path"]);
+    const content = String(input3["content"]);
+    const resolved = path11.resolve(filePath);
+    try {
+      const dir = path11.dirname(resolved);
+      if (!fs10.existsSync(dir)) {
+        fs10.mkdirSync(dir, { recursive: true });
+      }
+      const existed = fs10.existsSync(resolved);
+      fs10.writeFileSync(resolved, content, "utf-8");
+      const lines = content.split("\n").length;
+      const action = existed ? "Overwrote" : "Created";
+      return makeToolResult(`${action} ${resolved} (${lines} lines)`, {
+        filePath: resolved,
+        linesChanged: lines
+      });
+    } catch (err) {
+      return makeToolError(`Failed to write file: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+};
+
+// src/tools/file-edit.ts
+init_esm_shims();
+init_tool();
+import * as fs11 from "fs";
+import * as path12 from "path";
+var fileEditTool = {
+  name: "edit_file",
+  description: `Perform exact string replacement in a file. The old_string must be unique in the file unless replace_all is true. Preserves indentation exactly.`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      file_path: { type: "string", description: "Path to the file to edit" },
+      old_string: { type: "string", description: "The exact text to find and replace" },
+      new_string: { type: "string", description: "The replacement text" },
+      replace_all: { type: "boolean", description: "Replace all occurrences (default: false)", default: false }
+    },
+    required: ["file_path", "old_string", "new_string"]
+  },
+  dangerous: true,
+  readOnly: false,
+  async execute(input3) {
+    const filePath = String(input3["file_path"]);
+    const oldString = String(input3["old_string"]);
+    const newString = String(input3["new_string"]);
+    const replaceAll = input3["replace_all"] === true;
+    const resolved = path12.resolve(filePath);
+    if (!fs11.existsSync(resolved)) {
+      return makeToolError(`File not found: ${resolved}`);
+    }
+    try {
+      let content = fs11.readFileSync(resolved, "utf-8");
+      if (oldString === newString) {
+        return makeToolError("old_string and new_string are identical. No changes needed.");
+      }
+      if (!content.includes(oldString)) {
+        const lines = content.split("\n");
+        const oldLines = oldString.split("\n");
+        const firstOldLine = oldLines[0]?.trim();
+        const similar = firstOldLine ? lines.find((l) => l.trim().includes(firstOldLine)) : void 0;
+        let errMsg = `old_string not found in ${resolved}.`;
+        if (similar) {
+          errMsg += `
+Did you mean this line?
+  ${similar.trim()}`;
+        }
+        errMsg += "\nMake sure old_string matches exactly including whitespace and indentation.";
+        return makeToolError(errMsg);
+      }
+      if (!replaceAll) {
+        const count = content.split(oldString).length - 1;
+        if (count > 1) {
+          return makeToolError(
+            `old_string appears ${count} times in the file. Use replace_all: true to replace all, or provide more context to make it unique.`
+          );
+        }
+      }
+      if (replaceAll) {
+        content = content.split(oldString).join(newString);
+      } else {
+        const idx = content.indexOf(oldString);
+        content = content.slice(0, idx) + newString + content.slice(idx + oldString.length);
+      }
+      fs11.writeFileSync(resolved, content, "utf-8");
+      const linesChanged = Math.max(
+        oldString.split("\n").length,
+        newString.split("\n").length
+      );
+      return makeToolResult(`Edited ${resolved}`, {
+        filePath: resolved,
+        linesChanged
+      });
+    } catch (err) {
+      return makeToolError(`Failed to edit file: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+};
+
+// src/tools/file-multi-edit.ts
+init_esm_shims();
+init_tool();
+import * as fs12 from "fs";
+import * as path13 from "path";
+var fileMultiEditTool = {
+  name: "multi_edit",
+  description: `Apply multiple edits to a single file atomically. Each edit is an old_string \u2192 new_string replacement. All edits are validated before any are applied.`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      file_path: { type: "string", description: "Path to the file to edit" },
+      edits: {
+        type: "array",
+        description: "Array of edits to apply",
+        items: {
+          type: "object",
+          properties: {
+            old_string: { type: "string", description: "Text to find" },
+            new_string: { type: "string", description: "Replacement text" }
+          },
+          required: ["old_string", "new_string"]
+        }
+      }
+    },
+    required: ["file_path", "edits"]
+  },
+  dangerous: true,
+  readOnly: false,
+  async execute(input3) {
+    const filePath = String(input3["file_path"]);
+    const edits = input3["edits"];
+    const resolved = path13.resolve(filePath);
+    if (!fs12.existsSync(resolved)) {
+      return makeToolError(`File not found: ${resolved}`);
+    }
+    if (!Array.isArray(edits) || edits.length === 0) {
+      return makeToolError("edits must be a non-empty array of {old_string, new_string} objects");
+    }
+    try {
+      let content = fs12.readFileSync(resolved, "utf-8");
+      for (let i = 0; i < edits.length; i++) {
+        const edit2 = edits[i];
+        if (!content.includes(edit2.old_string)) {
+          return makeToolError(
+            `Edit ${i + 1}/${edits.length}: old_string not found in file. No edits applied.
+Searching for: ${edit2.old_string.slice(0, 100)}...`
+          );
+        }
+      }
+      let totalLinesChanged = 0;
+      for (const edit2 of edits) {
+        const idx = content.indexOf(edit2.old_string);
+        if (idx === -1) {
+          return makeToolError(`Edit validation passed but old_string disappeared during application. This may happen if edits overlap.`);
+        }
+        content = content.slice(0, idx) + edit2.new_string + content.slice(idx + edit2.old_string.length);
+        totalLinesChanged += Math.max(
+          edit2.old_string.split("\n").length,
+          edit2.new_string.split("\n").length
+        );
+      }
+      fs12.writeFileSync(resolved, content, "utf-8");
+      return makeToolResult(`Applied ${edits.length} edits to ${resolved}`, {
+        filePath: resolved,
+        linesChanged: totalLinesChanged
+      });
+    } catch (err) {
+      return makeToolError(`Failed to multi-edit: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+};
+
+// src/tools/glob.ts
+init_esm_shims();
+init_tool();
+import * as fs13 from "fs";
+import * as path14 from "path";
+import { globby } from "globby";
+var globTool = {
+  name: "glob",
+  description: `Fast file pattern matching. Supports glob patterns like "**/*.ts". Respects .gitignore. Returns matching file paths sorted by modification time.`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      pattern: { type: "string", description: 'Glob pattern to match files (e.g., "**/*.ts", "src/**/*.tsx")' },
+      path: { type: "string", description: "Directory to search in. Defaults to current working directory." }
+    },
+    required: ["pattern"]
+  },
+  dangerous: false,
+  readOnly: true,
+  async execute(input3) {
+    const pattern = String(input3["pattern"]);
+    const searchPath = input3["path"] ? String(input3["path"]) : process.cwd();
+    const resolved = path14.resolve(searchPath);
+    try {
+      const files = await globby(pattern, {
+        cwd: resolved,
+        gitignore: true,
+        ignore: ["node_modules/**", ".git/**"],
+        absolute: true,
+        onlyFiles: true
+      });
+      const withStats = files.map((f) => {
+        try {
+          const stat = fs13.statSync(f);
+          return { path: f, mtime: stat.mtimeMs };
+        } catch {
+          return { path: f, mtime: 0 };
+        }
+      });
+      withStats.sort((a, b) => b.mtime - a.mtime);
+      const result = withStats.map((f) => f.path);
+      if (result.length === 0) {
+        return makeToolResult(`No files matched pattern: ${pattern} in ${resolved}`);
+      }
+      return makeToolResult(
+        `Found ${result.length} file(s):
+${result.join("\n")}`
+      );
+    } catch (err) {
+      return makeToolError(`Glob failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+};
+
+// src/tools/grep.ts
+init_esm_shims();
+init_tool();
+import { execFile } from "child_process";
+import * as path15 from "path";
+var grepTool = {
+  name: "grep",
+  description: `Search file contents using regex patterns. Uses ripgrep (rg) if available, falls back to grep. Supports context lines, file type filters, and multiple output modes.`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      pattern: { type: "string", description: "Regex pattern to search for" },
+      path: { type: "string", description: "File or directory to search in" },
+      glob: { type: "string", description: 'Glob pattern to filter files (e.g., "*.ts")' },
+      type: { type: "string", description: 'File type filter (e.g., "ts", "py", "js")' },
+      output_mode: {
+        type: "string",
+        enum: ["content", "files_with_matches", "count"],
+        description: "Output mode: content (matching lines), files_with_matches (file paths only), count (match counts)"
+      },
+      "-A": { type: "number", description: "Lines to show after match" },
+      "-B": { type: "number", description: "Lines to show before match" },
+      "-C": { type: "number", description: "Context lines (before and after)" },
+      "-i": { type: "boolean", description: "Case insensitive search" },
+      "-n": { type: "boolean", description: "Show line numbers" },
+      multiline: { type: "boolean", description: "Enable multiline matching" },
+      head_limit: { type: "number", description: "Limit output to first N entries" }
+    },
+    required: ["pattern"]
+  },
+  dangerous: false,
+  readOnly: true,
+  async execute(input3) {
+    const pattern = String(input3["pattern"]);
+    const searchPath = path15.resolve(input3["path"] ? String(input3["path"]) : process.cwd());
+    const outputMode = input3["output_mode"] || "files_with_matches";
+    const headLimit = input3["head_limit"] || 0;
+    const args = [];
+    const useRg = await hasCommand("rg");
+    const cmd = useRg ? "rg" : "grep";
+    if (!useRg) {
+      args.push("-r");
+    }
+    if (outputMode === "files_with_matches") {
+      args.push(useRg ? "-l" : "-l");
+    } else if (outputMode === "count") {
+      args.push(useRg ? "-c" : "-c");
+    }
+    if (input3["-i"]) args.push("-i");
+    if (input3["-n"] !== false && outputMode === "content") {
+      args.push("-n");
+    }
+    if (input3["-C"]) args.push("-C", String(input3["-C"]));
+    else if (input3["-A"]) args.push("-A", String(input3["-A"]));
+    if (input3["-B"]) args.push("-B", String(input3["-B"]));
+    if (input3["multiline"] && useRg) {
+      args.push("-U", "--multiline-dotall");
+    }
+    if (input3["type"] && useRg) {
+      args.push("--type", String(input3["type"]));
+    }
+    if (input3["glob"] && useRg) {
+      args.push("--glob", String(input3["glob"]));
+    }
+    if (useRg) {
+      args.push("--no-ignore-vcs");
+      args.push("-g", "!node_modules");
+      args.push("-g", "!.git");
+    }
+    args.push(pattern, searchPath);
+    try {
+      const result = await runCommand(cmd, args);
+      if (!result.trim()) {
+        return makeToolResult(`No matches found for pattern: ${pattern}`);
+      }
+      let output3 = result;
+      if (headLimit > 0) {
+        const lines = output3.split("\n");
+        output3 = lines.slice(0, headLimit).join("\n");
+        if (lines.length > headLimit) {
+          output3 += `
+... (${lines.length - headLimit} more results)`;
+        }
+      }
+      return makeToolResult(output3);
+    } catch (err) {
+      if (err.code === 1) {
+        return makeToolResult(`No matches found for pattern: ${pattern}`);
+      }
+      return makeToolError(`Search failed: ${err.message || String(err)}`);
+    }
+  }
+};
+function hasCommand(cmd) {
+  return new Promise((resolve10) => {
+    execFile("which", [cmd], (err) => resolve10(!err));
+  });
+}
+function runCommand(cmd, args) {
+  return new Promise((resolve10, reject) => {
+    execFile(cmd, args, { maxBuffer: 10 * 1024 * 1024, timeout: 3e4 }, (err, stdout, stderr) => {
+      if (err) {
+        err.code = err.code;
+        reject(err);
+        return;
+      }
+      resolve10(stdout);
+    });
+  });
+}
+
+// src/tools/bash.ts
+init_esm_shims();
+init_tool();
+import { exec as exec2, spawn } from "child_process";
+var backgroundTasks = /* @__PURE__ */ new Map();
+var taskCounter = 0;
+var bashTool = {
+  name: "bash",
+  description: `Execute a bash command. Supports timeout (max 600s, default 120s) and background execution. The working directory persists between calls.`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      command: { type: "string", description: "The bash command to execute" },
+      description: { type: "string", description: "Brief description of what the command does" },
+      timeout: { type: "number", description: "Timeout in milliseconds (max 600000, default 120000)" },
+      run_in_background: { type: "boolean", description: "Run in background and return a task ID" }
+    },
+    required: ["command"]
+  },
+  dangerous: true,
+  readOnly: false,
+  async execute(input3) {
+    const command = String(input3["command"]);
+    const timeout = Math.min(Number(input3["timeout"]) || 12e4, 6e5);
+    const runInBackground = input3["run_in_background"] === true;
+    if (!command.trim()) {
+      return makeToolError("Command cannot be empty");
+    }
+    if (runInBackground) {
+      return runBackgroundTask(command);
+    }
+    return new Promise((resolve10) => {
+      exec2(command, {
+        timeout,
+        maxBuffer: 10 * 1024 * 1024,
+        shell: process.env["SHELL"] || "/bin/bash",
+        cwd: process.cwd(),
+        env: { ...process.env }
+      }, (err, stdout, stderr) => {
+        if (err) {
+          const exitCode = err.code;
+          const output4 = [
+            stdout ? `stdout:
+${stdout}` : "",
+            stderr ? `stderr:
+${stderr}` : "",
+            `Exit code: ${exitCode}`
+          ].filter(Boolean).join("\n\n");
+          if (err.killed) {
+            resolve10(makeToolError(`Command timed out after ${timeout / 1e3}s
+${output4}`));
+          } else {
+            resolve10(makeToolResult(output4 || `Command failed with exit code ${exitCode}`));
+          }
+          return;
+        }
+        const output3 = [
+          stdout ? stdout : "",
+          stderr ? `stderr:
+${stderr}` : ""
+        ].filter(Boolean).join("\n");
+        resolve10(makeToolResult(output3 || "(no output)"));
+      });
+    });
+  }
+};
+function runBackgroundTask(command) {
+  const taskId = `bg_${++taskCounter}`;
+  const proc = spawn(command, {
+    shell: process.env["SHELL"] || "/bin/bash",
+    cwd: process.cwd(),
+    env: { ...process.env },
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: false
+  });
+  const task = { process: proc, output: "", status: "running", exitCode: void 0 };
+  backgroundTasks.set(taskId, task);
+  proc.stdout?.on("data", (data) => {
+    task.output += data.toString();
+  });
+  proc.stderr?.on("data", (data) => {
+    task.output += data.toString();
+  });
+  proc.on("close", (code) => {
+    task.status = code === 0 ? "done" : "error";
+    task.exitCode = code ?? 1;
+  });
+  proc.on("error", (err) => {
+    task.status = "error";
+    task.output += `
+Process error: ${err.message}`;
+  });
+  return makeToolResult(`Background task started with ID: ${taskId}
+Use task_output tool to check results.`);
+}
+
+// src/tools/list-dir.ts
+init_esm_shims();
+init_tool();
+import * as fs14 from "fs";
+import * as path16 from "path";
+var listDirTool = {
+  name: "list_dir",
+  description: `List directory contents with file/folder distinction and basic metadata.`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Directory path to list (defaults to cwd)" }
+    },
+    required: []
+  },
+  dangerous: false,
+  readOnly: true,
+  async execute(input3) {
+    const dirPath = path16.resolve(input3["path"] ? String(input3["path"]) : process.cwd());
+    if (!fs14.existsSync(dirPath)) {
+      return makeToolError(`Directory not found: ${dirPath}`);
+    }
+    const stat = fs14.statSync(dirPath);
+    if (!stat.isDirectory()) {
+      return makeToolError(`Not a directory: ${dirPath}`);
+    }
+    try {
+      const entries = fs14.readdirSync(dirPath, { withFileTypes: true });
+      const IGNORE = /* @__PURE__ */ new Set([".git", "node_modules", ".DS_Store", "__pycache__", ".next", "dist", "build"]);
+      const lines = [];
+      const dirs = [];
+      const files = [];
+      for (const entry of entries) {
+        if (IGNORE.has(entry.name)) continue;
+        if (entry.isDirectory()) {
+          dirs.push(`${entry.name}/`);
+        } else if (entry.isSymbolicLink()) {
+          try {
+            const target = fs14.readlinkSync(path16.join(dirPath, entry.name));
+            files.push(`${entry.name} -> ${target}`);
+          } catch {
+            files.push(`${entry.name} -> (broken link)`);
+          }
+        } else {
+          files.push(entry.name);
+        }
+      }
+      dirs.sort();
+      files.sort();
+      lines.push(...dirs, ...files);
+      if (lines.length === 0) {
+        return makeToolResult(`Directory is empty: ${dirPath}`);
+      }
+      return makeToolResult(`${dirPath}
+${lines.join("\n")}`);
+    } catch (err) {
+      return makeToolError(`Failed to list directory: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+};
+
+// src/tools/git.ts
+init_esm_shims();
+init_tool();
+import { execSync as execSync4 } from "child_process";
+var gitTool = {
+  name: "git",
+  description: `Execute git commands with safety checks. Blocks dangerous operations like force push, hard reset, and amend. Use for status, diff, log, commit, branch operations.`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      command: { type: "string", description: 'Git subcommand and arguments (e.g., "status", "diff HEAD", "log --oneline -10")' }
+    },
+    required: ["command"]
+  },
+  dangerous: true,
+  readOnly: false,
+  async execute(input3) {
+    const command = String(input3["command"]).trim();
+    const blocked = [
+      { pattern: /push\s+.*--force/, msg: "Force push is blocked for safety. Use regular push." },
+      { pattern: /push\s+.*-f\b/, msg: "Force push (-f) is blocked for safety." },
+      { pattern: /reset\s+--hard/, msg: "Hard reset is blocked. Use soft reset or create a new commit." },
+      { pattern: /clean\s+-f/, msg: "git clean -f is blocked. Manually review files to remove." },
+      { pattern: /checkout\s+\.\s*$/, msg: "git checkout . discards all changes. Use more specific paths." },
+      { pattern: /branch\s+-D/, msg: "Force branch deletion is blocked. Use -d for safe deletion." },
+      { pattern: /\b-i\b/, msg: "Interactive mode (-i) is not supported in non-interactive context." },
+      { pattern: /commit\s+.*--amend/, msg: "Amending commits is blocked. Create a new commit instead." },
+      { pattern: /--no-verify/, msg: "Skipping hooks (--no-verify) is blocked." }
+    ];
+    for (const check of blocked) {
+      if (check.pattern.test(command)) {
+        return makeToolError(check.msg);
+      }
+    }
+    const readOnlyPrefixes = ["status", "diff", "log", "show", "branch", "tag", "remote", "stash list", "ls-files"];
+    const isReadOnly = readOnlyPrefixes.some((p) => command.startsWith(p));
+    try {
+      const result = execSync4(`git ${command}`, {
+        encoding: "utf-8",
+        maxBuffer: 10 * 1024 * 1024,
+        timeout: 3e4,
+        cwd: process.cwd()
+      });
+      return makeToolResult(result || "(no output)");
+    } catch (err) {
+      const output3 = [err.stdout, err.stderr].filter(Boolean).join("\n");
+      return makeToolError(`git ${command} failed:
+${output3 || err.message}`);
+    }
+  }
+};
+
+// src/tools/web-fetch.ts
+init_esm_shims();
+init_tool();
+var cache = /* @__PURE__ */ new Map();
+var CACHE_TTL = 15 * 60 * 1e3;
+var webFetchTool = {
+  name: "web_fetch",
+  description: `Fetch content from a URL, convert HTML to text, and return the content. Includes a 15-minute cache. HTTP URLs are upgraded to HTTPS.`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      url: { type: "string", description: "URL to fetch" },
+      prompt: { type: "string", description: "What information to extract from the page" }
+    },
+    required: ["url", "prompt"]
+  },
+  dangerous: true,
+  readOnly: true,
+  async execute(input3) {
+    let url = String(input3["url"]);
+    const prompt = String(input3["prompt"] || "");
+    if (url.startsWith("http://")) {
+      url = url.replace("http://", "https://");
+    }
+    const cached = cache.get(url);
+    if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+      return makeToolResult(`[Cached] ${prompt ? `Query: ${prompt}
+
+` : ""}${cached.content}`);
+    }
+    try {
+      const response = await fetch(url, {
+        headers: {
+          "User-Agent": "Codi/0.1 (AI Code Agent)",
+          "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+        },
+        redirect: "follow",
+        signal: AbortSignal.timeout(3e4)
+      });
+      if (!response.ok) {
+        return makeToolError(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const contentType = response.headers.get("content-type") || "";
+      let text;
+      if (contentType.includes("text/html") || contentType.includes("application/xhtml")) {
+        const html = await response.text();
+        const { load } = await import("cheerio");
+        const $ = load(html);
+        $("script, style, nav, header, footer, iframe, noscript").remove();
+        const main2 = $("main, article, .content, #content, .main").first();
+        text = (main2.length ? main2.text() : $("body").text()).replace(/\s+/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+      } else {
+        text = await response.text();
+      }
+      const MAX_LEN = 5e4;
+      if (text.length > MAX_LEN) {
+        text = text.slice(0, MAX_LEN) + "\n\n... (truncated)";
+      }
+      cache.set(url, { content: text, timestamp: Date.now() });
+      return makeToolResult(prompt ? `URL: ${url}
+Query: ${prompt}
+
+${text}` : text);
+    } catch (err) {
+      return makeToolError(`Failed to fetch URL: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+};
+
+// src/tools/web-search.ts
+init_esm_shims();
+init_tool();
+var webSearchTool = {
+  name: "web_search",
+  description: `Search the web for information. Returns search results with titles, URLs, and snippets. Uses DuckDuckGo as the search engine.`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: { type: "string", description: "Search query" }
+    },
+    required: ["query"]
+  },
+  dangerous: true,
+  readOnly: true,
+  async execute(input3) {
+    const query = String(input3["query"]);
+    try {
+      const encoded = encodeURIComponent(query);
+      const url = `https://html.duckduckgo.com/html/?q=${encoded}`;
+      const response = await fetch(url, {
+        headers: {
+          "User-Agent": "Mozilla/5.0 (compatible; Codi/0.1)"
+        },
+        signal: AbortSignal.timeout(15e3)
+      });
+      if (!response.ok) {
+        return makeToolError(`Search failed: HTTP ${response.status}`);
+      }
+      const html = await response.text();
+      const { load } = await import("cheerio");
+      const $ = load(html);
+      const results = [];
+      $(".result").each((i, el) => {
+        if (i >= 10) return false;
+        const $el = $(el);
+        const title = $el.find(".result__title a").text().trim();
+        const href = $el.find(".result__title a").attr("href") || "";
+        const snippet = $el.find(".result__snippet").text().trim();
+        if (title && href) {
+          let actualUrl = href;
+          try {
+            const urlObj = new URL(href, "https://duckduckgo.com");
+            actualUrl = urlObj.searchParams.get("uddg") || href;
+          } catch {
+            actualUrl = href;
+          }
+          results.push({ title, url: actualUrl, snippet });
+        }
+      });
+      if (results.length === 0) {
+        return makeToolResult(`No results found for: ${query}`);
+      }
+      const formatted = results.map((r, i) => `${i + 1}. ${r.title}
+   ${r.url}
+   ${r.snippet}`).join("\n\n");
+      return makeToolResult(`Search results for: ${query}
+
+${formatted}`);
+    } catch (err) {
+      return makeToolError(`Search failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+};
+
+// src/tools/notebook-edit.ts
+init_esm_shims();
+init_tool();
+import * as fs15 from "fs";
+import * as path17 from "path";
+var notebookEditTool = {
+  name: "notebook_edit",
+  description: `Edit Jupyter notebook (.ipynb) cells. Supports replacing, inserting, and deleting cells.`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      notebook_path: { type: "string", description: "Path to the .ipynb file" },
+      cell_number: { type: "number", description: "Cell index (0-based)" },
+      new_source: { type: "string", description: "New source content for the cell" },
+      cell_type: { type: "string", enum: ["code", "markdown"], description: "Cell type (for insert)" },
+      edit_mode: { type: "string", enum: ["replace", "insert", "delete"], description: "Edit mode (default: replace)" }
+    },
+    required: ["notebook_path", "new_source"]
+  },
+  dangerous: true,
+  readOnly: false,
+  async execute(input3) {
+    const nbPath = path17.resolve(String(input3["notebook_path"]));
+    const cellNumber = input3["cell_number"];
+    const newSource = String(input3["new_source"]);
+    const cellType = input3["cell_type"] || "code";
+    const editMode = input3["edit_mode"] || "replace";
+    if (!fs15.existsSync(nbPath)) {
+      return makeToolError(`Notebook not found: ${nbPath}`);
+    }
+    try {
+      const content = fs15.readFileSync(nbPath, "utf-8");
+      const nb = JSON.parse(content);
+      if (!nb.cells || !Array.isArray(nb.cells)) {
+        return makeToolError("Invalid notebook format: no cells array");
+      }
+      const sourceLines = newSource.split("\n").map(
+        (l, i, arr) => i < arr.length - 1 ? l + "\n" : l
+      );
+      switch (editMode) {
+        case "replace": {
+          const idx = cellNumber ?? 0;
+          if (idx < 0 || idx >= nb.cells.length) {
+            return makeToolError(`Cell index ${idx} out of range (0-${nb.cells.length - 1})`);
+          }
+          nb.cells[idx].source = sourceLines;
+          if (input3["cell_type"]) {
+            nb.cells[idx].cell_type = cellType;
+          }
+          break;
+        }
+        case "insert": {
+          const idx = cellNumber !== void 0 ? cellNumber + 1 : nb.cells.length;
+          const newCell = {
+            cell_type: cellType,
+            source: sourceLines,
+            metadata: {}
+          };
+          if (cellType === "code") {
+            newCell["execution_count"] = null;
+            newCell["outputs"] = [];
+          }
+          nb.cells.splice(idx, 0, newCell);
+          break;
+        }
+        case "delete": {
+          const idx = cellNumber ?? 0;
+          if (idx < 0 || idx >= nb.cells.length) {
+            return makeToolError(`Cell index ${idx} out of range (0-${nb.cells.length - 1})`);
+          }
+          nb.cells.splice(idx, 1);
+          break;
+        }
+        default:
+          return makeToolError(`Unknown edit_mode: ${editMode}`);
+      }
+      fs15.writeFileSync(nbPath, JSON.stringify(nb, null, 1), "utf-8");
+      return makeToolResult(`Notebook ${editMode}d cell in ${nbPath} (${nb.cells.length} cells total)`);
+    } catch (err) {
+      return makeToolError(`Notebook edit failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+};
+
+// src/cli.ts
+init_task_tools();
+
+// src/tools/ask-user.ts
+init_esm_shims();
+init_tool();
+import * as readline4 from "readline/promises";
+import chalk12 from "chalk";
+var askUserTool = {
+  name: "ask_user",
+  description: `Ask the user a question with optional choices. Use to gather preferences, clarify requirements, or get decisions.`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      question: { type: "string", description: "The question to ask" },
+      options: {
+        type: "array",
+        description: "Optional choices for the user",
+        items: {
+          type: "object",
+          properties: {
+            label: { type: "string", description: "Option label" },
+            description: { type: "string", description: "Option description" }
+          },
+          required: ["label"]
+        }
+      },
+      multiSelect: { type: "boolean", description: "Allow multiple selections" }
+    },
+    required: ["question"]
+  },
+  dangerous: false,
+  readOnly: true,
+  async execute(input3) {
+    const question = String(input3["question"]);
+    const options = input3["options"];
+    const multiSelect = input3["multiSelect"] === true;
+    console.log("");
+    console.log(chalk12.cyan.bold("? ") + chalk12.bold(question));
+    if (options && options.length > 0) {
+      console.log("");
+      for (let i = 0; i < options.length; i++) {
+        const opt = options[i];
+        console.log(chalk12.cyan(`  ${i + 1}.`) + ` ${opt.label}${opt.description ? chalk12.dim(` - ${opt.description}`) : ""}`);
+      }
+      console.log(chalk12.dim(`  ${options.length + 1}. Other (type custom response)`));
+      console.log("");
+      const rl2 = readline4.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      try {
+        const prompt = multiSelect ? chalk12.dim("Enter numbers separated by commas: ") : chalk12.dim("Enter number or type response: ");
+        const answer = await rl2.question(prompt);
+        rl2.close();
+        if (multiSelect) {
+          const indices = answer.split(",").map((s) => parseInt(s.trim()) - 1);
+          const selected = indices.filter((i) => i >= 0 && i < options.length).map((i) => options[i].label);
+          if (selected.length === 0) {
+            return makeToolResult(`User response: ${answer}`);
+          }
+          return makeToolResult(`User selected: ${selected.join(", ")}`);
+        }
+        const idx = parseInt(answer) - 1;
+        if (idx >= 0 && idx < options.length) {
+          return makeToolResult(`User selected: ${options[idx].label}`);
+        }
+        return makeToolResult(`User response: ${answer}`);
+      } catch {
+        rl2.close();
+        return makeToolError("Failed to get user input");
+      }
+    }
+    const rl = readline4.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    try {
+      const answer = await rl.question(chalk12.dim("> "));
+      rl.close();
+      return makeToolResult(`User response: ${answer}`);
+    } catch {
+      rl.close();
+      return makeToolError("Failed to get user input");
+    }
+  }
+};
+
+// src/llm/anthropic.ts
+init_esm_shims();
+import Anthropic from "@anthropic-ai/sdk";
+var AnthropicProvider = class {
+  name = "anthropic";
+  model;
+  client;
+  maxTokens;
+  constructor(config) {
+    this.client = new Anthropic({
+      apiKey: config.apiKey || process.env["ANTHROPIC_API_KEY"],
+      ...config.baseUrl ? { baseURL: config.baseUrl } : {}
+    });
+    this.model = config.model || "claude-sonnet-4-20250514";
+    this.maxTokens = config.maxTokens || 8192;
+  }
+  setModel(model) {
+    this.model = model;
+  }
+  async listModels() {
+    return [
+      "claude-opus-4-20250514",
+      "claude-sonnet-4-20250514",
+      "claude-haiku-3-5-20241022"
+    ];
+  }
+  async chat(options) {
+    const messages = this.convertMessages(options.messages);
+    const tools = options.tools?.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.input_schema
+    }));
+    if (options.stream && options.callbacks) {
+      return this.streamChat(messages, options);
+    }
+    const response = await this.client.messages.create({
+      model: this.model,
+      max_tokens: options.maxTokens || this.maxTokens,
+      ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+      ...options.systemPrompt ? { system: options.systemPrompt } : {},
+      messages,
+      ...tools && tools.length > 0 ? { tools } : {}
+    });
+    return this.parseResponse(response);
+  }
+  async streamChat(messages, options) {
+    const tools = options.tools?.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.input_schema
+    }));
+    const stream = this.client.messages.stream({
+      model: this.model,
+      max_tokens: options.maxTokens || this.maxTokens,
+      ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+      ...options.systemPrompt ? { system: options.systemPrompt } : {},
+      messages,
+      ...tools && tools.length > 0 ? { tools } : {}
+    });
+    stream.on("text", (text) => {
+      options.callbacks?.onToken?.(text);
+    });
+    const response = await stream.finalMessage();
+    return this.parseResponse(response);
+  }
+  convertMessages(messages) {
+    return messages.filter((m) => m.role !== "system").map((m) => {
+      if (typeof m.content === "string") {
+        return { role: m.role, content: m.content };
+      }
+      const blocks = m.content.map((block) => {
+        switch (block.type) {
+          case "text":
+            return { type: "text", text: block.text };
+          case "image":
+            return {
+              type: "image",
+              source: {
+                type: "base64",
+                media_type: block.source.media_type,
+                data: block.source.data
+              }
+            };
+          case "tool_use":
+            return {
+              type: "tool_use",
+              id: block.id,
+              name: block.name,
+              input: block.input
+            };
+          case "tool_result":
+            return {
+              type: "tool_result",
+              tool_use_id: block.tool_use_id,
+              content: typeof block.content === "string" ? block.content : JSON.stringify(block.content),
+              ...block.is_error ? { is_error: true } : {}
+            };
+          default:
+            return { type: "text", text: JSON.stringify(block) };
+        }
+      });
+      return { role: m.role, content: blocks };
+    });
+  }
+  parseResponse(response) {
+    const content = [];
+    const toolCalls = [];
+    let text = "";
+    for (const block of response.content) {
+      if (block.type === "text") {
+        content.push({ type: "text", text: block.text });
+        text += block.text;
+      } else if (block.type === "tool_use") {
+        const tc = {
+          id: block.id,
+          name: block.name,
+          input: block.input
+        };
+        content.push({
+          type: "tool_use",
+          id: block.id,
+          name: block.name,
+          input: block.input
+        });
+        toolCalls.push(tc);
+      }
+    }
+    return {
+      content,
+      text: text || void 0,
+      toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+      usage: {
+        input_tokens: response.usage.input_tokens,
+        output_tokens: response.usage.output_tokens
+      },
+      stopReason: response.stop_reason
+    };
+  }
+};
+
+// src/llm/openai.ts
+init_esm_shims();
+import OpenAI from "openai";
+var OpenAIProvider = class {
+  name = "openai";
+  model;
+  client;
+  maxTokens;
+  constructor(config) {
+    this.client = new OpenAI({
+      apiKey: config.apiKey || process.env["OPENAI_API_KEY"],
+      ...config.baseUrl ? { baseURL: config.baseUrl } : {}
+    });
+    this.model = config.model || "gpt-4o";
+    this.maxTokens = config.maxTokens || 8192;
+  }
+  setModel(model) {
+    this.model = model;
+  }
+  async listModels() {
+    try {
+      const models = await this.client.models.list();
+      return models.data.filter((m) => m.id.startsWith("gpt-")).map((m) => m.id).sort();
+    } catch {
+      return ["gpt-4o", "gpt-4o-mini", "gpt-4.1", "gpt-4.1-mini", "gpt-4.1-nano"];
+    }
+  }
+  async chat(options) {
+    const messages = this.convertMessages(options.messages, options.systemPrompt);
+    const tools = options.tools?.map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.input_schema
+      }
+    }));
+    if (options.stream && options.callbacks) {
+      return this.streamChat(messages, tools, options);
+    }
+    const response = await this.client.chat.completions.create({
+      model: this.model,
+      messages,
+      max_tokens: options.maxTokens || this.maxTokens,
+      ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+      ...tools && tools.length > 0 ? { tools } : {}
+    });
+    return this.parseResponse(response);
+  }
+  async streamChat(messages, tools, options) {
+    const stream = await this.client.chat.completions.create({
+      model: this.model,
+      messages,
+      max_tokens: options.maxTokens || this.maxTokens,
+      ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+      ...tools && tools.length > 0 ? { tools } : {},
+      stream: true
+    });
+    const content = [];
+    const toolCalls = [];
+    let text = "";
+    const toolCallAccumulator = /* @__PURE__ */ new Map();
+    for await (const chunk of stream) {
+      const delta = chunk.choices[0]?.delta;
+      if (!delta) continue;
+      if (delta.content) {
+        text += delta.content;
+        options.callbacks?.onToken?.(delta.content);
+      }
+      if (delta.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          const idx = tc.index;
+          if (!toolCallAccumulator.has(idx)) {
+            toolCallAccumulator.set(idx, { id: tc.id || "", name: tc.function?.name || "", args: "" });
+          }
+          const acc = toolCallAccumulator.get(idx);
+          if (tc.id) acc.id = tc.id;
+          if (tc.function?.name) acc.name = tc.function.name;
+          if (tc.function?.arguments) acc.args += tc.function.arguments;
+        }
+      }
+    }
+    if (text) {
+      content.push({ type: "text", text });
+    }
+    for (const [, acc] of toolCallAccumulator) {
+      let input3 = {};
+      try {
+        input3 = JSON.parse(acc.args);
+      } catch {
+      }
+      const tc = { id: acc.id, name: acc.name, input: input3 };
+      toolCalls.push(tc);
+      content.push({ type: "tool_use", id: acc.id, name: acc.name, input: input3 });
+    }
+    return {
+      content,
+      text: text || void 0,
+      toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+      stopReason: toolCalls.length > 0 ? "tool_use" : "end_turn"
+    };
+  }
+  convertMessages(messages, systemPrompt) {
+    const result = [];
+    if (systemPrompt) {
+      result.push({ role: "system", content: systemPrompt });
+    }
+    for (const m of messages) {
+      if (m.role === "system") {
+        result.push({ role: "system", content: typeof m.content === "string" ? m.content : JSON.stringify(m.content) });
+        continue;
+      }
+      if (typeof m.content === "string") {
+        result.push({ role: m.role, content: m.content });
+        continue;
+      }
+      const hasToolResults = m.content.some((b) => b.type === "tool_result");
+      if (hasToolResults) {
+        for (const block of m.content) {
+          if (block.type === "tool_result") {
+            result.push({
+              role: "tool",
+              tool_call_id: block.tool_use_id,
+              content: typeof block.content === "string" ? block.content : JSON.stringify(block.content)
+            });
+          }
+        }
+        continue;
+      }
+      const hasToolUse = m.content.some((b) => b.type === "tool_use");
+      if (hasToolUse) {
+        const toolCalls = [];
+        let textContent = "";
+        for (const block of m.content) {
+          if (block.type === "tool_use") {
+            toolCalls.push({
+              id: block.id,
+              type: "function",
+              function: {
+                name: block.name,
+                arguments: JSON.stringify(block.input)
+              }
+            });
+          } else if (block.type === "text") {
+            textContent += block.text;
+          }
+        }
+        result.push({
+          role: "assistant",
+          content: textContent || null,
+          tool_calls: toolCalls
+        });
+        continue;
+      }
+      const parts = m.content.filter(
+        (b) => b.type === "text" || b.type === "image"
+      ).map((b) => {
+        if (b.type === "text") return { type: "text", text: b.text };
+        return {
+          type: "image_url",
+          image_url: { url: `data:${b.source.media_type};base64,${b.source.data}` }
+        };
+      });
+      if (m.role === "user") {
+        result.push({ role: "user", content: parts });
+      } else {
+        const textContent = parts.filter((p) => p.type === "text").map((p) => p.text).join("");
+        result.push({ role: "assistant", content: textContent || null });
+      }
+    }
+    return result;
+  }
+  parseResponse(response) {
+    const choice = response.choices[0];
+    if (!choice) {
+      return { content: [], stopReason: "end_turn" };
+    }
+    const content = [];
+    const toolCalls = [];
+    let text = "";
+    if (choice.message.content) {
+      text = choice.message.content;
+      content.push({ type: "text", text });
+    }
+    if (choice.message.tool_calls) {
+      for (const tc of choice.message.tool_calls) {
+        if (tc.type !== "function") continue;
+        let input3 = {};
+        try {
+          input3 = JSON.parse(tc.function.arguments);
+        } catch {
+        }
+        toolCalls.push({ id: tc.id, name: tc.function.name, input: input3 });
+        content.push({ type: "tool_use", id: tc.id, name: tc.function.name, input: input3 });
+      }
+    }
+    return {
+      content,
+      text: text || void 0,
+      toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+      usage: response.usage ? {
+        input_tokens: response.usage.prompt_tokens,
+        output_tokens: response.usage.completion_tokens
+      } : void 0,
+      stopReason: choice.finish_reason === "tool_calls" ? "tool_use" : choice.finish_reason === "length" ? "max_tokens" : "end_turn"
+    };
+  }
+};
+
+// src/llm/ollama.ts
+init_esm_shims();
+import { Ollama } from "ollama";
+var OllamaProvider = class {
+  name = "ollama";
+  model;
+  client;
+  maxTokens;
+  constructor(config) {
+    this.client = new Ollama({
+      host: config.baseUrl || process.env["OLLAMA_HOST"] || "http://localhost:11434"
+    });
+    this.model = config.model || "llama3.1";
+    this.maxTokens = config.maxTokens || 4096;
+  }
+  setModel(model) {
+    this.model = model;
+  }
+  async listModels() {
+    try {
+      const models = await this.client.list();
+      return models.models.map((m) => m.name);
+    } catch {
+      return [];
+    }
+  }
+  async chat(options) {
+    const messages = this.convertMessages(options.messages, options.systemPrompt);
+    const tools = options.tools?.map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.input_schema
+      }
+    }));
+    if (options.stream && options.callbacks) {
+      return this.streamChat(messages, tools, options);
+    }
+    const response = await this.client.chat({
+      model: this.model,
+      messages,
+      ...tools && tools.length > 0 ? { tools } : {},
+      options: {
+        num_predict: options.maxTokens || this.maxTokens,
+        ...options.temperature !== void 0 ? { temperature: options.temperature } : {}
+      }
+    });
+    return this.parseResponse(response);
+  }
+  async streamChat(messages, tools, options) {
+    const response = await this.client.chat({
+      model: this.model,
+      messages,
+      ...tools && tools.length > 0 ? { tools } : {},
+      stream: true,
+      options: {
+        num_predict: options.maxTokens || this.maxTokens,
+        ...options.temperature !== void 0 ? { temperature: options.temperature } : {}
+      }
+    });
+    let text = "";
+    const toolCalls = [];
+    for await (const chunk of response) {
+      if (chunk.message?.content) {
+        text += chunk.message.content;
+        options.callbacks?.onToken?.(chunk.message.content);
+      }
+      if (chunk.message?.tool_calls) {
+        for (const tc of chunk.message.tool_calls) {
+          toolCalls.push({
+            id: `ollama_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            name: tc.function.name,
+            input: tc.function.arguments
+          });
+        }
+      }
+    }
+    const content = [];
+    if (text) content.push({ type: "text", text });
+    for (const tc of toolCalls) {
+      content.push({ type: "tool_use", id: tc.id, name: tc.name, input: tc.input });
+    }
+    return {
+      content,
+      text: text || void 0,
+      toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+      stopReason: toolCalls.length > 0 ? "tool_use" : "end_turn"
+    };
+  }
+  convertMessages(messages, systemPrompt) {
+    const result = [];
+    if (systemPrompt) {
+      result.push({ role: "system", content: systemPrompt });
+    }
+    for (const m of messages) {
+      if (typeof m.content === "string") {
+        result.push({ role: m.role, content: m.content });
+        continue;
+      }
+      const textParts = [];
+      const images = [];
+      for (const block of m.content) {
+        if (block.type === "text") {
+          textParts.push(block.text);
+        } else if (block.type === "image") {
+          images.push(block.source.data);
+        } else if (block.type === "tool_result") {
+          textParts.push(`[Tool Result: ${typeof block.content === "string" ? block.content : JSON.stringify(block.content)}]`);
+        } else if (block.type === "tool_use") {
+          textParts.push(`[Tool Call: ${block.name}(${JSON.stringify(block.input)})]`);
+        }
+      }
+      result.push({
+        role: m.role,
+        content: textParts.join("\n"),
+        ...images.length > 0 ? { images } : {}
+      });
+    }
+    return result;
+  }
+  parseResponse(response) {
+    const content = [];
+    const toolCalls = [];
+    let text = "";
+    if (response.message?.content) {
+      text = response.message.content;
+      content.push({ type: "text", text });
+    }
+    if (response.message?.tool_calls) {
+      for (const tc of response.message.tool_calls) {
+        const toolCall = {
+          id: `ollama_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+          name: tc.function.name,
+          input: tc.function.arguments
+        };
+        toolCalls.push(toolCall);
+        content.push({ type: "tool_use", ...toolCall });
+      }
+    }
+    return {
+      content,
+      text: text || void 0,
+      toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+      usage: response.eval_count ? { input_tokens: response.prompt_eval_count ?? 0, output_tokens: response.eval_count } : void 0,
+      stopReason: toolCalls.length > 0 ? "tool_use" : "end_turn"
+    };
+  }
+};
+
+// src/cli.ts
+function parseArgs(argv) {
+  const args = {};
+  let i = 2;
+  while (i < argv.length) {
+    const arg = argv[i];
+    switch (arg) {
+      case "--model":
+      case "-m":
+        args.model = argv[++i];
+        break;
+      case "--provider":
+        args.provider = argv[++i];
+        break;
+      case "-p":
+        args.prompt = argv.slice(i + 1).join(" ");
+        i = argv.length;
+        break;
+      case "-c":
+      case "--continue":
+        args.continue = true;
+        break;
+      case "-r":
+      case "--resume":
+        args.resume = argv[++i];
+        break;
+      case "--help":
+      case "-h":
+        args.help = true;
+        break;
+      case "--version":
+      case "-v":
+        args.version = true;
+        break;
+      case "--plan":
+        args.plan = true;
+        break;
+      case "--yolo":
+        args.yolo = true;
+        break;
+      default:
+        if (!arg.startsWith("-")) {
+          args.prompt = argv.slice(i).join(" ");
+          i = argv.length;
+        }
+        break;
+    }
+    i++;
+  }
+  return args;
+}
+function printHelp() {
+  console.log(`
+${chalk13.cyan.bold("Codi (\uCF54\uB514)")} - AI Code Agent for Terminal
+
+${chalk13.bold("Usage:")}
+  codi [options] [prompt]
+
+${chalk13.bold("Options:")}
+  -m, --model <model>    Set the model (default: gemini-2.5-flash)
+  --provider <name>      Set the provider (openai, anthropic, ollama)
+  -p <prompt>            Run a single prompt and exit
+  -c, --continue         Continue the last session
+  -r, --resume <id>      Resume a specific session
+  --plan                 Start in plan mode (read-only)
+  --yolo                 Skip all permission checks
+  -h, --help             Show this help
+  -v, --version          Show version
+
+${chalk13.bold("Environment:")}
+  GEMINI_API_KEY         Google Gemini API key (default provider)
+  OPENAI_API_KEY         OpenAI API key
+  ANTHROPIC_API_KEY      Anthropic API key
+
+${chalk13.bold("Examples:")}
+  codi                                   # Start interactive session
+  codi -p "explain main.ts"              # Single prompt
+  codi --provider anthropic              # Use Anthropic Claude
+  codi --model gpt-4o --provider openai  # Use OpenAI GPT-4o
+  codi -c                                # Continue last session
+`);
+}
+async function main() {
+  const args = parseArgs(process.argv);
+  if (args.help) {
+    printHelp();
+    process.exit(0);
+  }
+  if (args.version) {
+    console.log("codi v0.1.0");
+    process.exit(0);
+  }
+  if (await needsSetup()) {
+    const result = await runSetupWizard();
+    if (result) {
+      configManager.reload();
+    }
+  }
+  const config = configManager.get();
+  const providerName = args.provider || config.provider;
+  const modelName = args.model || config.model;
+  let provider;
+  switch (providerName) {
+    case "anthropic":
+      provider = new AnthropicProvider({
+        apiKey: config.apiKeys.anthropic,
+        model: modelName,
+        maxTokens: config.maxTokens,
+        baseUrl: config.baseUrls.anthropic
+      });
+      break;
+    case "ollama":
+      provider = new OllamaProvider({
+        model: modelName,
+        maxTokens: config.maxTokens,
+        baseUrl: config.baseUrls.ollama
+      });
+      break;
+    case "openai":
+    default:
+      provider = new OpenAIProvider({
+        apiKey: config.apiKeys.openai || process.env["GEMINI_API_KEY"],
+        model: modelName,
+        maxTokens: config.maxTokens,
+        baseUrl: config.baseUrls.openai
+      });
+      break;
+  }
+  tokenTracker.setModel(modelName);
+  statusLine.update({ model: modelName, provider: providerName });
+  const registry = new ToolRegistry();
+  registry.registerAll([
+    fileReadTool,
+    fileWriteTool,
+    fileEditTool,
+    fileMultiEditTool,
+    globTool,
+    grepTool,
+    bashTool,
+    listDirTool,
+    gitTool,
+    webFetchTool,
+    webSearchTool,
+    notebookEditTool,
+    subAgentTool,
+    taskCreateTool,
+    taskUpdateTool,
+    taskListTool,
+    taskGetTool,
+    askUserTool
+  ]);
+  const subAgentHandler2 = createSubAgentHandler(provider, registry);
+  setSubAgentHandler(subAgentHandler2);
+  try {
+    await mcpManager.initialize(registry);
+  } catch {
+  }
+  const conversation = new Conversation();
+  const compressor = new ContextCompressor({
+    threshold: config.autoCompactThreshold
+  });
+  const codiMd = loadCodiMd();
+  const memory = config.memoryEnabled ? memoryManager.buildMemoryPrompt() : "";
+  function buildPrompt() {
+    const context = {
+      model: provider.model,
+      provider: provider.name,
+      cwd: process.cwd(),
+      codiMd: codiMd || void 0,
+      memory: memory || void 0,
+      planMode: getMode() === "plan"
+    };
+    return buildSystemPrompt(context);
+  }
+  conversation.setSystemPrompt(buildPrompt());
+  if (args.yolo) {
+    setPermissionMode("yolo");
+  } else if (args.plan) {
+    setPermissionMode("plan");
+    setMode("plan");
+    statusLine.update({ mode: "plan" });
+  }
+  if (args.continue || args.resume) {
+    const id = args.resume || sessionManager.getLatest()?.id;
+    if (id) {
+      const session = sessionManager.load(id);
+      if (session) {
+        const data = session.conversation.serialize();
+        for (const msg of data.messages) {
+          if (msg.role === "user") conversation.addUserMessage(msg.content);
+          else if (msg.role === "assistant") conversation.addAssistantMessage(msg.content);
+        }
+        console.log(chalk13.dim(`Resumed session: ${id}`));
+      }
+    }
+  }
+  await hookManager.runHooks("SessionStart", { cwd: process.cwd() });
+  if (args.prompt) {
+    await agentLoop(args.prompt, {
+      provider,
+      conversation,
+      registry,
+      systemPrompt: conversation.getSystemPrompt(),
+      permissionCheck: checkPermission,
+      preHook: async (toolName, input3) => hookManager.runHooks("PreToolUse", { tool: toolName, args: input3 }),
+      postHook: async (toolName, input3, result) => {
+        await hookManager.runHooks("PostToolUse", { tool: toolName, args: input3, result });
+      },
+      planMode: getMode() === "plan"
+    });
+    await hookManager.runHooks("SessionEnd", {});
+    await mcpManager.disconnectAll();
+    process.exit(0);
+  }
+  const slashCommands = [...createBuiltinCommands(), ...loadCustomCommands()];
+  const cmdCtx = {
+    conversation,
+    provider,
+    compressor,
+    exitFn: async () => {
+      stopSpinner();
+      console.log(chalk13.dim("\nSaving session..."));
+      sessionManager.save(conversation, void 0, provider.model);
+      await hookManager.runHooks("SessionEnd", {});
+      await mcpManager.disconnectAll();
+    },
+    setProvider: (name, model) => {
+      const newProvider = name || providerName;
+      switch (newProvider) {
+        case "openai":
+          provider = new OpenAIProvider({ model, maxTokens: config.maxTokens });
+          break;
+        case "ollama":
+          provider = new OllamaProvider({ model, maxTokens: config.maxTokens });
+          break;
+        default:
+          provider = new AnthropicProvider({ model, maxTokens: config.maxTokens });
+          break;
+      }
+      tokenTracker.setModel(model);
+      statusLine.update({ model, provider: newProvider });
+    },
+    reloadSystemPrompt: () => {
+      conversation.setSystemPrompt(buildPrompt());
+    }
+  };
+  const repl = new Repl({
+    onMessage: async (message) => {
+      checkpointManager.create(conversation, message.slice(0, 50));
+      if (compressor.shouldCompress(conversation)) {
+        console.log(chalk13.dim("Auto-compacting conversation..."));
+        await compressor.compress(conversation, provider);
+        conversation.setSystemPrompt(buildPrompt());
+      }
+      await agentLoop(message, {
+        provider,
+        conversation,
+        registry,
+        systemPrompt: conversation.getSystemPrompt(),
+        permissionCheck: checkPermission,
+        preHook: async (toolName, input3) => hookManager.runHooks("PreToolUse", { tool: toolName, args: input3 }),
+        postHook: async (toolName, input3, result) => {
+          await hookManager.runHooks("PostToolUse", { tool: toolName, args: input3, result });
+        },
+        planMode: getMode() === "plan"
+      });
+    },
+    onSlashCommand: async (command, args2) => {
+      const cmd = slashCommands.find(
+        (c) => c.name === command || c.aliases?.includes(command)
+      );
+      if (!cmd) return false;
+      return cmd.handler(args2, cmdCtx);
+    },
+    onInterrupt: () => {
+      stopSpinner();
+    },
+    onExit: async () => {
+      stopSpinner();
+      console.log(chalk13.dim("\nSaving session..."));
+      sessionManager.save(conversation, void 0, provider.model);
+      await hookManager.runHooks("SessionEnd", {});
+      await mcpManager.disconnectAll();
+    }
+  });
+  process.on("SIGTERM", async () => {
+    stopSpinner();
+    sessionManager.save(conversation, void 0, provider.model);
+    await hookManager.runHooks("SessionEnd", {});
+    await mcpManager.disconnectAll();
+    process.exit(0);
+  });
+  await repl.start();
+}
+main().catch((err) => {
+  console.error(chalk13.red(`Fatal error: ${err.message}`));
+  console.error(err.stack);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map