@alanwchat/coder 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2987 @@
+#!/usr/bin/env node
+/**
+ * Coder CLI — AI-powered coding assistant
+ * Bundled with esbuild
+ */
+
+"use strict";
+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 });
+};
+
+// src/config/index.ts
+var config_exports = {};
+__export(config_exports, {
+  getConfigDirPath: () => getConfigDirPath,
+  getConfigFilePathExplicit: () => getConfigFilePathExplicit,
+  loadConfig: () => loadConfig,
+  resolveApiKey: () => resolveApiKey,
+  resolveProviderConfig: () => resolveProviderConfig,
+  saveConfig: () => saveConfig
+});
+function getConfigDir() {
+  const home = (0, import_node_os.homedir)();
+  const p = (0, import_node_os.platform)();
+  if (p === "win32") {
+    return process.env.APPDATA ? (0, import_node_path10.join)(process.env.APPDATA, "Coder", "cli") : (0, import_node_path10.join)(home, ".config", "coder", "cli");
+  }
+  if (process.env.XDG_CONFIG_HOME) {
+    return (0, import_node_path10.join)(process.env.XDG_CONFIG_HOME, "coder", "cli");
+  }
+  return (0, import_node_path10.join)(home, ".config", "coder", "cli");
+}
+function createDefaultProviderSettings(provider) {
+  const isCustom = provider === "custom";
+  return {
+    apiKeySource: "env",
+    apiKey: "",
+    apiKeyEnvVar: isCustom ? "CUSTOM_API_KEY" : PRESET_PROVIDERS[provider]?.defaultApiKeyEnvVar ?? "API_KEY",
+    customBaseUrl: isCustom ? "https://api.example.com/v1" : "",
+    showUsage: false
+  };
+}
+function createDefaultConfig() {
+  const providers = {};
+  for (const id of PROVIDER_IDS) {
+    providers[id] = createDefaultProviderSettings(id);
+  }
+  return {
+    activeProvider: "deepseek",
+    providers,
+    lastModel: "deepseek-v4-flash",
+    showUsage: false
+  };
+}
+function getConfigFilePath() {
+  return (0, import_node_path10.join)(getConfigDir(), CONFIG_FILE);
+}
+function ensureConfigDir() {
+  const dir = getConfigDir();
+  if (!(0, import_node_fs9.existsSync)(dir)) {
+    (0, import_node_fs9.mkdirSync)(dir, { recursive: true });
+  }
+}
+function loadConfig() {
+  const configPath = getConfigFilePath();
+  if (!(0, import_node_fs9.existsSync)(configPath)) {
+    const defaults = createDefaultConfig();
+    saveConfig(defaults);
+    return defaults;
+  }
+  try {
+    const raw = (0, import_node_fs9.readFileSync)(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return mergeWithDefaults(parsed);
+  } catch {
+    const defaults = createDefaultConfig();
+    saveConfig(defaults);
+    return defaults;
+  }
+}
+function mergeWithDefaults(raw) {
+  const defaults = createDefaultConfig();
+  return {
+    activeProvider: PROVIDER_IDS.includes(String(raw.activeProvider ?? "")) ? raw.activeProvider : defaults.activeProvider,
+    providers: mergeProviders(raw.providers, defaults.providers),
+    lastModel: typeof raw.lastModel === "string" ? raw.lastModel : defaults.lastModel,
+    showUsage: typeof raw.showUsage === "boolean" ? raw.showUsage : defaults.showUsage
+  };
+}
+function mergeProviders(raw, defaults) {
+  const result = { ...defaults };
+  if (!raw || typeof raw !== "object") {
+    return result;
+  }
+  for (const id of PROVIDER_IDS) {
+    const p = raw[id];
+    if (p && typeof p === "object") {
+      result[id] = {
+        apiKeySource: p.apiKeySource === "manual" ? "manual" : "env",
+        apiKey: typeof p.apiKey === "string" ? p.apiKey : result[id].apiKey,
+        apiKeyEnvVar: typeof p.apiKeyEnvVar === "string" ? p.apiKeyEnvVar : result[id].apiKeyEnvVar,
+        customBaseUrl: typeof p.customBaseUrl === "string" ? p.customBaseUrl : result[id].customBaseUrl,
+        showUsage: typeof p.showUsage === "boolean" ? p.showUsage : result[id].showUsage
+      };
+    }
+  }
+  return result;
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  const configPath = getConfigFilePath();
+  (0, import_node_fs9.writeFileSync)(configPath, JSON.stringify(config, null, 2), "utf-8");
+}
+function resolveProviderConfig(config, providerId) {
+  const provider = providerId ?? config.activeProvider;
+  const settings = config.providers[provider];
+  if (provider === "custom") {
+    if (!settings.customBaseUrl.trim()) {
+      throw new Error(
+        "Custom provider selected but no base URL configured. Run `coder config` or manually edit the config file."
+      );
+    }
+    return {
+      provider,
+      baseUrl: settings.customBaseUrl.trim(),
+      apiKeySource: settings.apiKeySource,
+      apiKey: settings.apiKey,
+      apiKeyEnvVar: settings.apiKeyEnvVar.trim(),
+      models: []
+    };
+  }
+  const preset = PRESET_PROVIDERS[provider];
+  if (!preset) {
+    throw new Error(`Unknown provider: ${provider}`);
+  }
+  return {
+    provider,
+    baseUrl: settings.customBaseUrl.trim() || preset.baseUrl,
+    apiKeySource: settings.apiKeySource,
+    apiKey: settings.apiKey,
+    apiKeyEnvVar: settings.apiKeyEnvVar.trim() || preset.defaultApiKeyEnvVar,
+    models: settings.customBaseUrl.trim() ? [] : PRESET_MODELS[provider] ?? []
+  };
+}
+function resolveApiKey(resolved) {
+  if (resolved.apiKeySource === "manual") {
+    if (!resolved.apiKey.trim()) {
+      throw new Error(
+        `API key for ${resolved.provider} is not configured. Set it with: coder config providers.<provider>.apiKey <key>`
+      );
+    }
+    return resolved.apiKey.trim();
+  }
+  const envVar = resolved.apiKeyEnvVar;
+  const envValue = process.env[envVar]?.trim();
+  if (!envValue) {
+    throw new Error(
+      `Environment variable ${envVar} is not set. Set it with: export ${envVar}=<your-api-key>`
+    );
+  }
+  return envValue;
+}
+function getConfigDirPath() {
+  return getConfigDir();
+}
+function getConfigFilePathExplicit() {
+  return getConfigFilePath();
+}
+var import_node_os, import_node_path10, import_node_fs9, PRESET_PROVIDERS, PRESET_MODELS, PROVIDER_IDS, CONFIG_FILE;
+var init_config = __esm({
+  "src/config/index.ts"() {
+    "use strict";
+    import_node_os = require("node:os");
+    import_node_path10 = require("node:path");
+    import_node_fs9 = require("node:fs");
+    PRESET_PROVIDERS = {
+      deepseek: { baseUrl: "https://api.deepseek.com", defaultApiKeyEnvVar: "DEEPSEEK_API_KEY" },
+      glm: { baseUrl: "https://open.bigmodel.cn/api/paas/v4", defaultApiKeyEnvVar: "GLM_API_KEY" },
+      agnes: { baseUrl: "https://api.agnesai.com", defaultApiKeyEnvVar: "AGNES_API_KEY" },
+      nvidia: { baseUrl: "https://integrate.api.nvidia.com/v1", defaultApiKeyEnvVar: "NVIDIA_API_KEY" },
+      minimax: { baseUrl: "https://api.minimax.chat/v1", defaultApiKeyEnvVar: "MINIMAX_API_KEY" }
+    };
+    PRESET_MODELS = {
+      deepseek: [
+        { id: "deepseek-v4-flash", label: "DeepSeek V4 Flash", contextWindow: 1e6, supportsThinking: true, supportsMultimodal: false },
+        { id: "deepseek-chat", label: "DeepSeek Chat", contextWindow: 1e6, supportsThinking: false, supportsMultimodal: true }
+      ],
+      glm: [
+        { id: "glm-4", label: "GLM-4", contextWindow: 128e3, supportsThinking: false, supportsMultimodal: true },
+        { id: "glm-4-plus", label: "GLM-4 Plus", contextWindow: 128e3, supportsThinking: true, supportsMultimodal: true }
+      ],
+      agnes: [
+        { id: "agnes-v3", label: "Agnes V3", contextWindow: 128e3, supportsThinking: false, supportsMultimodal: true }
+      ],
+      nvidia: [],
+      minimax: [
+        { id: "minimax-m1", label: "MiniMax M1", contextWindow: 2e5, supportsThinking: true, supportsMultimodal: false }
+      ]
+    };
+    PROVIDER_IDS = ["deepseek", "glm", "agnes", "nvidia", "minimax", "custom"];
+    CONFIG_FILE = "config.json";
+  }
+});
+
+// src/handlers/list-dir.ts
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+
+// src/handlers/result.ts
+function toolSuccess(tool, data) {
+  return { ok: true, tool, data };
+}
+function toolFailure(tool, code, message) {
+  return {
+    ok: false,
+    tool,
+    error: { code, message }
+  };
+}
+
+// src/handlers/list-dir.ts
+var listDirHandler = async (rawArgs, context) => {
+  const args = rawArgs;
+  if (!context.workspaceDir) {
+    return toolFailure("list_dir", "workspace_required", "No workspace directory set");
+  }
+  const dirPath = (0, import_node_path.resolve)(context.workspaceDir, args.path);
+  const maxDepth = args.recursive ? args.max_depth ?? 1 : 1;
+  try {
+    const entries = walkDirectory(dirPath, 0, maxDepth, args.show_hidden ?? false);
+    return toolSuccess("list_dir", {
+      path: (0, import_node_path.relative)(context.workspaceDir, dirPath),
+      entries
+    });
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    return toolFailure("list_dir", "read_error", message);
+  }
+};
+function walkDirectory(dirPath, currentDepth, maxDepth, showHidden) {
+  const results = [];
+  let entries;
+  try {
+    entries = (0, import_node_fs.readdirSync)(dirPath);
+  } catch {
+    return results;
+  }
+  for (const name of entries) {
+    if (!showHidden && name.startsWith(".")) {
+      continue;
+    }
+    const fullPath = (0, import_node_path.resolve)(dirPath, name);
+    let stats;
+    try {
+      stats = (0, import_node_fs.statSync)(fullPath);
+    } catch {
+      continue;
+    }
+    results.push({
+      name,
+      path: fullPath,
+      isDir: stats.isDirectory(),
+      size: stats.isFile() ? stats.size : void 0
+    });
+    if (stats.isDirectory() && currentDepth < maxDepth) {
+      results.push(...walkDirectory(fullPath, currentDepth + 1, maxDepth, showHidden));
+    }
+  }
+  return results;
+}
+
+// src/handlers/read-file.ts
+var import_node_fs2 = require("node:fs");
+var import_node_path2 = require("node:path");
+var readFileHandler = async (rawArgs, context) => {
+  const args = rawArgs;
+  if (!context.workspaceDir) {
+    return toolFailure("read_file", "workspace_required", "No workspace directory set");
+  }
+  const filePath = (0, import_node_path2.resolve)(context.workspaceDir, args.path);
+  const startLine = args.start_line ?? 1;
+  const maxLines = args.max_lines ?? 500;
+  try {
+    (0, import_node_fs2.statSync)(filePath);
+    const content = (0, import_node_fs2.readFileSync)(filePath, "utf-8");
+    const lines = content.split("\n");
+    const totalLines = lines.length;
+    const endLine = Math.min(startLine + maxLines - 1, totalLines);
+    const paginatedContent = lines.slice(startLine - 1, endLine).join("\n");
+    return toolSuccess("read_file", {
+      path: filePath,
+      encoding: "utf-8",
+      mimeType: "text/plain",
+      content: paginatedContent,
+      totalLines,
+      startLine,
+      endLine,
+      truncated: endLine < totalLines
+    });
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    if (message.includes("ENOENT")) {
+      return toolFailure("read_file", "not_found", `File not found: ${filePath}`);
+    }
+    return toolFailure("read_file", "read_error", message);
+  }
+};
+
+// src/handlers/write-file.ts
+var import_node_fs3 = require("node:fs");
+var import_node_path3 = require("node:path");
+var writeFileHandler = async (rawArgs, context) => {
+  const args = rawArgs;
+  if (!context.workspaceDir) {
+    return toolFailure("write_file", "workspace_required", "No workspace directory set");
+  }
+  const filePath = (0, import_node_path3.resolve)(context.workspaceDir, args.path);
+  if (!filePath.startsWith(context.workspaceDir.replace(/\\/g, "/").replace(/\\/g, "/"))) {
+    return toolFailure("write_file", "path_escape", "Path escapes workspace directory");
+  }
+  if ((0, import_node_fs3.existsSync)(filePath)) {
+    return toolFailure("write_file", "file_exists", `File already exists: ${args.path}. Use replace_file to overwrite.`);
+  }
+  try {
+    if (args.create_parent_dirs !== false) {
+      const parentDir = (0, import_node_path3.dirname)(filePath);
+      if (!(0, import_node_fs3.existsSync)(parentDir)) {
+        (0, import_node_fs3.mkdirSync)(parentDir, { recursive: true });
+      }
+    }
+    const lines = args.content.split("\n");
+    (0, import_node_fs3.writeFileSync)(filePath, args.content, "utf-8");
+    return toolSuccess("write_file", {
+      path: args.path,
+      action: "created",
+      bytesWritten: Buffer.byteLength(args.content, "utf-8"),
+      linesAdded: lines.length,
+      linesRemoved: 0
+    });
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    return toolFailure("write_file", "write_error", message);
+  }
+};
+
+// src/handlers/replace-file.ts
+var import_node_fs4 = require("node:fs");
+var import_node_path4 = require("node:path");
+var import_node_crypto = require("node:crypto");
+var replaceFileHandler = async (rawArgs, context) => {
+  const args = rawArgs;
+  if (!context.workspaceDir) {
+    return toolFailure("replace_file", "workspace_required", "No workspace directory set");
+  }
+  const filePath = (0, import_node_path4.resolve)(context.workspaceDir, args.path);
+  if (!(0, import_node_fs4.existsSync)(filePath)) {
+    return toolFailure("replace_file", "not_found", `File not found: ${args.path}`);
+  }
+  try {
+    const oldContent = (0, import_node_fs4.readFileSync)(filePath, "utf-8");
+    const oldLines = oldContent.split("\n");
+    const newLines = args.content.split("\n");
+    if (args.expected_sha256) {
+      const actualHash = (0, import_node_crypto.createHash)("sha256").update(oldContent).digest("hex");
+      if (actualHash !== args.expected_sha256) {
+        return toolFailure(
+          "replace_file",
+          "content_changed",
+          `File content changed since last read. Expected SHA256: ${args.expected_sha256}, got: ${actualHash}. Read the file again to get the latest content.`
+        );
+      }
+    }
+    (0, import_node_fs4.writeFileSync)(filePath, args.content, "utf-8");
+    return toolSuccess("replace_file", {
+      path: args.path,
+      action: "replaced",
+      bytesWritten: Buffer.byteLength(args.content, "utf-8"),
+      linesAdded: newLines.length,
+      linesRemoved: oldLines.length
+    });
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    return toolFailure("replace_file", "write_error", message);
+  }
+};
+
+// src/handlers/edit-file.ts
+var import_node_fs5 = require("node:fs");
+var import_node_path5 = require("node:path");
+var import_node_crypto2 = require("node:crypto");
+var editFileHandler = async (rawArgs, context) => {
+  const args = rawArgs;
+  if (!context.workspaceDir) {
+    return toolFailure("edit_file", "workspace_required", "No workspace directory set");
+  }
+  const filePath = (0, import_node_path5.resolve)(context.workspaceDir, args.path);
+  if (!(0, import_node_fs5.existsSync)(filePath)) {
+    return toolFailure("edit_file", "not_found", `File not found: ${args.path}`);
+  }
+  try {
+    const oldContent = (0, import_node_fs5.readFileSync)(filePath, "utf-8");
+    const oldLines = oldContent.split("\n");
+    if (args.expected_sha256) {
+      const actualHash = (0, import_node_crypto2.createHash)("sha256").update(oldContent).digest("hex");
+      if (actualHash !== args.expected_sha256) {
+        return toolFailure(
+          "edit_file",
+          "content_changed",
+          `File content changed since last read. Expected SHA256: ${args.expected_sha256}, got: ${actualHash}.`
+        );
+      }
+    }
+    let newContent;
+    if (args.replace_all) {
+      newContent = oldContent.split(args.old_string).join(args.new_string);
+    } else {
+      const index = oldContent.indexOf(args.old_string);
+      if (index === -1) {
+        return toolFailure(
+          "edit_file",
+          "string_not_found",
+          `Could not find the exact text to replace in ${args.path}. The text must match exactly.`
+        );
+      }
+      newContent = oldContent.slice(0, index) + args.new_string + oldContent.slice(index + args.old_string.length);
+    }
+    const newLines = newContent.split("\n");
+    (0, import_node_fs5.writeFileSync)(filePath, newContent, "utf-8");
+    const linesAdded = newLines.length - oldLines.length;
+    const linesRemoved = oldLines.length - newLines.length;
+    return toolSuccess("edit_file", {
+      path: args.path,
+      action: "modified",
+      bytesWritten: Buffer.byteLength(newContent, "utf-8"),
+      linesAdded: linesAdded > 0 ? linesAdded : 0,
+      linesRemoved: linesRemoved > 0 ? linesRemoved : 0
+    });
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    return toolFailure("edit_file", "write_error", message);
+  }
+};
+
+// src/handlers/replace-lines.ts
+var import_node_fs6 = require("node:fs");
+var import_node_path6 = require("node:path");
+var import_node_crypto3 = require("node:crypto");
+var replaceLinesHandler = async (rawArgs, context) => {
+  const args = rawArgs;
+  if (!context.workspaceDir) {
+    return toolFailure("replace_lines", "workspace_required", "No workspace directory set");
+  }
+  const filePath = (0, import_node_path6.resolve)(context.workspaceDir, args.path);
+  if (!(0, import_node_fs6.existsSync)(filePath)) {
+    return toolFailure("replace_lines", "not_found", `File not found: ${args.path}`);
+  }
+  try {
+    const oldContent = (0, import_node_fs6.readFileSync)(filePath, "utf-8");
+    const oldLines = oldContent.split("\n");
+    if (args.expected_sha256) {
+      const actualHash = (0, import_node_crypto3.createHash)("sha256").update(oldContent).digest("hex");
+      if (actualHash !== args.expected_sha256) {
+        return toolFailure(
+          "replace_lines",
+          "content_changed",
+          `File content changed since last read. Expected SHA256: ${args.expected_sha256}, got: ${actualHash}.`
+        );
+      }
+    }
+    if (args.start_line < 1 || args.end_line < args.start_line || args.start_line > oldLines.length) {
+      return toolFailure(
+        "replace_lines",
+        "invalid_range",
+        `Invalid line range: ${args.start_line}-${args.end_line}. File has ${oldLines.length} lines.`
+      );
+    }
+    const endLine = Math.min(args.end_line, oldLines.length);
+    const replacementLines = args.content === "" ? [] : args.content.split("\n");
+    const before = oldLines.slice(0, args.start_line - 1);
+    const after = oldLines.slice(endLine);
+    const newContent = [...before, ...replacementLines, ...after].join("\n");
+    (0, import_node_fs6.writeFileSync)(filePath, newContent, "utf-8");
+    return toolSuccess("replace_lines", {
+      path: args.path,
+      action: "modified",
+      bytesWritten: Buffer.byteLength(newContent, "utf-8"),
+      linesAdded: replacementLines.length,
+      linesRemoved: endLine - args.start_line + 1
+    });
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    return toolFailure("replace_lines", "write_error", message);
+  }
+};
+
+// src/handlers/glob.ts
+var import_node_fs7 = require("node:fs");
+var import_node_path7 = require("node:path");
+var globHandler = async (rawArgs, context) => {
+  const args = rawArgs;
+  if (!context.workspaceDir) {
+    return toolFailure("glob", "workspace_required", "No workspace directory set");
+  }
+  const searchDir = args.target_directory ? (0, import_node_path7.resolve)(context.workspaceDir, args.target_directory) : context.workspaceDir;
+  const headLimit = args.head_limit ?? 100;
+  const pattern = args.glob_pattern;
+  try {
+    const matches = simpleGlob(searchDir, pattern, context.workspaceDir, headLimit);
+    return toolSuccess("glob", {
+      pattern,
+      targetDirectory: (0, import_node_path7.relative)(context.workspaceDir, searchDir),
+      matches: matches.slice(0, headLimit),
+      totalMatches: matches.length,
+      truncated: matches.length > headLimit
+    });
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    return toolFailure("glob", "search_error", message);
+  }
+};
+function simpleGlob(rootDir, pattern, workspaceDir, limit) {
+  const results = [];
+  function walk(dir) {
+    if (results.length >= limit) return;
+    let entries;
+    try {
+      entries = (0, import_node_fs7.readdirSync)(dir);
+    } catch {
+      return;
+    }
+    for (const name of entries) {
+      if (results.length >= limit) return;
+      if (name.startsWith(".")) continue;
+      const fullPath = (0, import_node_path7.resolve)(dir, name);
+      const relPath = (0, import_node_path7.relative)(workspaceDir, fullPath).replace(/\\/g, "/");
+      let stats;
+      try {
+        stats = (0, import_node_fs7.statSync)(fullPath);
+      } catch {
+        continue;
+      }
+      const regex = globToRegex(pattern);
+      if (regex.test(relPath)) {
+        results.push(relPath);
+      }
+      if (stats.isDirectory()) {
+        walk(fullPath);
+      }
+    }
+  }
+  walk(rootDir);
+  results.sort();
+  return results;
+}
+function globToRegex(pattern) {
+  let regexStr = "^";
+  let i = 0;
+  while (i < pattern.length) {
+    const ch = pattern[i];
+    if (ch === "*") {
+      if (i + 1 < pattern.length && pattern[i + 1] === "*") {
+        regexStr += ".*";
+        i += 2;
+        if (i < pattern.length && pattern[i] === "/") {
+          regexStr += "/?";
+          i++;
+        }
+      } else {
+        regexStr += "[^/]*";
+        i++;
+      }
+    } else if (ch === "?") {
+      regexStr += "[^/]";
+      i++;
+    } else if (ch === "." || ch === "+" || ch === "(" || ch === ")" || ch === "[" || ch === "]" || ch === "{" || ch === "}" || ch === "\\" || ch === "^" || ch === "$" || ch === "|") {
+      regexStr += "\\" + ch;
+      i++;
+    } else {
+      regexStr += ch;
+      i++;
+    }
+  }
+  regexStr += "$";
+  return new RegExp(regexStr, "i");
+}
+
+// src/handlers/grep.ts
+var import_node_fs8 = require("node:fs");
+var import_node_path8 = require("node:path");
+var grepHandler = async (rawArgs, context) => {
+  const args = rawArgs;
+  if (!context.workspaceDir) {
+    return toolFailure("grep", "workspace_required", "No workspace directory set");
+  }
+  const searchPath = args.path ? (0, import_node_path8.resolve)(context.workspaceDir, args.path) : context.workspaceDir;
+  const headLimit = args.head_limit ?? 200;
+  const offset = args.offset ?? 0;
+  const ctxBefore = args.context_before ?? args.context ?? 0;
+  const ctxAfter = args.context_after ?? args.context ?? 0;
+  const flags = args.case_insensitive ? "gi" : "g";
+  const outputMode = args.output_mode ?? "content";
+  const multiline = args.multiline ?? false;
+  try {
+    let searchRegex;
+    try {
+      const regexFlags = multiline ? `${flags}s` : flags;
+      searchRegex = new RegExp(args.pattern, regexFlags);
+    } catch {
+      return toolFailure("grep", "invalid_pattern", `Invalid regex pattern: ${args.pattern}`);
+    }
+    const files = collectFiles(searchPath);
+    const matches = [];
+    const fileMatchSet = /* @__PURE__ */ new Set();
+    const fileCountMap = {};
+    let totalMatches = 0;
+    let skippedFiles = 0;
+    for (const file of files) {
+      if (totalMatches >= headLimit + offset) break;
+      let content;
+      try {
+        content = (0, import_node_fs8.readFileSync)(file, "utf-8");
+      } catch {
+        skippedFiles++;
+        continue;
+      }
+      const relativePath = (0, import_node_path8.relative)(context.workspaceDir, file);
+      let fileHasMatch = false;
+      let fileMatchCount = 0;
+      if (multiline) {
+        const lines = content.split("\n");
+        searchRegex.lastIndex = 0;
+        const fullMatch = searchRegex.exec(content);
+        if (fullMatch) {
+          fileHasMatch = true;
+          do {
+            totalMatches++;
+            fileMatchCount++;
+            searchRegex.lastIndex = fullMatch.index + 1;
+          } while (searchRegex.exec(content));
+          searchRegex.lastIndex = 0;
+          if (outputMode === "content") {
+            matches.push({
+              path: relativePath,
+              lineNumber: 1,
+              line: fullMatch[0].slice(0, 200)
+            });
+          }
+        }
+      } else {
+        const lines = content.split("\n");
+        for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+          searchRegex.lastIndex = 0;
+          if (searchRegex.test(lines[lineNum])) {
+            totalMatches++;
+            fileMatchCount++;
+            if (outputMode === "files_with_matches") {
+              fileMatchSet.add(relativePath);
+              fileHasMatch = true;
+              continue;
+            }
+            if (outputMode === "count") {
+              fileHasMatch = true;
+              continue;
+            }
+            if (totalMatches > offset && totalMatches <= offset + headLimit) {
+              const contextBeforeLines = ctxBefore > 0 ? lines.slice(Math.max(0, lineNum - ctxBefore), lineNum) : void 0;
+              const contextAfterLines = ctxAfter > 0 ? lines.slice(lineNum + 1, lineNum + 1 + ctxAfter) : void 0;
+              matches.push({
+                path: relativePath,
+                lineNumber: lineNum + 1,
+                line: lines[lineNum],
+                contextBefore: contextBeforeLines?.length ? contextBeforeLines : void 0,
+                contextAfter: contextAfterLines?.length ? contextAfterLines : void 0
+              });
+            }
+          }
+        }
+      }
+      if (fileHasMatch || fileMatchCount > 0) {
+        fileMatchSet.add(relativePath);
+        fileCountMap[relativePath] = fileMatchCount;
+      }
+      if (outputMode === "files_with_matches" && fileMatchSet.size >= headLimit) {
+        break;
+      }
+    }
+    const result = {
+      pattern: args.pattern,
+      path: (0, import_node_path8.relative)(context.workspaceDir, searchPath),
+      outputMode,
+      totalMatches,
+      truncated: totalMatches > headLimit
+    };
+    if (outputMode === "content") {
+      result.matches = matches;
+    } else if (outputMode === "files_with_matches") {
+      result.files = [...fileMatchSet];
+    } else if (outputMode === "count") {
+      result.files = [...fileMatchSet];
+      result.fileCounts = fileCountMap;
+    }
+    if (skippedFiles > 0) {
+      result.skippedFiles = skippedFiles;
+    }
+    return toolSuccess("grep", result);
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    return toolFailure("grep", "search_error", message);
+  }
+};
+function collectFiles(dirPath) {
+  try {
+    const stats = (0, import_node_fs8.statSync)(dirPath);
+    if (stats.isFile()) {
+      return [dirPath];
+    }
+  } catch {
+    return [];
+  }
+  const results = [];
+  function walk(dir) {
+    let entries;
+    try {
+      entries = (0, import_node_fs8.readdirSync)(dir);
+    } catch {
+      return;
+    }
+    for (const name of entries) {
+      if (name === ".git" || name === "node_modules") continue;
+      const fullPath = (0, import_node_path8.resolve)(dir, name);
+      let stats;
+      try {
+        stats = (0, import_node_fs8.statSync)(fullPath);
+      } catch {
+        continue;
+      }
+      if (stats.isDirectory()) {
+        walk(fullPath);
+      } else if (stats.isFile() && stats.size > 0) {
+        results.push(fullPath);
+      }
+    }
+  }
+  walk(dirPath);
+  return results;
+}
+
+// src/handlers/shell-manager.ts
+var import_node_child_process = require("node:child_process");
+var import_node_path9 = require("node:path");
+var shells = /* @__PURE__ */ new Map();
+var shellCounter = 0;
+function generateShellId() {
+  shellCounter++;
+  return `shell-${Date.now()}-${shellCounter}`;
+}
+async function executeShell(command, options) {
+  const shellId = generateShellId();
+  const cwd = options.workspaceDir ? options.workingDirectory ? (0, import_node_path9.resolve)(options.workspaceDir, options.workingDirectory) : options.workspaceDir : process.cwd();
+  const startTime = Date.now();
+  const blockMs = options.blockUntilMs ?? 3e4;
+  const isWindows = process.platform === "win32";
+  const shellCmd = isWindows ? "cmd.exe" : "/bin/sh";
+  const shellArgs = isWindows ? ["/c", command] : ["-c", command];
+  return new Promise((resolvePromise) => {
+    const child = (0, import_node_child_process.spawn)(shellCmd, shellArgs, {
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      shell: false,
+      env: { ...process.env }
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const shell = {
+      shellId,
+      command,
+      description: options.description,
+      process: child,
+      status: "running",
+      stdout,
+      stderr,
+      workingDirectory: cwd,
+      startedAtMs: startTime,
+      taskId: options.taskId
+    };
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+      shell.stdout = stdout;
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+      shell.stderr = stderr;
+    });
+    const finish = (status, code) => {
+      if (settled) return;
+      settled = true;
+      shell.status = status;
+      shell.exitCode = code;
+      const duration = Date.now() - startTime;
+      const stdoutBytes = Buffer.byteLength(stdout);
+      const stderrBytes = Buffer.byteLength(stderr);
+      if (blockMs <= 0) {
+        shells.set(shellId, shell);
+      } else {
+        shells.delete(shellId);
+      }
+      resolvePromise({
+        command,
+        description: options.description,
+        workingDirectory: cwd,
+        stdout,
+        stderr,
+        stdoutTruncated: stdoutBytes > 65536,
+        stderrTruncated: stderrBytes > 65536,
+        stdoutTotalBytes: stdoutBytes,
+        stderrTotalBytes: stderrBytes,
+        exitCode: code,
+        durationMs: duration,
+        status,
+        shellId: blockMs <= 0 ? shellId : void 0
+      });
+    };
+    child.on("error", (err) => {
+      stderr += err.message;
+      finish("failed", 1);
+    });
+    child.on("close", (code) => {
+      finish(code === 0 ? "completed" : "failed", code ?? void 0);
+    });
+    if (blockMs > 0) {
+      const timeout = setTimeout(() => {
+        if (!settled) {
+          child.kill();
+          finish("timeout", void 0);
+        }
+      }, blockMs);
+      child.on("close", () => clearTimeout(timeout));
+    }
+    if (blockMs <= 0) {
+      shells.set(shellId, shell);
+      const stdoutBytes = Buffer.byteLength(stdout);
+      const stderrBytes = Buffer.byteLength(stderr);
+      resolvePromise({
+        command,
+        description: options.description,
+        workingDirectory: cwd,
+        stdout: "",
+        stderr: "",
+        stdoutTruncated: false,
+        stderrTruncated: false,
+        stdoutTotalBytes: 0,
+        stderrTotalBytes: 0,
+        exitCode: void 0,
+        durationMs: 0,
+        status: "running",
+        shellId
+      });
+    }
+  });
+}
+async function awaitShell(shellId, blockUntilMs = 3e4) {
+  const shell = shells.get(shellId);
+  if (!shell) {
+    return {
+      command: "",
+      workingDirectory: "",
+      stdout: "",
+      stderr: "",
+      stdoutTruncated: false,
+      stderrTruncated: false,
+      stdoutTotalBytes: 0,
+      stderrTotalBytes: 0,
+      durationMs: 0,
+      status: "completed",
+      shellId
+    };
+  }
+  return new Promise((resolvePromise) => {
+    const startTime = Date.now();
+    const checkProcess = () => {
+      if (shell.exitCode !== void 0 || shell.status !== "running") {
+        const duration = Date.now() - startTime;
+        const stdoutBytes = Buffer.byteLength(shell.stdout);
+        const stderrBytes = Buffer.byteLength(shell.stderr);
+        resolvePromise({
+          command: shell.command,
+          description: shell.description,
+          workingDirectory: shell.workingDirectory,
+          stdout: shell.stdout,
+          stderr: shell.stderr,
+          stdoutTruncated: stdoutBytes > 65536,
+          stderrTruncated: stderrBytes > 65536,
+          stdoutTotalBytes: stdoutBytes,
+          stderrTotalBytes: stderrBytes,
+          exitCode: shell.exitCode,
+          durationMs: duration,
+          status: shell.status,
+          shellId
+        });
+        return;
+      }
+      if (Date.now() - startTime > blockUntilMs) {
+        const duration = Date.now() - startTime;
+        const stdoutBytes = Buffer.byteLength(shell.stdout);
+        const stderrBytes = Buffer.byteLength(shell.stderr);
+        resolvePromise({
+          command: shell.command,
+          description: shell.description,
+          workingDirectory: shell.workingDirectory,
+          stdout: shell.stdout,
+          stderr: shell.stderr,
+          stdoutTruncated: stdoutBytes > 65536,
+          stderrTruncated: stderrBytes > 65536,
+          stdoutTotalBytes: stdoutBytes,
+          stderrTotalBytes: stderrBytes,
+          exitCode: shell.exitCode,
+          durationMs: duration,
+          status: shell.status,
+          shellId
+        });
+        return;
+      }
+      setTimeout(checkProcess, 50);
+    };
+    shell.process.on("close", () => {
+      checkProcess();
+    });
+    checkProcess();
+  });
+}
+function listShells(statusFilter) {
+  const result = [];
+  for (const shell of shells.values()) {
+    if (statusFilter && shell.status !== statusFilter && statusFilter !== "all") {
+      continue;
+    }
+    result.push({
+      shellId: shell.shellId,
+      command: shell.command,
+      description: shell.description,
+      workingDirectory: shell.workingDirectory,
+      status: shell.status,
+      exitCode: shell.exitCode,
+      startedAtMs: shell.startedAtMs,
+      taskId: shell.taskId,
+      stdout: shell.stdout,
+      stderr: shell.stderr,
+      stdoutTruncated: Buffer.byteLength(shell.stdout) > 65536,
+      stderrTruncated: Buffer.byteLength(shell.stderr) > 65536
+    });
+  }
+  return result;
+}
+function killShell(shellId) {
+  const shell = shells.get(shellId);
+  if (!shell) return false;
+  try {
+    shell.process.kill("SIGTERM");
+    shell.status = "cancelled";
+    setTimeout(() => {
+      try {
+        shell.process.kill("SIGKILL");
+      } catch {
+      }
+    }, 2e3);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readShellLogs(shellId, stream, offset = 0, limit = 4096) {
+  const shell = shells.get(shellId);
+  if (!shell) {
+    return { data: "", offset: 0, totalBytes: 0, truncated: false };
+  }
+  const content = stream === "stdout" ? shell.stdout : shell.stderr;
+  const totalBytes = Buffer.byteLength(content);
+  const sliced = content.slice(offset, offset + limit);
+  return {
+    data: sliced,
+    offset: offset + sliced.length,
+    totalBytes,
+    truncated: offset + limit < totalBytes
+  };
+}
+
+// src/handlers/shell.ts
+var shellHandler = async (rawArgs, context) => {
+  const args = rawArgs;
+  if (!args.command?.trim()) {
+    return toolFailure("shell", "invalid_arguments", "Command is required");
+  }
+  try {
+    const result = await executeShell(args.command.trim(), {
+      workingDirectory: args.working_directory,
+      description: args.description,
+      blockUntilMs: args.block_until_ms ?? 3e4,
+      taskId: context.taskId,
+      workspaceDir: context.workspaceDir
+    });
+    return toolSuccess("shell", result);
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    return toolFailure("shell", "execution_error", message);
+  }
+};
+
+// src/handlers/await-shell.ts
+var awaitShellHandler = async (rawArgs, _context) => {
+  const args = rawArgs;
+  if (!args.shell_id?.trim()) {
+    return toolFailure("await", "invalid_arguments", "shell_id is required");
+  }
+  try {
+    const result = await awaitShell(args.shell_id.trim(), args.block_until_ms ?? 3e4);
+    return toolSuccess("await", result);
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    return toolFailure("await", "error", message);
+  }
+};
+
+// src/handlers/list-shells.ts
+var listShellsHandler = async (rawArgs, _context) => {
+  const args = rawArgs;
+  const shells2 = listShells(args.status_filter);
+  return toolSuccess("list_shells", {
+    shells: shells2,
+    total: shells2.length
+  });
+};
+
+// src/handlers/kill-shell.ts
+var killShellHandler = async (rawArgs, _context) => {
+  const args = rawArgs;
+  if (!args.shell_id?.trim()) {
+    return toolFailure("kill_shell", "invalid_arguments", "shell_id is required");
+  }
+  const killed = killShell(args.shell_id.trim());
+  return toolSuccess("kill_shell", {
+    shellId: args.shell_id.trim(),
+    killed
+  });
+};
+
+// src/handlers/read-shell-logs.ts
+var readShellLogsHandler = async (rawArgs, _context) => {
+  const args = rawArgs;
+  if (!args.shell_id?.trim()) {
+    return toolFailure("read_shell_logs", "invalid_arguments", "shell_id is required");
+  }
+  const result = readShellLogs(
+    args.shell_id.trim(),
+    args.stream ?? "stdout",
+    args.offset ?? 0,
+    args.limit ?? 4096
+  );
+  return toolSuccess("read_shell_logs", {
+    shellId: args.shell_id.trim(),
+    stream: args.stream ?? "stdout",
+    data: result.data,
+    offset: result.offset,
+    totalBytes: result.totalBytes,
+    truncated: result.truncated
+  });
+};
+
+// src/handlers/web-search.ts
+var webSearchHandler = async (rawArgs, _context) => {
+  const args = rawArgs;
+  if (!args.search_term?.trim()) {
+    return toolFailure("web_search", "invalid_arguments", "search_term is required");
+  }
+  try {
+    const results = await performWebSearch(args.search_term, args.max_results ?? 5);
+    return toolSuccess("web_search", {
+      query: args.search_term,
+      results
+    });
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    return toolFailure("web_search", "search_error", message);
+  }
+};
+async function performWebSearch(query, maxResults) {
+  try {
+    const url = `https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json&no_html=1&skip_disambig=1`;
+    const response = await fetch(url, {
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    const data = await response.json();
+    const results = [];
+    if (data.AbstractText) {
+      results.push({
+        title: data.AbstractSource ?? "Result",
+        url: data.AbstractURL ?? "",
+        snippet: data.AbstractText
+      });
+    }
+    if (data.RelatedTopics) {
+      for (const topic of data.RelatedTopics.slice(0, maxResults)) {
+        if (topic.Text && topic.FirstURL) {
+          results.push({
+            title: topic.Text.split(" - ")[0] ?? "Result",
+            url: topic.FirstURL,
+            snippet: topic.Text
+          });
+        }
+      }
+    }
+    return results.slice(0, maxResults);
+  } catch {
+    throw new Error(
+      "Web search is currently unavailable. Configure a Tavily API key for web search support, or set the TAVILY_API_KEY environment variable."
+    );
+  }
+}
+
+// src/handlers/browse-page.ts
+var browsePageHandler = async (rawArgs, _context) => {
+  const args = rawArgs;
+  if (!args.url?.trim()) {
+    return toolFailure("browse_page", "invalid_arguments", "url is required");
+  }
+  try {
+    const response = await fetch(args.url.trim(), {
+      headers: {
+        "User-Agent": "Mozilla/5.0 (compatible; CoderCLI/1.0)",
+        Accept: "text/html,text/plain,*/*"
+      },
+      signal: AbortSignal.timeout(15e3)
+    });
+    const contentType = response.headers.get("content-type") ?? "text/plain";
+    const finalUrl = response.url;
+    const title = extractTitleFromUrl(finalUrl);
+    let content = await response.text();
+    const startLine = args.start_line ?? 1;
+    const maxLines = args.max_lines ?? 500;
+    const lines = content.split("\n");
+    const totalLines = lines.length;
+    const endLine = Math.min(startLine + maxLines - 1, totalLines);
+    const paginatedContent = lines.slice(startLine - 1, endLine).join("\n");
+    return toolSuccess("browse_page", {
+      url: args.url,
+      finalUrl,
+      title,
+      content: paginatedContent,
+      truncated: endLine < totalLines,
+      statusCode: response.status,
+      contentType
+    });
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    if (message.includes("fetch")) {
+      return toolFailure("browse_page", "network_error", `Failed to fetch URL: ${message}`);
+    }
+    return toolFailure("browse_page", "error", message);
+  }
+};
+function extractTitleFromUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.hostname;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/handlers/todos.ts
+var import_node_fs10 = require("node:fs");
+var import_node_path11 = require("node:path");
+init_config();
+function getTodosFilePath(sessionId) {
+  const dir = (0, import_node_path11.join)(getConfigDirPath(), "todos");
+  if (!(0, import_node_fs10.existsSync)(dir)) {
+    (0, import_node_fs10.mkdirSync)(dir, { recursive: true });
+  }
+  const safeSessionId = (sessionId ?? "default").replace(/[^a-z0-9-]/gi, "");
+  return (0, import_node_path11.join)(dir, `${safeSessionId}.json`);
+}
+function readTodos(sessionId) {
+  const filePath = getTodosFilePath(sessionId);
+  if (!(0, import_node_fs10.existsSync)(filePath)) return [];
+  try {
+    return JSON.parse((0, import_node_fs10.readFileSync)(filePath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function writeTodos(todos, sessionId) {
+  (0, import_node_fs10.writeFileSync)(getTodosFilePath(sessionId), JSON.stringify(todos, null, 2), "utf-8");
+}
+var todoReadHandler = async (rawArgs, context) => {
+  const args = rawArgs;
+  const sessionId = args.session_id ?? context.sessionId;
+  const todos = readTodos(sessionId);
+  const snapshot = todos.sort((a, b) => a.order - b.order).map((t) => ({
+    id: t.id,
+    content: t.content,
+    status: t.status
+  }));
+  return toolSuccess("todo_read", {
+    sessionId: sessionId ?? null,
+    todos: snapshot,
+    total: snapshot.length,
+    active: snapshot.filter((t) => t.status === "pending" || t.status === "in_progress").length,
+    completed: snapshot.filter((t) => t.status === "completed").length
+  });
+};
+var todoWriteHandler = async (rawArgs, context) => {
+  const args = rawArgs;
+  const sessionId = args.session_id ?? context.sessionId;
+  if (!args.todos || !Array.isArray(args.todos)) {
+    return toolFailure("todo_write", "invalid_arguments", "todos array is required");
+  }
+  const existing = readTodos(sessionId);
+  const existingMap = new Map(existing.map((t) => [t.id, t]));
+  for (let i = 0; i < args.todos.length; i++) {
+    const input = args.todos[i];
+    const existingRecord = existingMap.get(input.id);
+    if (existingRecord) {
+      existingRecord.content = input.content;
+      existingRecord.status = input.status;
+      existingRecord.updatedAt = Date.now();
+    } else {
+      existing.push({
+        id: input.id,
+        content: input.content,
+        status: input.status,
+        order: i,
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+      });
+    }
+  }
+  writeTodos(existing, sessionId);
+  return toolSuccess("todo_write", {
+    total: existing.length,
+    updated: args.todos.length
+  });
+};
+
+// src/handlers/plans.ts
+var import_node_fs11 = require("node:fs");
+var import_node_path12 = require("node:path");
+init_config();
+function getPlansDir() {
+  const dir = (0, import_node_path12.join)(getConfigDirPath(), "plans");
+  if (!(0, import_node_fs11.existsSync)(dir)) {
+    (0, import_node_fs11.mkdirSync)(dir, { recursive: true });
+  }
+  return dir;
+}
+function getPlanFilePath(name) {
+  const safeName = name.replace(/[^a-z0-9-_.]/gi, "").toLowerCase();
+  return (0, import_node_path12.join)(getPlansDir(), `${safeName}.json`);
+}
+function readPlanFile(name) {
+  const filePath = getPlanFilePath(name);
+  if (!(0, import_node_fs11.existsSync)(filePath)) return null;
+  try {
+    return JSON.parse((0, import_node_fs11.readFileSync)(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writePlanFile(name, plan) {
+  (0, import_node_fs11.writeFileSync)(getPlanFilePath(name), JSON.stringify(plan, null, 2), "utf-8");
+}
+function deletePlanFile(name) {
+  const filePath = getPlanFilePath(name);
+  if (!(0, import_node_fs11.existsSync)(filePath)) return false;
+  try {
+    (0, import_node_fs11.writeFileSync)(filePath, JSON.stringify({ deleted: true }), "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function listPlanFiles() {
+  return (0, import_node_fs11.readdirSync)(getPlansDir()).filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, ""));
+}
+var planCreateHandler = async (rawArgs, _context) => {
+  const args = rawArgs;
+  if (!args.name?.trim() || !args.content?.trim()) {
+    return toolFailure("plan_create", "invalid_arguments", "name and content are required");
+  }
+  const name = args.name.trim().toLowerCase().replace(/[^a-z0-9-_.]/gi, "");
+  if (readPlanFile(name)) {
+    return toolFailure("plan_create", "exists", `Plan already exists: ${name}`);
+  }
+  writePlanFile(name, {
+    name,
+    title: args.title?.trim() ?? name,
+    content: args.content.trim(),
+    createdAt: Date.now(),
+    updatedAt: Date.now()
+  });
+  return toolSuccess("plan_create", { name, title: args.title?.trim() ?? name });
+};
+var planReadHandler = async (rawArgs, _context) => {
+  const args = rawArgs;
+  if (!args.name?.trim()) {
+    return toolFailure("plan_read", "invalid_arguments", "name is required");
+  }
+  const plan = readPlanFile(args.name.trim());
+  if (!plan) {
+    return toolFailure("plan_read", "not_found", `Plan not found: ${args.name}`);
+  }
+  return toolSuccess("plan_read", plan);
+};
+var planUpdateHandler = async (rawArgs, _context) => {
+  const args = rawArgs;
+  if (!args.name?.trim()) {
+    return toolFailure("plan_update", "invalid_arguments", "name is required");
+  }
+  const existing = readPlanFile(args.name.trim());
+  if (!existing) {
+    return toolFailure("plan_update", "not_found", `Plan not found: ${args.name}`);
+  }
+  writePlanFile(args.name.trim(), {
+    ...existing,
+    title: args.title?.trim() ?? existing.title,
+    content: args.content?.trim() ?? existing.content,
+    updatedAt: Date.now()
+  });
+  return toolSuccess("plan_update", { name: args.name.trim() });
+};
+var planEditHandler = async (rawArgs, _context) => {
+  const args = rawArgs;
+  if (!args.name?.trim()) {
+    return toolFailure("plan_edit", "invalid_arguments", "name is required");
+  }
+  const existing = readPlanFile(args.name.trim());
+  if (!existing) {
+    return toolFailure("plan_edit", "not_found", `Plan not found: ${args.name}`);
+  }
+  writePlanFile(args.name.trim(), {
+    ...existing,
+    content: existing.content + "\n\n## Edit Instructions\n\n" + (args.instructions?.trim() ?? ""),
+    updatedAt: Date.now()
+  });
+  return toolSuccess("plan_edit", { name: args.name.trim() });
+};
+var planDeleteHandler = async (rawArgs, _context) => {
+  const args = rawArgs;
+  if (!args.name?.trim()) {
+    return toolFailure("plan_delete", "invalid_arguments", "name is required");
+  }
+  deletePlanFile(args.name.trim());
+  return toolSuccess("plan_delete", { name: args.name.trim(), deleted: true });
+};
+var planListHandler = async (_rawArgs, _context) => {
+  const names = listPlanFiles();
+  const plans = names.map((name) => readPlanFile(name)).filter((p) => p !== null).map((p) => ({ name: p.name, title: p.title }));
+  return toolSuccess("plan_list", { plans, total: plans.length });
+};
+
+// src/handlers/workspace-tree.ts
+var import_node_fs12 = require("node:fs");
+var import_node_path13 = require("node:path");
+var EXCLUDED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "target",
+  ".next",
+  "out",
+  ".cache",
+  ".turbo",
+  "coverage",
+  ".nyc_output",
+  "__pycache__",
+  ".venv",
+  "venv",
+  ".history"
+]);
+var getWorkspaceTreeHandler = async (rawArgs, context) => {
+  const args = rawArgs;
+  if (!context.workspaceDir) {
+    return toolFailure("get_workspace_tree", "workspace_required", "No workspace directory set");
+  }
+  try {
+    const rootDir = context.workspaceDir;
+    const treeLines = buildTree(rootDir, rootDir, 0);
+    const fullText = treeLines.join("\n");
+    const totalLines = treeLines.length;
+    const startLine = args.start_line ?? 1;
+    const maxLines = args.max_lines ?? 500;
+    const endLine = Math.min(startLine + maxLines - 1, totalLines);
+    const paginatedText = treeLines.slice(startLine - 1, endLine).join("\n");
+    return toolSuccess("get_workspace_tree", {
+      treeText: paginatedText,
+      totalLines,
+      startLine,
+      endLine,
+      truncated: endLine < totalLines
+    });
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    return toolFailure("get_workspace_tree", "error", message);
+  }
+};
+function buildTree(rootDir, currentDir, depth) {
+  const lines = [];
+  const relPath = (0, import_node_path13.relative)(rootDir, currentDir);
+  if (depth === 0) {
+    lines.push((0, import_node_path13.relative)(rootDir, currentDir) || ".");
+  }
+  let entries;
+  try {
+    entries = (0, import_node_fs12.readdirSync)(currentDir);
+  } catch {
+    return lines;
+  }
+  const dirs = [];
+  const files = [];
+  for (const name of entries) {
+    if (name.startsWith(".") && depth === 0 && name === ".git") continue;
+    if (EXCLUDED_DIRS.has(name)) continue;
+    if (name.startsWith(".") && depth > 0) continue;
+    const fullPath = (0, import_node_path13.resolve)(currentDir, name);
+    try {
+      const stats = (0, import_node_fs12.statSync)(fullPath);
+      if (stats.isDirectory()) {
+        dirs.push(name);
+      } else {
+        files.push(name);
+      }
+    } catch {
+    }
+  }
+  dirs.sort();
+  files.sort();
+  const allEntries = [...dirs, ...files];
+  for (let i = 0; i < allEntries.length; i++) {
+    const name = allEntries[i];
+    const isLast = i === allEntries.length - 1;
+    const prefix = depth === 0 ? isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 " : "";
+    const childPrefix = depth === 0 ? isLast ? "    " : "\u2502   " : "";
+    const fullPath = (0, import_node_path13.resolve)(currentDir, name);
+    lines.push(`${prefix}${name}`);
+    try {
+      const stats = (0, import_node_fs12.statSync)(fullPath);
+      if (stats.isDirectory()) {
+        const childLines = buildTreeFromDepth(rootDir, fullPath, depth + 1, prefix || "", childPrefix);
+        lines.push(...childLines);
+      }
+    } catch {
+    }
+  }
+  return lines;
+}
+function buildTreeFromDepth(rootDir, currentDir, depth, parentPrefix, prefix) {
+  const lines = [];
+  let entries;
+  try {
+    entries = (0, import_node_fs12.readdirSync)(currentDir);
+  } catch {
+    return lines;
+  }
+  const dirs = [];
+  const files = [];
+  for (const name of entries) {
+    if (EXCLUDED_DIRS.has(name)) continue;
+    if (name.startsWith(".")) continue;
+    const fullPath = (0, import_node_path13.resolve)(currentDir, name);
+    try {
+      const stats = (0, import_node_fs12.statSync)(fullPath);
+      if (stats.isDirectory()) {
+        dirs.push(name);
+      } else {
+        files.push(name);
+      }
+    } catch {
+    }
+  }
+  dirs.sort();
+  files.sort();
+  const allEntries = [...dirs, ...files];
+  for (let i = 0; i < allEntries.length; i++) {
+    const name = allEntries[i];
+    const isLast = i === allEntries.length - 1;
+    const linePrefix = `${prefix}${isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 "}`;
+    const childPrefix = `${prefix}${isLast ? "    " : "\u2502   "}`;
+    lines.push(`${linePrefix}${name}`);
+    const fullPath = (0, import_node_path13.resolve)(currentDir, name);
+    try {
+      const stats = (0, import_node_fs12.statSync)(fullPath);
+      if (stats.isDirectory()) {
+        const childLines = buildTreeFromDepth(rootDir, fullPath, depth + 1, "", childPrefix);
+        lines.push(...childLines);
+      }
+    } catch {
+    }
+  }
+  return lines;
+}
+
+// src/handlers/ask-question.ts
+var import_node_readline = require("node:readline");
+var askQuestionHandler = async (rawArgs, _context) => {
+  const args = rawArgs;
+  if (!args.question?.trim()) {
+    return toolFailure("ask_question", "invalid_arguments", "question is required");
+  }
+  const rl = (0, import_node_readline.createInterface)({
+    input: process.stdin,
+    output: process.stderr
+  });
+  const answer = await new Promise((resolve12) => {
+    process.stderr.write(`
+\x1B[33m\u2753 ${args.question}\x1B[0m
+> `);
+    rl.once("line", (line) => {
+      resolve12(line.trim());
+    });
+  });
+  rl.close();
+  if (!answer) {
+    return toolFailure("ask_question", "no_answer", "User did not provide an answer");
+  }
+  return toolSuccess("ask_question", {
+    question: args.question,
+    answer
+  });
+};
+
+// src/handlers/spawn-subagent.ts
+var spawnAgentFunction = null;
+var spawnSubAgentHandler = async (rawArgs, _context) => {
+  const args = rawArgs;
+  if (!args.task?.trim()) {
+    return toolFailure("spawn_subagent", "invalid_arguments", "task is required");
+  }
+  if (!spawnAgentFunction) {
+    return toolFailure(
+      "spawn_subagent",
+      "not_available",
+      "Sub-agent spawning is not available in the current configuration."
+    );
+  }
+  try {
+    const result = await spawnAgentFunction(args.task, args.context, args.tools);
+    return toolSuccess("spawn_subagent", result);
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    return toolFailure("spawn_subagent", "execution_error", message);
+  }
+};
+
+// src/handlers/index.ts
+var AGENT_TOOL_DEFINITIONS = [
+  {
+    type: "function",
+    function: {
+      name: "list_dir",
+      description: "List files and directories under a path. Relative paths are resolved against the workspace root.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Relative or absolute path within the workspace." },
+          recursive: { type: "boolean", description: "Whether to list entries recursively.", default: false },
+          max_depth: { type: "integer", description: "Maximum recursion depth when recursive is true.", default: 1 },
+          show_hidden: { type: "boolean", description: "Whether to include dotfiles and dot-directories.", default: false }
+        },
+        required: ["path"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "read_file",
+      description: "Read a text file with line numbers and pagination. Relative paths are resolved against the workspace root.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Relative or absolute path to the file within the workspace." },
+          start_line: { type: "integer", description: "First line to read (1-based).", default: 1 },
+          max_lines: { type: "integer", description: "Maximum number of lines to return.", default: 500 },
+          respect_gitignore: { type: "boolean", description: "Whether to refuse reading paths ignored by .gitignore.", default: true }
+        },
+        required: ["path"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "write_file",
+      description: "Create a new text file. Fails if the file already exists. Use replace_file or edit_file to modify existing files.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Relative or absolute path to the new file within the workspace." },
+          content: { type: "string", description: "Full file content to write." },
+          create_parent_dirs: { type: "boolean", description: "Whether to create missing parent directories.", default: true }
+        },
+        required: ["path", "content"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "replace_file",
+      description: "Replace the entire contents of an existing text file. Use expected_sha256 from read_file to avoid overwriting concurrent changes.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Relative or absolute path to the file within the workspace." },
+          content: { type: "string", description: "Full replacement file content." },
+          expected_sha256: { type: "string", description: "SHA256 hash from read_file. Rejects the write if the file changed." },
+          create_backup: { type: "boolean", description: "Whether to save a backup copy under .history before writing.", default: false },
+          respect_gitignore: { type: "boolean", description: "Whether to refuse editing paths ignored by .gitignore.", default: true }
+        },
+        required: ["path", "content"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "edit_file",
+      description: "Apply a targeted search-and-replace edit to an existing text file. Prefer this over replace_file for small changes.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Relative or absolute path to the file within the workspace." },
+          old_string: { type: "string", description: "Exact text to replace. Must match uniquely unless replace_all is true." },
+          new_string: { type: "string", description: "Replacement text." },
+          expected_sha256: { type: "string", description: "SHA256 hash from read_file. Rejects the edit if the file changed." },
+          replace_all: { type: "boolean", description: "Whether to replace every occurrence of old_string.", default: false },
+          create_backup: { type: "boolean", description: "Whether to save a backup copy under .history before writing.", default: false },
+          respect_gitignore: { type: "boolean", description: "Whether to refuse editing paths ignored by .gitignore.", default: true }
+        },
+        required: ["path", "old_string", "new_string"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "replace_lines",
+      description: "Replace a range of lines in an existing text file by line number. Read the file with read_file first to see line numbers.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Relative or absolute path to the file within the workspace." },
+          start_line: { type: "integer", description: "First line to replace (1-based)." },
+          end_line: { type: "integer", description: "Last line to replace (inclusive, 1-based)." },
+          content: { type: "string", description: "Replacement content for the specified line range." },
+          expected_sha256: { type: "string", description: "SHA256 hash from read_file. Rejects the edit if the file changed." },
+          create_backup: { type: "boolean", description: "Whether to save a backup copy under .history before writing.", default: false },
+          respect_gitignore: { type: "boolean", description: "Whether to refuse editing paths ignored by .gitignore.", default: true }
+        },
+        required: ["path", "start_line", "end_line", "content"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "glob",
+      description: "Find files by glob pattern under a directory. Relative paths are resolved against the workspace root.",
+      parameters: {
+        type: "object",
+        properties: {
+          glob_pattern: { type: "string", description: "Glob pattern such as **/*.tsx or src/**/*.rs." },
+          target_directory: { type: "string", description: "Directory to search from. Defaults to the workspace root." },
+          head_limit: { type: "integer", description: "Maximum number of matching paths to return.", default: 100 },
+          respect_gitignore: { type: "boolean", description: "Whether to skip paths ignored by .gitignore.", default: true }
+        },
+        required: ["glob_pattern"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "grep",
+      description: "Search file contents with a regex pattern. Relative paths are resolved against the workspace root.",
+      parameters: {
+        type: "object",
+        properties: {
+          pattern: { type: "string", description: "Regular expression pattern to search for." },
+          path: { type: "string", description: "File or directory to search. Defaults to the workspace root." },
+          glob: { type: "string", description: "Optional glob filter to limit searched files." },
+          output_mode: { type: "string", enum: ["content", "files_with_matches", "count"], default: "content" },
+          case_insensitive: { type: "boolean", description: "Whether to ignore letter case while matching.", default: false },
+          context_before: { type: "integer", description: "Number of lines to include before each match." },
+          context_after: { type: "integer", description: "Number of lines to include after each match." },
+          context: { type: "integer", description: "Number of lines to include before and after each match." },
+          head_limit: { type: "integer", description: "Maximum number of results to return.", default: 200 },
+          offset: { type: "integer", description: "Number of results to skip in content mode.", default: 0 },
+          multiline: { type: "boolean", description: "Whether . should match newlines.", default: false },
+          respect_gitignore: { type: "boolean", description: "Whether to skip paths ignored by .gitignore.", default: true }
+        },
+        required: ["pattern"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "shell",
+      description: "Execute a shell command in the workspace. Use for builds, tests, git, and other CLI tasks.",
+      parameters: {
+        type: "object",
+        properties: {
+          command: { type: "string", description: "The shell command to execute." },
+          description: { type: "string", description: "Short human-readable description for display only." },
+          working_directory: { type: "string", description: "Directory to run the command in, relative to workspace root." },
+          block_until_ms: { type: "integer", description: "Max wait time in ms. Default 30000. Use 0 for background mode.", default: 3e4 }
+        },
+        required: ["command"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "await",
+      description: "Poll a background shell started with shell(block_until_ms=0) until it completes or times out.",
+      parameters: {
+        type: "object",
+        properties: {
+          shell_id: { type: "string", description: "The shell_id returned from a background shell invocation." },
+          block_until_ms: { type: "integer", description: "Max wait time in ms before returning current output.", default: 3e4 }
+        },
+        required: ["shell_id"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "list_shells",
+      description: "List background shell processes started by the agent.",
+      parameters: {
+        type: "object",
+        properties: {
+          status_filter: { type: "string", description: 'Filter by status. Default "running". Use "all" to include completed and failed shells.' }
+        },
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "kill_shell",
+      description: "Kill a running background shell process by shell_id.",
+      parameters: {
+        type: "object",
+        properties: {
+          shell_id: { type: "string", description: "The shell_id to terminate." }
+        },
+        required: ["shell_id"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "read_shell_logs",
+      description: "Read logs from a shell process in batches.",
+      parameters: {
+        type: "object",
+        properties: {
+          shell_id: { type: "string", description: "The shell_id to read logs from." },
+          stream: { type: "string", enum: ["stdout", "stderr"], default: "stdout" },
+          offset: { type: "integer", description: "Byte offset to start reading from.", default: 0 },
+          limit: { type: "integer", description: "Maximum bytes to return.", default: 4096 }
+        },
+        required: ["shell_id"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "web_search",
+      description: "Search the web for real-time information outside training data.",
+      parameters: {
+        type: "object",
+        properties: {
+          search_term: { type: "string", description: "The search term to look up on the web." },
+          max_results: { type: "integer", description: "Maximum number of search results to return.", default: 5 },
+          explanation: { type: "string", description: "One sentence explanation of why this search is being used." }
+        },
+        required: ["search_term"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "browse_page",
+      description: "Fetch a public web page and return readable Markdown content.",
+      parameters: {
+        type: "object",
+        properties: {
+          url: { type: "string", description: "The URL to fetch. Must be http or https." },
+          max_lines: { type: "integer", description: "Maximum number of lines to return.", default: 500 },
+          start_line: { type: "integer", description: "First line to read (1-based).", default: 1 },
+          explanation: { type: "string", description: "One sentence explanation of why this page is being fetched." }
+        },
+        required: ["url"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "todo_read",
+      description: "Read the current structured todo list for the session.",
+      parameters: {
+        type: "object",
+        properties: {
+          session_id: { type: "string", description: "Optional session ID." }
+        },
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "todo_write",
+      description: "Create and update a structured todo list for the session.",
+      parameters: {
+        type: "object",
+        properties: {
+          todos: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                id: { type: "string" },
+                content: { type: "string" },
+                status: { type: "string", enum: ["pending", "in_progress", "completed", "cancelled"] }
+              },
+              required: ["id", "content", "status"]
+            }
+          },
+          session_id: { type: "string", description: "Optional session ID." }
+        },
+        required: ["todos"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "get_workspace_tree",
+      description: "Display the workspace directory tree structure with depth recursion.",
+      parameters: {
+        type: "object",
+        properties: {
+          max_lines: { type: "integer", description: "Maximum number of lines to return.", default: 500 },
+          start_line: { type: "integer", description: "First line to return (1-based).", default: 1 }
+        },
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "spawn_subagent",
+      description: "Spawn a sub-agent to complete an independent sub-task.",
+      parameters: {
+        type: "object",
+        properties: {
+          task: { type: "string", description: "The task description for the sub-agent." },
+          context: { type: "string", description: "Optional additional context or constraints." },
+          tools: { type: "array", items: { type: "string" }, description: "Optional whitelist of tool names." }
+        },
+        required: ["task"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "ask_question",
+      description: "Ask the user a question when you need additional information to proceed.",
+      parameters: {
+        type: "object",
+        properties: {
+          question: { type: "string", description: "The question to ask the user." }
+        },
+        required: ["question"],
+        additionalProperties: false
+      }
+    }
+  }
+];
+var HANDLER_MAP = {
+  list_dir: listDirHandler,
+  read_file: readFileHandler,
+  write_file: writeFileHandler,
+  replace_file: replaceFileHandler,
+  edit_file: editFileHandler,
+  replace_lines: replaceLinesHandler,
+  glob: globHandler,
+  grep: grepHandler,
+  shell: shellHandler,
+  await: awaitShellHandler,
+  list_shells: listShellsHandler,
+  kill_shell: killShellHandler,
+  read_shell_logs: readShellLogsHandler,
+  web_search: webSearchHandler,
+  browse_page: browsePageHandler,
+  todo_read: todoReadHandler,
+  todo_write: todoWriteHandler,
+  get_workspace_tree: getWorkspaceTreeHandler,
+  spawn_subagent: spawnSubAgentHandler,
+  ask_question: askQuestionHandler,
+  plan_create: planCreateHandler,
+  plan_read: planReadHandler,
+  plan_update: planUpdateHandler,
+  plan_edit: planEditHandler,
+  plan_delete: planDeleteHandler,
+  plan_list: planListHandler
+};
+var ASK_QUESTION_TOOL_NAME = "ask_question";
+var AGENT_MODE_EXCLUDED_TOOL_NAMES = /* @__PURE__ */ new Set([
+  ASK_QUESTION_TOOL_NAME
+]);
+var ASK_MODE_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "list_dir",
+  "read_file",
+  "glob",
+  "grep",
+  "web_search",
+  "browse_page",
+  "todo_read",
+  "list_shells",
+  "read_shell_logs",
+  "get_workspace_tree"
+]);
+function getToolDefinitions(agentMode) {
+  if (agentMode === "ask") {
+    return AGENT_TOOL_DEFINITIONS.filter(
+      (t) => ASK_MODE_TOOL_NAMES.has(t.function.name)
+    );
+  }
+  if (agentMode === "plan") {
+    return AGENT_TOOL_DEFINITIONS;
+  }
+  return AGENT_TOOL_DEFINITIONS.filter(
+    (t) => !AGENT_MODE_EXCLUDED_TOOL_NAMES.has(t.function.name)
+  );
+}
+function getToolHandler(name) {
+  return HANDLER_MAP[name];
+}
+async function executeToolCall(name, rawArguments, context) {
+  const handler = getToolHandler(name);
+  if (!handler) {
+    return {
+      ok: false,
+      tool: name,
+      error: {
+        code: "unknown_tool",
+        message: `Unknown tool: ${name}`
+      }
+    };
+  }
+  let parsedArgs;
+  try {
+    parsedArgs = rawArguments.trim() ? JSON.parse(rawArguments) : {};
+  } catch {
+    return {
+      ok: false,
+      tool: name,
+      error: {
+        code: "invalid_arguments",
+        message: "Tool arguments must be valid JSON"
+      }
+    };
+  }
+  return handler(parsedArgs, context);
+}
+
+// src/agent/llm-stream.ts
+function chatCompletionsUrl(baseUrl) {
+  const trimmed = baseUrl.trim().replace(/\/+$/, "");
+  if (trimmed.endsWith("/v1")) {
+    return `${trimmed}/chat/completions`;
+  }
+  return `${trimmed}/v1/chat/completions`;
+}
+async function startLLMStream(options, callbacks) {
+  const url = chatCompletionsUrl(options.baseUrl);
+  const body = {
+    model: options.model,
+    messages: options.messages.map(formatMessage),
+    stream: true,
+    stream_options: { include_usage: true }
+  };
+  if (options.tools && options.tools.length > 0) {
+    body.tools = options.tools;
+    body.tool_choice = "auto";
+  }
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${options.apiKey}`,
+        "Content-Type": "application/json",
+        Accept: "text/event-stream"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => "");
+      throw new Error(`API error (${response.status}): ${errorBody || response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is empty");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const toolCallAccumulator = new ToolCallAccumulator({
+      onIdentified: (id, name) => {
+      }
+    });
+    let hasToolCalls = false;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      while (true) {
+        const lineBreak = buffer.indexOf("\n");
+        if (lineBreak === -1) break;
+        const line = buffer.slice(0, lineBreak).trim();
+        buffer = buffer.slice(lineBreak + 1);
+        processLine(line, callbacks, toolCallAccumulator);
+      }
+    }
+    if (buffer.trim()) {
+      processLine(buffer.trim(), callbacks, toolCallAccumulator);
+    }
+    const finalToolCalls = toolCallAccumulator.finalize();
+    for (const call of finalToolCalls) {
+      callbacks.onToolCall(call.id, call.name, call.arguments);
+    }
+    callbacks.onDone();
+  } catch (error2) {
+    if (error2 instanceof Error) {
+      callbacks.onError(error2);
+    } else {
+      callbacks.onError(new Error(String(error2)));
+    }
+  }
+}
+function processLine(line, callbacks, toolCalls) {
+  if (!line || line.startsWith(":")) return;
+  const payload = line.startsWith("data:") ? line.slice(5).trim() : line;
+  if (payload === "[DONE]") return;
+  let parsed;
+  try {
+    parsed = JSON.parse(payload);
+  } catch {
+    return;
+  }
+  const choices = parsed.choices;
+  const choice = choices?.[0];
+  const delta = choice?.delta;
+  if (delta) {
+    if (delta.reasoning_content) {
+      callbacks.onReasoning(delta.reasoning_content);
+    }
+    if (delta.content) {
+      callbacks.onContent(delta.content);
+    }
+    const toolCallDeltas = delta.tool_calls;
+    if (toolCallDeltas) {
+      for (const tcDelta of toolCallDeltas) {
+        const index = tcDelta.index;
+        const fn = tcDelta.function;
+        const id = tcDelta.id;
+        if (id) {
+          toolCalls.startToolCall(index, id, fn?.name);
+        } else if (fn?.arguments) {
+          toolCalls.appendArguments(index, fn.arguments);
+        }
+      }
+    }
+  }
+  const usage = parsed.usage;
+  if (usage?.prompt_tokens !== void 0) {
+    callbacks.onUsage({
+      promptTokens: usage.prompt_tokens,
+      completionTokens: usage.completion_tokens,
+      totalTokens: usage.total_tokens
+    });
+  }
+}
+var ToolCallAccumulator = class {
+  pending = /* @__PURE__ */ new Map();
+  finalized = false;
+  onIdentified;
+  constructor(opts) {
+    this.onIdentified = opts.onIdentified;
+  }
+  startToolCall(index, id, name) {
+    this.pending.set(index, { index, id, name, arguments: "" });
+  }
+  appendArguments(index, args) {
+    const existing = this.pending.get(index);
+    if (existing) {
+      existing.arguments += args;
+    }
+  }
+  finalize() {
+    if (this.finalized) return [];
+    this.finalized = true;
+    const calls = Array.from(this.pending.values()).sort((a, b) => a.index - b.index).map((c) => ({
+      id: c.id,
+      name: c.name,
+      arguments: c.arguments
+    }));
+    return calls;
+  }
+};
+function formatMessage(msg) {
+  const formatted = {
+    role: msg.role
+  };
+  if (msg.content !== void 0) {
+    formatted.content = msg.content;
+  }
+  if (msg.reasoning_content) {
+    formatted.reasoning_content = msg.reasoning_content;
+  }
+  if (msg.tool_calls) {
+    formatted.tool_calls = msg.tool_calls;
+  }
+  if (msg.tool_call_id) {
+    formatted.tool_call_id = msg.tool_call_id;
+  }
+  if (msg.name) {
+    formatted.name = msg.name;
+  }
+  return formatted;
+}
+
+// src/agent/runner.ts
+async function runAgentWithTools(input, toolContext, onEvent) {
+  let messages = [...input.messages];
+  let cumulativeUsage;
+  while (true) {
+    const turn = await runSingleAgentTurn(input, messages, onEvent);
+    if (turn.usage) {
+      cumulativeUsage = cumulativeUsage ? {
+        promptTokens: cumulativeUsage.promptTokens + turn.usage.promptTokens,
+        completionTokens: cumulativeUsage.completionTokens + turn.usage.completionTokens,
+        totalTokens: cumulativeUsage.totalTokens + turn.usage.totalTokens
+      } : turn.usage;
+    }
+    if (turn.toolCalls.length === 0) {
+      if (turn.content || turn.reasoningContent) {
+        messages = [
+          ...messages,
+          {
+            role: "assistant",
+            content: turn.content || void 0,
+            reasoning_content: turn.reasoningContent || void 0
+          }
+        ];
+      }
+      onEvent({ type: "done", taskId: input.taskId, usage: cumulativeUsage ?? turn.usage });
+      onEvent({ type: "status", taskId: input.taskId, status: "completed" });
+      return messages;
+    }
+    messages = await appendToolResults(messages, turn, toolContext, onEvent);
+  }
+}
+async function runSingleAgentTurn(input, messages, onEvent) {
+  return new Promise((resolve12, reject) => {
+    let content = "";
+    let reasoningContent = "";
+    const toolCalls = [];
+    let turnUsage;
+    startLLMStream(
+      {
+        baseUrl: input.baseUrl,
+        apiKey: input.apiKey,
+        model: input.model,
+        messages,
+        tools: getToolDefinitions(input.agentMode)
+      },
+      {
+        onContent: (delta) => {
+          content += delta;
+          onEvent({ type: "content_delta", taskId: input.taskId, delta });
+        },
+        onReasoning: (delta) => {
+          reasoningContent += delta;
+          onEvent({ type: "thinking_delta", taskId: input.taskId, delta });
+        },
+        onToolCall: (id, name, args) => {
+          toolCalls.push({ id, name, arguments: args });
+          onEvent({ type: "tool_call_pending", taskId: input.taskId, toolCallId: id, name });
+        },
+        onUsage: (usage) => {
+          turnUsage = usage;
+        },
+        onDone: () => {
+          if (toolCalls.length > 0) {
+            for (const call of toolCalls) {
+              let parsedInput;
+              try {
+                parsedInput = call.arguments.trim() ? JSON.parse(call.arguments) : {};
+              } catch {
+                parsedInput = {};
+              }
+              onEvent({
+                type: "tool_call_started",
+                taskId: input.taskId,
+                toolCallId: call.id,
+                name: call.name,
+                input: parsedInput
+              });
+            }
+          }
+          resolve12({ toolCalls, content, reasoningContent, usage: turnUsage });
+        },
+        onError: (error2) => {
+          reject(error2);
+        }
+      }
+    );
+  });
+}
+async function appendToolResults(messages, turn, context, onEvent) {
+  const assistantMessage = {
+    role: "assistant",
+    content: turn.content || void 0,
+    reasoning_content: turn.reasoningContent || void 0,
+    tool_calls: turn.toolCalls.map((tc) => ({
+      id: tc.id,
+      type: "function",
+      function: { name: tc.name, arguments: tc.arguments }
+    }))
+  };
+  const nextMessages = [...messages, assistantMessage];
+  const results = await Promise.all(
+    turn.toolCalls.map(async (call) => {
+      try {
+        const result = await executeToolCall(call.name, call.arguments, context);
+        if (result.ok) {
+          onEvent({
+            type: "tool_call_finished",
+            taskId: context.taskId ?? "",
+            toolCallId: call.id,
+            output: result.data
+          });
+        } else {
+          onEvent({
+            type: "tool_call_finished",
+            taskId: context.taskId ?? "",
+            toolCallId: call.id,
+            errorText: result.error?.message
+          });
+        }
+        return { id: call.id, result };
+      } catch (error2) {
+        const errorText = error2 instanceof Error ? error2.message : String(error2);
+        onEvent({
+          type: "tool_call_finished",
+          taskId: context.taskId ?? "",
+          toolCallId: call.id,
+          errorText
+        });
+        return {
+          id: call.id,
+          result: {
+            ok: false,
+            tool: call.name,
+            error: { code: "execution_error", message: errorText }
+          }
+        };
+      }
+    })
+  );
+  for (const { id, result } of results) {
+    const content = result.ok ? JSON.stringify(result.data, null, 2) : JSON.stringify({ error: result.error }, null, 2);
+    nextMessages.push({
+      role: "tool",
+      tool_call_id: id,
+      content
+    });
+  }
+  return nextMessages;
+}
+
+// src/agent/environment/index.ts
+var import_node_os2 = require("node:os");
+var import_node_child_process2 = require("node:child_process");
+var import_node_fs13 = require("node:fs");
+var import_node_path14 = require("node:path");
+function resolveAgentEnvironment(workspaceDir) {
+  const os = `${(0, import_node_os2.platform)()} (${(0, import_node_os2.release)()})`;
+  const shell = resolveShell();
+  const isGitRepository = workspaceDir ? checkIsGitRepository(workspaceDir) : false;
+  const today = (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    timeZone: "UTC"
+  });
+  let agentsMd = null;
+  if (workspaceDir) {
+    const agentsMdPath = (0, import_node_path14.resolve)(workspaceDir, "AGENTS.md");
+    if ((0, import_node_fs13.existsSync)(agentsMdPath)) {
+      const content = (0, import_node_fs13.readFileSync)(agentsMdPath, "utf-8");
+      agentsMd = {
+        path: agentsMdPath,
+        content: content.length > 4e3 ? content.slice(0, 4e3) + "\n... [truncated]" : content,
+        truncated: content.length > 4e3
+      };
+    }
+  }
+  return {
+    workspaceDir,
+    os,
+    shell,
+    isGitRepository,
+    today,
+    agentsMd,
+    enabledSystemSkills: []
+  };
+}
+function resolveShell() {
+  const p = (0, import_node_os2.platform)();
+  if (p === "win32") {
+    return process.env.COMSPEC || "cmd.exe";
+  }
+  return process.env.SHELL || "/bin/sh";
+}
+function checkIsGitRepository(dir) {
+  try {
+    (0, import_node_child_process2.execSync)("git rev-parse --is-inside-work-tree", {
+      cwd: dir,
+      stdio: "pipe",
+      timeout: 3e3
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function buildSystemPrompt(env) {
+  const workspaceLine = env.workspaceDir ?? "not selected";
+  const gitLine = env.isGitRepository ? "yes" : env.workspaceDir ? "no" : "unknown";
+  const lines = [
+    "You are Coder, a helpful terminal AI assistant.",
+    "",
+    "## Environment",
+    `- Workspace: ${workspaceLine}`,
+    `- OS: ${env.os}`,
+    `- Shell: ${env.shell}`,
+    `- Git repository: ${gitLine}`,
+    `- Date: ${env.today}`,
+    "",
+    "## Available Tools",
+    "You have access to all standard tools: file operations, shell commands, web search, skills, and more.",
+    "",
+    "## Guidelines",
+    "- Always read files before editing them.",
+    "- Prefer targeted edits over full file replacements.",
+    "- Use shell commands only for builds, tests, git, and non-interactive CLI tasks.",
+    "- When a task requires multiple steps, create a plan first using todo_write.",
+    "- After completing a task, summarize what was done.",
+    "- Use ask_question when you need clarification from the user.",
+    ""
+  ];
+  if (env.agentsMd) {
+    lines.push("## Project Instructions (AGENTS.md)");
+    lines.push("");
+    lines.push(env.agentsMd.content);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/agent/session.ts
+init_config();
+
+// src/ui/index.ts
+var import_node_tty = require("node:tty");
+var stdoutIsTTY = (0, import_node_tty.isatty)(process.stdout.fd);
+var stderrIsTTY = (0, import_node_tty.isatty)(process.stderr.fd);
+var colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  italic: "\x1B[3m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m"
+};
+function colorize(text, color) {
+  if (!stdoutIsTTY) return text;
+  return `${colors[color]}${text}${colors.reset}`;
+}
+function dim(text) {
+  return colorize(text, "dim");
+}
+function bold(text) {
+  if (!stdoutIsTTY) return text;
+  return `${colors.bold}${text}${colors.reset}`;
+}
+function error(text) {
+  return colorize(text, "red");
+}
+function success(text) {
+  return colorize(text, "green");
+}
+function warning(text) {
+  return colorize(text, "yellow");
+}
+function info(text) {
+  return colorize(text, "cyan");
+}
+function writeStream(text) {
+  process.stdout.write(text);
+}
+function writeLine(text) {
+  process.stdout.write(text + "\n");
+}
+function writeError(text) {
+  process.stderr.write(text + "\n");
+}
+
+// src/agent/session.ts
+async function runAgentSession(prompt, options) {
+  const config = loadConfig();
+  const workspaceDir = options.workspaceDir || null;
+  const providerId = options.provider ?? config.activeProvider;
+  const resolvedConfig = resolveProviderConfig(config, providerId);
+  const apiKey = resolveApiKey(resolvedConfig);
+  const modelId = options.model ?? config.lastModel;
+  let messages;
+  if (options.existingMessages && options.existingMessages.length > 0) {
+    messages = [...options.existingMessages, { role: "user", content: prompt }];
+  } else {
+    const env = resolveAgentEnvironment(workspaceDir);
+    const systemPrompt = buildSystemPrompt(env);
+    messages = [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: prompt }
+    ];
+  }
+  const taskId = `task-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const isStreaming = options.stream !== false;
+  let currentContent = "";
+  let currentThinking = "";
+  let hasContent = false;
+  const toolContext = {
+    workspaceDir,
+    sessionId: taskId,
+    taskId,
+    agentMode: options.agentMode
+  };
+  if (!isStreaming) {
+    writeLine(`${info("\u2139")} Running agent in ${bold(options.agentMode)} mode...
+`);
+  }
+  try {
+    const finalMessages = await runAgentWithTools(
+      {
+        taskId,
+        baseUrl: resolvedConfig.baseUrl,
+        apiKey,
+        apiKeySource: resolvedConfig.apiKeySource,
+        apiKeyEnvVar: resolvedConfig.apiKeyEnvVar,
+        model: modelId,
+        messages,
+        agentMode: options.agentMode
+      },
+      toolContext,
+      (event) => {
+        switch (event.type) {
+          case "thinking_delta": {
+            currentThinking += event.delta;
+            if (isStreaming && !hasContent) {
+              writeStream(dim(event.delta));
+            }
+            break;
+          }
+          case "content_delta": {
+            if (!hasContent && currentThinking && isStreaming) {
+              writeLine("");
+              hasContent = true;
+            }
+            hasContent = true;
+            currentContent += event.delta;
+            if (isStreaming) {
+              writeStream(event.delta);
+            }
+            break;
+          }
+          case "tool_call_started": {
+            if (isStreaming) {
+              if (hasContent || currentThinking) {
+                writeLine("");
+              }
+              writeLine(`${dim("\u{1F527}")} ${bold(event.name)}${dim("...")}`);
+            }
+            break;
+          }
+          case "tool_call_finished": {
+            if (event.errorText) {
+              writeLine(`  ${error("\u2717")} ${dim(event.errorText.slice(0, 200))}`);
+            } else if (isStreaming) {
+              writeLine(`  ${success("\u2713")} ${dim("done")}`);
+            }
+            break;
+          }
+          case "status": {
+            if (event.status === "completed") {
+              if (isStreaming) {
+                writeLine("");
+                writeLine(success(`
+\u2713 Task completed`));
+              } else {
+                writeLine(success(`\u2713 Task completed`));
+                if (currentContent) {
+                  writeLine("\n" + currentContent);
+                }
+              }
+            } else if (event.status === "failed") {
+              writeLine(error(`
+\u2717 Task failed`));
+            } else if (event.status === "cancelled") {
+              writeLine(warning(`
+\u26A0 Task cancelled`));
+            }
+            break;
+          }
+          case "done": {
+            if (event.usage && config.showUsage) {
+              writeLine(dim(
+                `  Tokens: ${event.usage.promptTokens}\u2191 ${event.usage.completionTokens}\u2193 ${event.usage.totalTokens}\u2211`
+              ));
+            }
+            break;
+          }
+          case "error": {
+            writeLine(error(`
+\u2717 Error: ${event.message}`));
+            break;
+          }
+        }
+      }
+    );
+    return finalMessages;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    writeError(error(`Fatal error: ${message}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/run.ts
+async function runCommand(prompt, options) {
+  await runAgentSession(prompt, {
+    ...options,
+    agentMode: "agent",
+    workspaceDir: options.workspace ?? process.cwd(),
+    interactive: false
+  });
+}
+
+// src/commands/ask.ts
+async function askCommand(prompt, options) {
+  await runAgentSession(prompt, {
+    ...options,
+    agentMode: "ask",
+    workspaceDir: options.workspace ?? process.cwd(),
+    interactive: false
+  });
+}
+
+// src/commands/plan.ts
+async function planCommand(prompt, options) {
+  await runAgentSession(prompt, {
+    ...options,
+    agentMode: "plan",
+    workspaceDir: options.workspace ?? process.cwd(),
+    interactive: false
+  });
+}
+
+// src/commands/repl.ts
+var import_node_readline2 = require("node:readline");
+init_config();
+async function replCommand(options) {
+  const config = loadConfig();
+  const workspaceDir = options.workspace ?? process.cwd();
+  writeLine("");
+  writeLine(bold("Coder CLI \u2014 Interactive REPL"));
+  writeLine(dim("\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\u2500\u2500"));
+  writeLine(dim(`  Model: ${config.lastModel || "not set"}`));
+  writeLine(dim(`  Provider: ${config.activeProvider}`));
+  writeLine(dim(`  Workspace: ${workspaceDir}`));
+  writeLine(dim(`  Type 'exit' or Ctrl+C to quit`));
+  writeLine(dim("\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\u2500\u2500"));
+  writeLine("");
+  let conversationMessages;
+  const rl = (0, import_node_readline2.createInterface)({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: `${bold("coder")}> `,
+    terminal: true
+  });
+  rl.prompt();
+  rl.on("line", async (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      rl.prompt();
+      return;
+    }
+    if (trimmed === "exit" || trimmed === "quit") {
+      rl.close();
+      return;
+    }
+    if (trimmed === "clear") {
+      console.clear();
+      rl.prompt();
+      return;
+    }
+    if (trimmed === "help") {
+      writeLine(bold("\nREPL Commands:"));
+      writeLine("  <prompt>          Ask the agent anything");
+      writeLine("  exit / quit       Exit REPL");
+      writeLine("  clear             Clear screen");
+      writeLine("  help              Show this help");
+      writeLine("  model <id>        Switch model");
+      writeLine("");
+      rl.prompt();
+      return;
+    }
+    if (trimmed.startsWith("model ")) {
+      const modelId = trimmed.slice(6).trim();
+      if (modelId) {
+        config.lastModel = modelId;
+        const { saveConfig: saveConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+        saveConfig2(config);
+        writeLine(info(`Model set to: ${modelId}`));
+      }
+      rl.prompt();
+      return;
+    }
+    rl.pause();
+    try {
+      conversationMessages = await runAgentSession(trimmed, {
+        agentMode: "agent",
+        workspaceDir,
+        interactive: true,
+        model: options.model,
+        provider: options.provider,
+        existingMessages: conversationMessages
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      writeError(error(`Error: ${message}`));
+    }
+    writeLine("");
+    rl.prompt();
+    rl.resume();
+  });
+  rl.on("close", () => {
+    writeLine(dim("\nGoodbye! \u{1F44B}"));
+    process.exit(0);
+  });
+  rl.on("SIGINT", () => {
+    rl.close();
+  });
+}
+
+// src/commands/init.ts
+init_config();
+var import_node_readline3 = require("node:readline");
+async function initCommand() {
+  writeLine(bold("\nCoder CLI \u2014 Initialization"));
+  writeLine(dim("\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\u2500\u2500"));
+  writeLine(`Config directory: ${getConfigDirPath()}`);
+  writeLine("");
+  const config = loadConfig();
+  writeLine(info("Select your AI provider:"));
+  const providers = ["deepseek", "glm", "agnes", "nvidia", "minimax", "custom"];
+  for (let i = 0; i < providers.length; i++) {
+    writeLine(`  ${i + 1}. ${providers[i]}`);
+  }
+  writeLine("");
+  const providerIndex = await askQuestion("Provider number [1]: ");
+  const providerChoice = parseInt(providerIndex || "1", 10);
+  const selectedProvider = providers[Math.max(0, Math.min(providerChoice - 1, providers.length - 1))];
+  config.activeProvider = selectedProvider;
+  writeLine(`  Selected: ${bold(selectedProvider)}`);
+  writeLine("");
+  const providerSettings = config.providers[selectedProvider];
+  const envVar = providerSettings.apiKeyEnvVar;
+  writeLine(info(`API Key Configuration for "${selectedProvider}":`));
+  writeLine(`  You can set the ${bold(envVar)} environment variable,`);
+  writeLine(`  or enter the key directly (stored in config file).`);
+  writeLine("");
+  const source = await askQuestion("Use environment variable? [Y/n]: ");
+  const useEnv = source.toLowerCase() !== "n";
+  if (useEnv) {
+    providerSettings.apiKeySource = "env";
+    writeLine(`  Using ${bold(envVar)} environment variable.`);
+    writeLine(`  Make sure to set it: export ${envVar}=<your-api-key>`);
+  } else {
+    providerSettings.apiKeySource = "manual";
+    const key = await askQuestion("Enter API key: ");
+    if (key.trim()) {
+      providerSettings.apiKey = key.trim();
+      writeLine("  API key saved to config.");
+    } else {
+      writeLine(`  ${error("No key entered. Set it later with: coder config")}`);
+    }
+  }
+  writeLine("");
+  if (selectedProvider === "custom") {
+    const baseUrl = await askQuestion("Custom API base URL: ");
+    if (baseUrl.trim()) {
+      providerSettings.customBaseUrl = baseUrl.trim();
+    }
+  } else {
+    const customUrl = await askQuestion(`Custom base URL (leave empty for default): `);
+    if (customUrl.trim()) {
+      providerSettings.customBaseUrl = customUrl.trim();
+    }
+    writeLine("");
+  }
+  saveConfig(config);
+  writeLine(success("\n\u2713 Configuration saved!"));
+  writeLine(`  Config file: ${getConfigFilePathExplicit()}`);
+  writeLine("");
+  writeLine(info("Quick start:"));
+  writeLine('  coder "What is in this directory?"');
+  writeLine('  coder ask "Explain this code"');
+  writeLine("  coder repl");
+  writeLine("");
+}
+function askQuestion(query) {
+  const rl = (0, import_node_readline3.createInterface)({
+    input: process.stdin,
+    output: process.stderr
+  });
+  return new Promise((resolve12) => {
+    rl.question(query, (answer) => {
+      rl.close();
+      resolve12(answer);
+    });
+  });
+}
+
+// src/commands/config.ts
+init_config();
+var PROVIDER_IDS2 = ["deepseek", "glm", "agnes", "nvidia", "minimax", "custom"];
+async function configCommand(key, value) {
+  const config = loadConfig();
+  if (!key) {
+    showConfig(config);
+    return;
+  }
+  if (key && value !== void 0) {
+    await setConfigValue(config, key, value);
+    return;
+  }
+  showConfigValue(config, key);
+}
+function showConfig(config) {
+  writeLine(bold("\nCoder CLI Configuration"));
+  writeLine(dim("\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\u2500\u2500"));
+  writeLine(`Config directory: ${getConfigDirPath()}`);
+  writeLine(`Config file: ${getConfigFilePathExplicit()}`);
+  writeLine("");
+  writeLine(bold("Active Settings:"));
+  writeLine(`  Active provider: ${config.activeProvider}`);
+  writeLine(`  Last model:      ${config.lastModel}`);
+  writeLine(`  Show usage:      ${config.showUsage}`);
+  writeLine("");
+  for (const providerId of PROVIDER_IDS2) {
+    const p = config.providers[providerId];
+    writeLine(bold(`Provider: ${providerId}`));
+    writeLine(`  API Key Source: ${p.apiKeySource}`);
+    writeLine(`  API Key Env Var: ${p.apiKeyEnvVar}`);
+    writeLine(`  API Key (stored): ${p.apiKey ? "***" : "(not set)"}`);
+    writeLine(`  Custom Base URL: ${p.customBaseUrl || "(default)"}`);
+    writeLine("");
+  }
+  writeLine(dim("To change a value: coder config <key> <value>"));
+  writeLine(dim("Examples:"));
+  writeLine(dim('  coder config activeProvider "deepseek"'));
+  writeLine(dim('  coder config lastModel "deepseek-v4-flash"'));
+  writeLine(dim('  coder config providers.deepseek.apiKeySource "env"'));
+  writeLine("");
+}
+function showConfigValue(config, key) {
+  const value = getNestedValue(config, key);
+  if (value === void 0) {
+    writeLine(warning(`Config key not found: ${key}`));
+    return;
+  }
+  writeLine(String(value));
+}
+async function setConfigValue(config, key, value) {
+  setNestedValue(config, key, parseValue(value));
+  saveConfig(config);
+  writeLine(info(`Config updated: ${key} = ${value}`));
+}
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function setNestedValue(obj, path, value) {
+  const parts = path.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (!(parts[i] in current)) {
+      current[parts[i]] = {};
+    }
+    current = current[parts[i]];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+function parseValue(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  const num = Number(value);
+  if (!isNaN(num) && value.trim() !== "") return num;
+  return value;
+}
+
+// src/commands/common.ts
+var _globalOptions = {};
+function setGlobalOptions(opts) {
+  _globalOptions = opts;
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+async function main() {
+  const rawArgs = process.argv.slice(2);
+  if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
+    printHelp();
+    return;
+  }
+  if (rawArgs.includes("--version") || rawArgs.includes("-V")) {
+    console.log(VERSION);
+    return;
+  }
+  if (rawArgs.length === 0) {
+    await replCommand({});
+    return;
+  }
+  const globalOpts = extractGlobalOptions(rawArgs);
+  setGlobalOptions(globalOpts);
+  const firstNonFlag = rawArgs.find((a) => !a.startsWith("-"));
+  const knownSubcommands = {
+    ask: async (args, opts) => {
+      await askCommand(args.join(" "), opts);
+    },
+    plan: async (args, opts) => {
+      await planCommand(args.join(" "), opts);
+    },
+    repl: async () => {
+      await replCommand(globalOpts);
+    },
+    init: async () => {
+      await initCommand();
+    },
+    config: async (args) => {
+      await configCommand(args[0], args[1]);
+    }
+  };
+  if (firstNonFlag && knownSubcommands[firstNonFlag]) {
+    const cmdArgs = rawArgs.slice(rawArgs.indexOf(firstNonFlag) + 1).filter((a) => !a.startsWith("-"));
+    await knownSubcommands[firstNonFlag](cmdArgs, globalOpts);
+    return;
+  }
+  const promptParts = rawArgs.filter((a) => !a.startsWith("-"));
+  const prompt = promptParts.join(" ");
+  if (!prompt.trim()) {
+    await replCommand(globalOpts);
+    return;
+  }
+  await runCommand(prompt, globalOpts);
+}
+function extractGlobalOptions(args) {
+  const opts = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-m" || arg === "--model") {
+      opts.model = args[++i] ?? "";
+    } else if (arg === "-p" || arg === "--provider") {
+      opts.provider = args[++i] ?? "";
+    } else if (arg === "-w" || arg === "--workspace") {
+      opts.workspace = args[++i] ?? "";
+    } else if (arg === "-y" || arg === "--yes") {
+      opts.yes = true;
+    } else if (arg === "--no-stream") {
+      opts.stream = false;
+    } else if (arg === "--stream") {
+      opts.stream = true;
+    }
+  }
+  return opts;
+}
+function printHelp() {
+  console.log(`
+Usage: coder [options] [prompt...]
+
+Coder CLI \u2014 AI-powered coding assistant in the terminal
+
+Options:
+  -V, --version              output the version number
+  -m, --model <model>        Model ID to use
+  -p, --provider <provider>  Provider ID (deepseek, glm, agnes, nvidia, minimax, custom)
+  -w, --workspace <path>     Workspace directory
+  -y, --yes                  Auto-confirm prompts (unattended mode)
+  --no-stream                Disable streaming output
+  -h, --help                 display help for command
+
+Commands:
+  ask [prompt...]            Ask a question (read-only mode)
+  plan [prompt...]           Create or work on a plan
+  repl                       Start interactive REPL session
+  init                       Initialize Coder CLI configuration
+  config [key] [value]       View or edit configuration
+`);
+}
+main().catch((err) => {
+  const message = err instanceof Error ? err.message : String(err);
+  writeError(error(`Fatal: ${message}`));
+  process.exit(1);
+});
+//# sourceMappingURL=index.cjs.map