@wanghuimvp/axon 0.4.2 → 0.5.0

package/dist/cli.js

@@ -1,1266 +0,0 @@
-#!/usr/bin/env node
-
-// src/cli.ts
-import { Command } from "commander";
-
-// src/version.ts
-var VERSION = "0.0.1";
-
-// src/config/config.ts
-import { readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-var DEFAULT_MODELS = {
-  anthropic: "claude-opus-4-8",
-  openai: "gpt-4.1",
-  gemini: "gemini-2.5-pro"
-};
-var DEFAULTS = {
-  provider: "anthropic",
-  providers: {
-    anthropic: { apiKey: "env:ANTHROPIC_API_KEY" },
-    openai: { apiKey: "env:OPENAI_API_KEY" },
-    gemini: { apiKey: "env:GEMINI_API_KEY" }
-  }
-};
-var ENV_VARS = {
-  anthropic: "ANTHROPIC_API_KEY",
-  openai: "OPENAI_API_KEY",
-  gemini: "GEMINI_API_KEY"
-};
-function detectProvider(fileCfg) {
-  for (const name of ["anthropic", "openai", "gemini"]) {
-    const literal = fileCfg.providers?.[name]?.apiKey;
-    const hasLiteral = typeof literal === "string" && !literal.startsWith("env:") && literal.trim().length > 0;
-    const hasEnv = (process.env[ENV_VARS[name]] ?? "").trim().length > 0;
-    if (hasLiteral || hasEnv) return name;
-  }
-  return "anthropic";
-}
-function resolveModel(cfg) {
-  const model = cfg.model ?? cfg.providers[cfg.provider]?.model ?? DEFAULT_MODELS[cfg.provider];
-  if (!model) {
-    throw new Error(`No model configured for provider "${cfg.provider}". Set "model" in ~/.axon/config.json or pass --model.`);
-  }
-  return model;
-}
-function resolveEnvRefs(cfg) {
-  const providers = {};
-  for (const [name, p] of Object.entries(cfg.providers)) {
-    const apiKey = p.apiKey?.startsWith("env:") ? process.env[p.apiKey.slice(4)] : p.apiKey;
-    providers[name] = { ...p, apiKey };
-  }
-  return { ...cfg, providers };
-}
-function loadConfig() {
-  const path = join(homedir(), ".axon", "config.json");
-  let fileCfg = {};
-  try {
-    fileCfg = JSON.parse(readFileSync(path, "utf8"));
-  } catch {
-  }
-  const merged = {
-    provider: fileCfg.provider ?? detectProvider(fileCfg),
-    model: fileCfg.model,
-    providers: { ...DEFAULTS.providers, ...fileCfg.providers ?? {} }
-  };
-  return resolveEnvRefs(merged);
-}
-
-// src/config/configFile.ts
-import { readFileSync as readFileSync2, writeFileSync, mkdirSync, chmodSync } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { join as join2, dirname } from "node:path";
-function configPath() {
-  return join2(homedir2(), ".axon", "config.json");
-}
-function readConfigFile() {
-  try {
-    return JSON.parse(readFileSync2(configPath(), "utf8"));
-  } catch {
-    return {};
-  }
-}
-function setConfigValue(key, value) {
-  const cfg = readConfigFile();
-  if (key === "provider" || key === "model") {
-    cfg[key] = value;
-  } else if (key.includes(".")) {
-    const [provider, field] = key.split(".", 2);
-    const ALLOWED = /* @__PURE__ */ new Set(["baseUrl", "model"]);
-    if (!ALLOWED.has(field)) {
-      throw new Error(`Cannot set "${field}" via config. Set API keys via the provider's env var (e.g. ANTHROPIC_API_KEY); only baseUrl and model are settable here.`);
-    }
-    const providers = cfg.providers ??= {};
-    (providers[provider] ??= {})[field] = value;
-  } else {
-    throw new Error(`Unknown config key "${key}". Use "provider", "model", or "<provider>.<baseUrl|model>".`);
-  }
-  const path = configPath();
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, JSON.stringify(cfg, null, 2) + "\n");
-}
-function setApiKey(provider, key) {
-  const cfg = readConfigFile();
-  const providers = cfg.providers ??= {};
-  (providers[provider] ??= {}).apiKey = key;
-  const path = configPath();
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, JSON.stringify(cfg, null, 2) + "\n", { mode: 384 });
-  try {
-    chmodSync(path, 384);
-  } catch {
-  }
-}
-
-// src/providers/registry.ts
-import Anthropic from "@anthropic-ai/sdk";
-import OpenAI from "openai";
-import { GoogleGenAI } from "@google/genai";
-
-// src/providers/anthropic.ts
-function mapStop(reason) {
-  if (reason === "tool_use") return "tool_use";
-  if (reason === "max_tokens") return "max_tokens";
-  return "end";
-}
-function blockToAnthropic(b) {
-  if (b.type === "text") return { type: "text", text: b.text };
-  return { type: "tool_use", id: b.id, name: b.name, input: b.args };
-}
-function toAnthropicMessages(messages) {
-  const out = [];
-  let i = 0;
-  while (i < messages.length) {
-    const m = messages[i];
-    if (m.role === "tool") {
-      const results = [];
-      while (i < messages.length && messages[i].role === "tool") {
-        const t = messages[i];
-        results.push({ type: "tool_result", tool_use_id: t.toolCallId, content: t.content });
-        i++;
-      }
-      out.push({ role: "user", content: results });
-    } else {
-      out.push({ role: m.role, content: m.content.map(blockToAnthropic) });
-      i++;
-    }
-  }
-  return out;
-}
-function toAnthropicTool(t) {
-  return { name: t.name, description: t.description, input_schema: t.parameters };
-}
-var AnthropicProvider = class {
-  constructor(deps) {
-    this.deps = deps;
-  }
-  async *stream(req) {
-    const stream = await this.deps.client.messages.create({
-      model: this.deps.model,
-      max_tokens: 4096,
-      stream: true,
-      system: req.system,
-      messages: toAnthropicMessages(req.messages),
-      tools: req.tools.map(toAnthropicTool)
-    });
-    const toolBlocks = /* @__PURE__ */ new Map();
-    let stopReason = "end";
-    for await (const ev of stream) {
-      switch (ev.type) {
-        case "content_block_start":
-          if (ev.content_block?.type === "tool_use") {
-            toolBlocks.set(ev.index, { id: ev.content_block.id, name: ev.content_block.name, json: "" });
-          }
-          break;
-        case "content_block_delta":
-          if (ev.delta?.type === "text_delta") {
-            yield { type: "text_delta", text: ev.delta.text };
-          } else if (ev.delta?.type === "input_json_delta") {
-            const t = toolBlocks.get(ev.index);
-            if (t) t.json += ev.delta.partial_json;
-          }
-          break;
-        case "content_block_stop": {
-          const t = toolBlocks.get(ev.index);
-          if (t) {
-            let args;
-            try {
-              args = t.json.trim() ? JSON.parse(t.json) : {};
-            } catch (err) {
-              throw new Error(`Tool "${t.name}" (id=${t.id}): invalid tool-call JSON: ${JSON.stringify(t.json)}`, { cause: err });
-            }
-            yield { type: "tool_call", id: t.id, name: t.name, args };
-            toolBlocks.delete(ev.index);
-          }
-          break;
-        }
-        case "message_delta":
-          stopReason = mapStop(ev.delta?.stop_reason);
-          break;
-        case "message_stop":
-          yield { type: "done", stopReason };
-          break;
-      }
-    }
-  }
-};
-
-// src/providers/openai.ts
-function textOf(blocks) {
-  return blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
-}
-function toOpenAIMessages(system, messages) {
-  const out = [{ role: "system", content: system }];
-  for (const m of messages) {
-    if (m.role === "tool") {
-      out.push({ role: "tool", tool_call_id: m.toolCallId, content: m.content });
-      continue;
-    }
-    if (m.role === "user") {
-      out.push({ role: "user", content: textOf(m.content) });
-      continue;
-    }
-    const toolCalls = m.content.filter((b) => b.type === "tool_call").map((b) => {
-      const t = b;
-      return { id: t.id, type: "function", function: { name: t.name, arguments: JSON.stringify(t.args ?? {}) } };
-    });
-    const msg = { role: "assistant", content: textOf(m.content) };
-    if (toolCalls.length) msg.tool_calls = toolCalls;
-    out.push(msg);
-  }
-  return out;
-}
-function toOpenAITools(tools) {
-  if (!tools.length) return void 0;
-  return tools.map((t) => ({ type: "function", function: { name: t.name, description: t.description, parameters: t.parameters } }));
-}
-var OpenAIProvider = class {
-  constructor(deps) {
-    this.deps = deps;
-  }
-  callCounter = 0;
-  async *stream(req) {
-    const tools = toOpenAITools(req.tools);
-    const stream = await this.deps.client.chat.completions.create({
-      model: this.deps.model,
-      stream: true,
-      messages: toOpenAIMessages(req.system, req.messages),
-      ...tools ? { tools } : {}
-    });
-    const calls = /* @__PURE__ */ new Map();
-    let finishReason = null;
-    for await (const chunk of stream) {
-      const choice = chunk.choices?.[0];
-      if (!choice) continue;
-      const delta = choice.delta ?? {};
-      if (typeof delta.content === "string" && delta.content.length) {
-        yield { type: "text_delta", text: delta.content };
-      }
-      for (const tc of delta.tool_calls ?? []) {
-        const cur = calls.get(tc.index) ?? { id: "", name: "", args: "" };
-        if (tc.id) cur.id = tc.id;
-        if (tc.function?.name) cur.name = tc.function.name;
-        if (tc.function?.arguments) cur.args += tc.function.arguments;
-        calls.set(tc.index, cur);
-      }
-      if (choice.finish_reason) finishReason = choice.finish_reason;
-    }
-    for (const c of [...calls.entries()].sort((a, b) => a[0] - b[0]).map((e) => e[1])) {
-      const id = c.id || `openai-call-${this.callCounter++}`;
-      let args;
-      try {
-        args = c.args.trim() ? JSON.parse(c.args) : {};
-      } catch (err) {
-        throw new Error(`Tool "${c.name}" (id=${id}): invalid tool-call JSON: ${JSON.stringify(c.args)}`, { cause: err });
-      }
-      yield { type: "tool_call", id, name: c.name, args };
-    }
-    const stopReason = calls.size ? "tool_use" : finishReason === "length" ? "max_tokens" : "end";
-    yield { type: "done", stopReason };
-  }
-};
-
-// src/providers/gemini.ts
-function textOf2(blocks) {
-  return blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
-}
-function buildIdToName(messages) {
-  const map = /* @__PURE__ */ new Map();
-  for (const m of messages) {
-    if (m.role === "assistant") {
-      for (const b of m.content) {
-        if (b.type === "tool_call") map.set(b.id, b.name);
-      }
-    }
-  }
-  return map;
-}
-function toGeminiContents(messages) {
-  const idToName = buildIdToName(messages);
-  const out = [];
-  let i = 0;
-  while (i < messages.length) {
-    const m = messages[i];
-    if (m.role === "tool") {
-      const parts2 = [];
-      while (i < messages.length && messages[i].role === "tool") {
-        const t = messages[i];
-        parts2.push({ functionResponse: { name: idToName.get(t.toolCallId) ?? "unknown", response: { result: t.content } } });
-        i++;
-      }
-      out.push({ role: "user", parts: parts2 });
-      continue;
-    }
-    if (m.role === "user") {
-      out.push({ role: "user", parts: [{ text: textOf2(m.content) }] });
-      i++;
-      continue;
-    }
-    const parts = [];
-    for (const b of m.content) {
-      if (b.type === "text") parts.push({ text: b.text });
-      else if (b.type === "tool_call") parts.push({ functionCall: { name: b.name, args: b.args } });
-    }
-    out.push({ role: "model", parts });
-    i++;
-  }
-  return out;
-}
-function toGeminiTools(tools) {
-  if (!tools.length) return void 0;
-  return [{ functionDeclarations: tools.map((t) => ({ name: t.name, description: t.description, parameters: t.parameters })) }];
-}
-var GeminiProvider = class {
-  constructor(deps) {
-    this.deps = deps;
-  }
-  callCounter = 0;
-  async *stream(req) {
-    const stream = await this.deps.client.models.generateContentStream({
-      model: this.deps.model,
-      contents: toGeminiContents(req.messages),
-      config: {
-        systemInstruction: req.system,
-        tools: toGeminiTools(req.tools)
-      }
-    });
-    let sawToolCall = false;
-    let finishReason;
-    for await (const chunk of stream) {
-      const cand = chunk.candidates?.[0];
-      const parts = cand?.content?.parts ?? [];
-      for (const part of parts) {
-        if (typeof part.text === "string" && part.text.length) {
-          yield { type: "text_delta", text: part.text };
-        } else if (part.functionCall) {
-          sawToolCall = true;
-          yield {
-            type: "tool_call",
-            id: `gemini-call-${this.callCounter++}`,
-            name: part.functionCall.name,
-            args: part.functionCall.args ?? {}
-          };
-        }
-      }
-      if (cand?.finishReason) finishReason = cand.finishReason;
-    }
-    const stopReason = sawToolCall ? "tool_use" : finishReason === "MAX_TOKENS" ? "max_tokens" : "end";
-    yield { type: "done", stopReason };
-  }
-};
-
-// src/providers/registry.ts
-function requireKey(provider, apiKey) {
-  if (!apiKey || !apiKey.trim()) {
-    throw new Error(`Missing ${provider} API key. Set it via env or ~/.axon/config.json.`);
-  }
-  return apiKey;
-}
-function createProvider(cfg) {
-  const pc = cfg.providers[cfg.provider] ?? {};
-  switch (cfg.provider) {
-    case "anthropic": {
-      const apiKey = requireKey("Anthropic", pc.apiKey);
-      const model = resolveModel(cfg);
-      const client = new Anthropic({ apiKey });
-      return new AnthropicProvider({ client, model });
-    }
-    case "openai": {
-      const apiKey = requireKey("OpenAI", pc.apiKey);
-      const model = resolveModel(cfg);
-      const client = new OpenAI({ apiKey, baseURL: pc.baseUrl });
-      return new OpenAIProvider({ client, model });
-    }
-    case "gemini": {
-      const apiKey = requireKey("Gemini", pc.apiKey);
-      const model = resolveModel(cfg);
-      const client = new GoogleGenAI({ apiKey });
-      return new GeminiProvider({ client, model });
-    }
-    default:
-      throw new Error(`Unsupported provider: ${cfg.provider}`);
-  }
-}
-
-// src/tools/fs.ts
-import { readFile, readdir } from "node:fs/promises";
-import { join as join3, resolve as resolve2 } from "node:path";
-import fg from "fast-glob";
-
-// src/tools/paths.ts
-import { resolve, relative, isAbsolute, sep, dirname as dirname2 } from "node:path";
-import { realpathSync, existsSync } from "node:fs";
-function resolveInside(cwd, p) {
-  const root = resolve(cwd);
-  const full = isAbsolute(p) ? resolve(p) : resolve(root, p);
-  const rel = relative(root, full);
-  if (rel === ".." || rel.startsWith(".." + sep) || isAbsolute(rel)) {
-    throw new Error(`path escapes project root: ${p}`);
-  }
-  return full;
-}
-function assertSafeGlob(pattern) {
-  const norm = pattern.replace(/\\/g, "/");
-  if (isAbsolute(pattern) || norm === ".." || norm.startsWith("../") || norm.includes("/../")) {
-    throw new Error(`glob pattern escapes project root: ${pattern}`);
-  }
-}
-function assertRealInside(cwd, full) {
-  const root = realpathSync(resolve(cwd));
-  let p = full;
-  while (!existsSync(p)) {
-    const parent = dirname2(p);
-    if (parent === p) throw new Error(`cannot resolve path: ${full}`);
-    p = parent;
-  }
-  const real = realpathSync(p);
-  const rel = relative(root, real);
-  if (rel === ".." || rel.startsWith(".." + sep) || isAbsolute(rel)) {
-    throw new Error(`path escapes project root via symlink: ${full}`);
-  }
-}
-
-// src/tools/fs.ts
-function fail(err) {
-  return { ok: false, output: err instanceof Error ? err.message : String(err) };
-}
-var readFileTool = {
-  name: "read_file",
-  dangerous: false,
-  schema: {
-    name: "read_file",
-    description: "Read a file, returns content with 1-based line numbers.",
-    parameters: { type: "object", properties: { path: { type: "string" } }, required: ["path"] }
-  },
-  async run(args, ctx) {
-    try {
-      const { path } = args;
-      const full = resolveInside(ctx.cwd, path);
-      const text = await readFile(full, "utf8");
-      const numbered = text.replace(/\n$/, "").split("\n").map((line, i) => `${i + 1}	${line}`).join("\n");
-      return { ok: true, output: numbered };
-    } catch (err) {
-      return fail(err);
-    }
-  }
-};
-var listDirTool = {
-  name: "list_dir",
-  dangerous: false,
-  schema: {
-    name: "list_dir",
-    description: "List the entries of a directory. Directories get a trailing slash.",
-    parameters: { type: "object", properties: { path: { type: "string" } }, required: ["path"] }
-  },
-  async run(args, ctx) {
-    try {
-      const { path } = args;
-      const full = resolveInside(ctx.cwd, path);
-      const entries = await readdir(full, { withFileTypes: true });
-      const out = entries.map((e) => e.isDirectory() ? `${e.name}/` : e.name).join("\n");
-      return { ok: true, output: out };
-    } catch (err) {
-      return fail(err);
-    }
-  }
-};
-var globTool = {
-  name: "glob",
-  dangerous: false,
-  schema: {
-    name: "glob",
-    description: "Find files matching a glob pattern (relative paths from project root).",
-    parameters: { type: "object", properties: { pattern: { type: "string" } }, required: ["pattern"] }
-  },
-  async run(args, ctx) {
-    try {
-      const { pattern } = args;
-      assertSafeGlob(pattern);
-      const matches = await fg(pattern, { cwd: resolve2(ctx.cwd), onlyFiles: true, dot: false });
-      return { ok: true, output: matches.join("\n") };
-    } catch (err) {
-      return fail(err);
-    }
-  }
-};
-var grepTool = {
-  name: "grep",
-  dangerous: false,
-  schema: {
-    name: "grep",
-    description: "Search file contents by regex. Returns file:line:text for each match.",
-    parameters: {
-      type: "object",
-      properties: { pattern: { type: "string" }, glob: { type: "string" } },
-      required: ["pattern"]
-    }
-  },
-  async run(args, ctx) {
-    try {
-      const { pattern, glob = "**/*" } = args;
-      assertSafeGlob(glob);
-      const root = resolve2(ctx.cwd);
-      const re = new RegExp(pattern);
-      const files = await fg(glob, { cwd: root, onlyFiles: true, dot: false });
-      const hits = [];
-      for (const rel of files) {
-        const text = await readFile(join3(root, rel), "utf8").catch(() => "");
-        text.split("\n").forEach((line, i) => {
-          if (re.test(line)) hits.push(`${rel}:${i + 1}:${line}`);
-        });
-      }
-      return { ok: true, output: hits.join("\n") };
-    } catch (err) {
-      return fail(err);
-    }
-  }
-};
-
-// src/tools/edit.ts
-import { readFile as readFile2, writeFile, mkdir } from "node:fs/promises";
-import { dirname as dirname3 } from "node:path";
-function fail2(err) {
-  return { ok: false, output: err instanceof Error ? err.message : String(err) };
-}
-var writeFileTool = {
-  name: "write_file",
-  dangerous: true,
-  schema: {
-    name: "write_file",
-    description: "Create or overwrite a file (relative to the project root). Creates parent directories as needed.",
-    parameters: {
-      type: "object",
-      properties: { path: { type: "string" }, content: { type: "string" } },
-      required: ["path", "content"]
-    }
-  },
-  async run(args, ctx) {
-    try {
-      const { path, content } = args;
-      const full = resolveInside(ctx.cwd, path);
-      assertRealInside(ctx.cwd, full);
-      await mkdir(dirname3(full), { recursive: true });
-      await writeFile(full, content, "utf8");
-      return { ok: true, output: `wrote ${Buffer.byteLength(content, "utf8")} bytes to ${path}` };
-    } catch (err) {
-      return fail2(err);
-    }
-  }
-};
-var editFileTool = {
-  name: "edit_file",
-  dangerous: true,
-  schema: {
-    name: "edit_file",
-    description: "Replace an exact, unique occurrence of old_string with new_string in a file.",
-    parameters: {
-      type: "object",
-      properties: { path: { type: "string" }, old_string: { type: "string" }, new_string: { type: "string" } },
-      required: ["path", "old_string", "new_string"]
-    }
-  },
-  async run(args, ctx) {
-    try {
-      const { path, old_string, new_string } = args;
-      const full = resolveInside(ctx.cwd, path);
-      assertRealInside(ctx.cwd, full);
-      if (old_string === "") return { ok: false, output: "old_string must not be empty" };
-      const text = await readFile2(full, "utf8");
-      const count = text.split(old_string).length - 1;
-      if (count === 0) return { ok: false, output: `old_string not found in ${path}` };
-      if (count > 1) return { ok: false, output: `old_string matches ${count} occurrences in ${path}; make it unique` };
-      const updated = text.split(old_string).join(new_string);
-      await writeFile(full, updated, "utf8");
-      return { ok: true, output: `edited ${path}` };
-    } catch (err) {
-      return fail2(err);
-    }
-  }
-};
-
-// src/tools/shell.ts
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-var pexec = promisify(exec);
-function combine(stdout, stderr) {
-  return [stdout, stderr].filter((s) => s.trim()).join("\n").trim();
-}
-var shellTool = {
-  name: "shell",
-  dangerous: true,
-  schema: {
-    name: "shell",
-    description: "Run a shell command in the project root. Returns combined stdout+stderr; ok is false on a nonzero exit or timeout.",
-    parameters: {
-      type: "object",
-      properties: { command: { type: "string" } },
-      required: ["command"]
-    }
-  },
-  async run(args, ctx) {
-    const { command } = args;
-    try {
-      const { stdout, stderr } = await pexec(command, {
-        cwd: ctx.cwd,
-        timeout: 12e4,
-        maxBuffer: 10 * 1024 * 1024,
-        windowsHide: true
-      });
-      return { ok: true, output: combine(stdout, stderr) || "(no output)" };
-    } catch (err) {
-      const e = err;
-      const body = combine(e.stdout ?? "", e.stderr ?? "");
-      const status = e.killed && e.code == null ? "timed out" : e.killed ? "killed by signal" : `exit ${e.code ?? "?"}`;
-      return { ok: false, output: `[${status}] ${body || e.message}`.trim() };
-    }
-  }
-};
-
-// src/tools/registry.ts
-function toMap(tools) {
-  return new Map(tools.map((t) => [t.name, t]));
-}
-function buildReadOnlyTools() {
-  return toMap([readFileTool, listDirTool, globTool, grepTool]);
-}
-function buildMutatingTools() {
-  return toMap([writeFileTool, editFileTool, shellTool]);
-}
-function buildAllTools() {
-  return toMap([...buildReadOnlyTools().values(), ...buildMutatingTools().values()]);
-}
-
-// src/permission/gate.ts
-var denyGate = async (req) => ({
-  allow: false,
-  reason: `permission denied: "${req.name}" is a write/exec action and non-interactive mode blocks it. Re-run with --yolo to allow.`
-});
-var allowAllGate = async () => ({
-  allow: true,
-  reason: "allowed (--yolo)"
-});
-
-// src/core/conversation.ts
-var Conversation = class {
-  msgs = [];
-  get messages() {
-    return [...this.msgs];
-  }
-  pushUser(text) {
-    this.msgs.push({ role: "user", content: [{ type: "text", text }] });
-  }
-  pushAssistant(content) {
-    this.msgs.push({ role: "assistant", content });
-  }
-  pushToolResult(toolCallId, content) {
-    this.msgs.push({ role: "tool", toolCallId, content });
-  }
-};
-
-// src/core/engine.ts
-var Engine = class {
-  constructor(deps) {
-    this.deps = deps;
-  }
-  convo = new Conversation();
-  listeners = [];
-  on(fn) {
-    this.listeners.push(fn);
-  }
-  /** Read-only snapshot of the conversation transcript. */
-  get history() {
-    return this.convo.messages;
-  }
-  emit(e) {
-    for (const l of this.listeners) l(e);
-  }
-  // NOTE: the `error` EngineEvent is reserved for the Plan 3 interactive/TUI path;
-  // stream failures currently propagate to the CLI's top-level handler in the non-interactive slice.
-  async submit(text) {
-    this.convo.pushUser(text);
-    const maxSteps = this.deps.maxSteps ?? 50;
-    for (let step = 0; step < maxSteps; step++) {
-      const blocks = [];
-      const calls = [];
-      let textBlock = null;
-      let stopReason = "end";
-      for await (const ev of this.deps.provider.stream({
-        system: this.deps.system,
-        messages: this.convo.messages,
-        tools: [...this.deps.tools.values()].map((t) => t.schema)
-      })) {
-        if (ev.type === "text_delta") {
-          if (!textBlock) {
-            textBlock = { type: "text", text: "" };
-            blocks.push(textBlock);
-          }
-          textBlock.text += ev.text;
-          this.emit({ type: "text_delta", text: ev.text });
-        } else if (ev.type === "tool_call") {
-          textBlock = null;
-          blocks.push({ type: "tool_call", id: ev.id, name: ev.name, args: ev.args });
-          calls.push({ id: ev.id, name: ev.name, args: ev.args });
-        } else if (ev.type === "done") {
-          stopReason = ev.stopReason;
-        }
-      }
-      this.convo.pushAssistant(blocks);
-      if (calls.length === 0) {
-        this.emit({ type: "turn_done", stopReason });
-        return;
-      }
-      for (const call of calls) {
-        this.emit({ type: "tool_start", id: call.id, name: call.name, args: call.args });
-        const tool = this.deps.tools.get(call.name);
-        if (!tool) {
-          this.emit({ type: "tool_end", id: call.id, ok: false, output: `unknown tool: ${call.name}` });
-          this.convo.pushToolResult(call.id, `unknown tool: ${call.name}`);
-          continue;
-        }
-        if (tool.dangerous) {
-          const gate = this.deps.gate ?? denyGate;
-          const verdict = await gate({ id: call.id, name: call.name, args: call.args });
-          if (!verdict.allow) {
-            this.emit({ type: "tool_end", id: call.id, ok: false, output: verdict.reason });
-            this.convo.pushToolResult(call.id, verdict.reason);
-            continue;
-          }
-        }
-        let result;
-        try {
-          result = await tool.run(call.args, { cwd: this.deps.cwd });
-        } catch (err) {
-          result = { ok: false, output: String(err) };
-        }
-        this.emit({ type: "tool_end", id: call.id, ok: result.ok, output: result.output });
-        this.convo.pushToolResult(call.id, result.output);
-      }
-    }
-    this.emit({ type: "turn_done", stopReason: "max_steps" });
-  }
-};
-
-// src/ui/printRunner.ts
-function printRunner(engine, write) {
-  engine.on((e) => {
-    switch (e.type) {
-      case "text_delta":
-        write(e.text);
-        break;
-      case "tool_start":
-        write(`
-\u23F3 ${e.name}(${JSON.stringify(e.args)})
-`);
-        break;
-      case "tool_end":
-        write(`${e.ok ? "\u2705" : "\u274C"} ${truncate(e.output)}
-`);
-        break;
-      case "permission_request":
-        write(`
-\u{1F512} ${e.action}: ${e.detail}
-`);
-        break;
-      case "turn_done":
-        write(`
-[done: ${e.stopReason}]
-`);
-        break;
-      case "error":
-        write(`
-\u{1F4A5} ${e.message}
-`);
-        break;
-    }
-  });
-}
-function truncate(s, max = 500) {
-  return s.length > max ? `${s.slice(0, max)}\u2026` : s;
-}
-
-// src/ui/runTui.tsx
-import { useState as useState3, useRef } from "react";
-import { Box as Box6, Text as Text6, render } from "ink";
-
-// src/core/projectContext.ts
-import { readFileSync as readFileSync3 } from "node:fs";
-import { join as join4 } from "node:path";
-function truncate2(s, max) {
-  return s.length > max ? `${s.slice(0, max)}\u2026` : s;
-}
-function loadProjectContext(cwd) {
-  const parts = [];
-  try {
-    const pkg = JSON.parse(readFileSync3(join4(cwd, "package.json"), "utf8"));
-    const bits = [];
-    if (pkg.name) bits.push(`name: ${pkg.name}`);
-    if (pkg.description) bits.push(`description: ${pkg.description}`);
-    if (pkg.scripts && typeof pkg.scripts === "object") bits.push(`scripts: ${Object.keys(pkg.scripts).join(", ")}`);
-    if (bits.length) parts.push(`package.json \u2014 ${bits.join("; ")}`);
-  } catch {
-  }
-  for (const name of ["AGENTS.md", "CLAUDE.md", "README.md"]) {
-    try {
-      const text = readFileSync3(join4(cwd, name), "utf8").trim();
-      if (text) {
-        parts.push(`${name}:
-${truncate2(text, 2e3)}`);
-        break;
-      }
-    } catch {
-    }
-  }
-  return parts.join("\n\n");
-}
-
-// src/core/systemPrompt.ts
-function buildSystemPrompt(opts) {
-  const identity = `You are the coding agent inside Axon, a command-line coding tool. Axon is the CLI program \u2014 it is NOT a language model. You are powered by the model "${opts.model}" via the ${opts.provider} provider. If the user asks which model or LLM you are, answer honestly: "${opts.model}" (via ${opts.provider}), running inside the Axon CLI. Never claim that "Axon" is a model.`;
-  const toolLine = opts.tools === "all" ? `Use the tools to inspect AND modify the project: read_file, list_dir, glob, grep (read-only) and write_file, edit_file, shell (these change the workspace; the user is prompted to approve each). Prefer edit_file for surgical changes.` : `Use the read-only tools to inspect the project: read_file, list_dir, glob, grep.`;
-  const closing = `Explain briefly what you are doing. When the task is done, stop calling tools.`;
-  let prompt = `${identity}
-
-${toolLine} ${closing}`;
-  if (opts.context) prompt += `
-
-Project context:
-${opts.context}`;
-  return prompt;
-}
-
-// src/ui/permissionController.ts
-function createPermissionController() {
-  const sessionAllow = /* @__PURE__ */ new Set();
-  const subscribers = /* @__PURE__ */ new Set();
-  const queue = [];
-  let active = null;
-  let currentPending = null;
-  const notify = (p) => {
-    currentPending = p;
-    for (const fn of subscribers) fn(p);
-  };
-  const pump = () => {
-    if (active || queue.length === 0) return;
-    active = queue.shift();
-    notify({ req: active.req });
-  };
-  const gate = (req) => {
-    if (sessionAllow.has(req.name)) {
-      return Promise.resolve({ allow: true, reason: "allowed (remembered this session)" });
-    }
-    return new Promise((res) => {
-      queue.push({ req, settle: res });
-      pump();
-    });
-  };
-  const resolve3 = (decision) => {
-    if (!active) return;
-    const { req, settle } = active;
-    active = null;
-    if (decision === "always") sessionAllow.add(req.name);
-    settle({
-      allow: decision !== "deny",
-      reason: decision === "deny" ? `permission denied by user: ${req.name}` : `allowed (${decision})`
-    });
-    pump();
-    if (!active) notify(null);
-  };
-  const subscribe = (fn) => {
-    subscribers.add(fn);
-    return () => {
-      subscribers.delete(fn);
-    };
-  };
-  const getPending = () => currentPending;
-  return { gate, subscribe, getPending, resolve: resolve3 };
-}
-
-// src/config/credentials.ts
-function hasUsableKey(cfg) {
-  const k = cfg.providers[cfg.provider]?.apiKey;
-  return typeof k === "string" && k.trim().length > 0;
-}
-var INFO = {
-  anthropic: { envVar: "ANTHROPIC_API_KEY", url: "https://console.anthropic.com/settings/keys" },
-  openai: { envVar: "OPENAI_API_KEY", url: "https://platform.openai.com/api-keys" },
-  gemini: { envVar: "GEMINI_API_KEY", url: "https://aistudio.google.com/apikey" }
-};
-function keyProviderInfo(provider) {
-  return INFO[provider] ?? { envVar: `${provider.toUpperCase()}_API_KEY`, url: "" };
-}
-
-// src/ui/app.tsx
-import { useEffect, useState, useSyncExternalStore, useCallback } from "react";
-import { Box as Box4, Text as Text4, useInput as useInput2 } from "ink";
-import TextInput from "ink-text-input";
-
-// src/ui/components/MessageView.tsx
-import { Box, Text } from "ink";
-import { jsx, jsxs } from "react/jsx-runtime";
-function toolIcon(status) {
-  if (status === "running") return "\u23F3";
-  return status === "ok" ? "\u2705" : "\u274C";
-}
-function truncate3(s, max = 300) {
-  return s.length > max ? `${s.slice(0, max)}\u2026` : s;
-}
-function MessageView({ items }) {
-  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: items.map((it, i) => {
-    if (it.kind === "user") {
-      return /* @__PURE__ */ jsxs(Text, { children: [
-        /* @__PURE__ */ jsxs(Text, { color: "cyan", bold: true, children: [
-          "You",
-          "  "
-        ] }),
-        it.text
-      ] }, i);
-    }
-    if (it.kind === "assistant") {
-      return /* @__PURE__ */ jsxs(Text, { children: [
-        /* @__PURE__ */ jsxs(Text, { color: "green", bold: true, children: [
-          "Axon",
-          " "
-        ] }),
-        it.text
-      ] }, i);
-    }
-    if (it.kind === "error") {
-      return /* @__PURE__ */ jsxs(Text, { color: "red", children: [
-        "\u{1F4A5} ",
-        it.text
-      ] }, i);
-    }
-    if (it.kind === "tool") {
-      return /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
-        toolIcon(it.status),
-        " ",
-        it.name,
-        "(",
-        truncate3(JSON.stringify(it.args ?? {}), 60),
-        ")",
-        it.output ? ` \u2014 ${truncate3(it.output)}` : ""
-      ] }, i);
-    }
-    return null;
-  }) });
-}
-
-// src/ui/components/PermissionPrompt.tsx
-import { Box as Box2, Text as Text2, useInput } from "ink";
-import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
-function summarize(args) {
-  const s = JSON.stringify(args ?? {});
-  return s.length > 80 ? `${s.slice(0, 80)}\u2026` : s;
-}
-function decisionForKey(input) {
-  if (input === "a") return "once";
-  if (input === "A") return "always";
-  if (input === "d") return "deny";
-  return null;
-}
-function PermissionPrompt({ req, onDecide }) {
-  useInput((input) => {
-    const d = decisionForKey(input);
-    if (d) onDecide(d);
-  });
-  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs2(Text2, { color: "yellow", children: [
-      "\u{1F512} ",
-      req.name,
-      "(",
-      summarize(req.args),
-      ")"
-    ] }),
-    /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: "[a] allow once / [A] always this session / [d] deny" })
-  ] });
-}
-
-// src/ui/components/StatusBar.tsx
-import { Box as Box3, Text as Text3 } from "ink";
-import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
-function StatusBar({ provider, model, running, yolo }) {
-  return /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsxs3(Text3, { color: "gray", children: [
-    "[axon: ",
-    provider,
-    "/",
-    model,
-    yolo ? " \xB7 yolo" : "",
-    " \xB7 ",
-    running ? "working\u2026" : "ready",
-    " \xB7 ^C quit]"
-  ] }) });
-}
-
-// src/ui/app.tsx
-import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
-function reduceEvent(items, e) {
-  switch (e.type) {
-    case "text_delta": {
-      const last = items[items.length - 1];
-      if (last && last.kind === "assistant") {
-        return [...items.slice(0, -1), { kind: "assistant", text: last.text + e.text }];
-      }
-      return [...items, { kind: "assistant", text: e.text }];
-    }
-    case "tool_start":
-      return [...items, { kind: "tool", id: e.id, name: e.name, args: e.args, status: "running" }];
-    case "tool_end":
-      return items.map(
-        (it) => it.kind === "tool" && it.id === e.id ? { ...it, status: e.ok ? "ok" : "fail", output: e.output } : it
-      );
-    default:
-      return items;
-  }
-}
-function usePendingPermission(controller) {
-  const subscribe = useCallback((onChange) => controller.subscribe(() => onChange()), [controller]);
-  const getSnapshot = useCallback(() => controller.getPending(), [controller]);
-  const pending = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-  return pending ? pending.req : null;
-}
-function App({ engine, controller, provider, model, yolo }) {
-  const [items, setItems] = useState([]);
-  const [input, setInput] = useState("");
-  const [running, setRunning] = useState(false);
-  const pending = usePendingPermission(controller);
-  useEffect(() => {
-    engine.on((e) => setItems((prev) => reduceEvent(prev, e)));
-  }, [engine]);
-  useInput2(
-    (_input, key) => {
-      if (key.escape && !running) setInput("");
-    },
-    { isActive: !pending }
-  );
-  const handleSubmit = (text) => {
-    if (!text.trim() || running) return;
-    setItems((prev) => [...prev, { kind: "user", text }]);
-    setInput("");
-    setRunning(true);
-    engine.submit(text).catch((err) => {
-      const msg = err instanceof Error ? err.message : String(err);
-      setItems((prev) => [...prev, { kind: "error", text: msg }]);
-    }).finally(() => setRunning(false));
-  };
-  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx4(MessageView, { items }),
-    pending ? /* @__PURE__ */ jsx4(PermissionPrompt, { req: pending, onDecide: (d) => controller.resolve(d) }) : running ? /* @__PURE__ */ jsx4(Text4, { color: "gray", children: "\u2026 working (Ctrl+C to quit)" }) : /* @__PURE__ */ jsxs4(Box4, { children: [
-      /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "\u203A " }),
-      /* @__PURE__ */ jsx4(TextInput, { value: input, onChange: setInput, onSubmit: handleSubmit })
-    ] }),
-    /* @__PURE__ */ jsx4(StatusBar, { provider, model, running, yolo })
-  ] });
-}
-
-// src/ui/Setup.tsx
-import { useState as useState2 } from "react";
-import { Box as Box5, Text as Text5, useInput as useInput3 } from "ink";
-import TextInput2 from "ink-text-input";
-import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
-var SETUP_PROVIDERS = ["anthropic", "openai", "gemini"];
-function trimmedKey(v) {
-  const t = v.trim();
-  return t ? t : null;
-}
-function providerForDigit(input) {
-  const idx = Number(input) - 1;
-  return Number.isInteger(idx) && idx >= 0 && idx < SETUP_PROVIDERS.length ? SETUP_PROVIDERS[idx] : null;
-}
-function Setup({
-  initialProvider,
-  onSubmit
-}) {
-  const start = SETUP_PROVIDERS.includes(initialProvider) ? initialProvider : "anthropic";
-  const [provider, setProvider] = useState2(start);
-  const [value, setValue] = useState2("");
-  useInput3((input) => {
-    const picked = providerForDigit(input);
-    if (picked) setProvider(picked);
-  });
-  const info = keyProviderInfo(provider);
-  const submit = (v) => {
-    const k = trimmedKey(v);
-    if (k) onSubmit(provider, k);
-  };
-  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx5(Text5, { color: "yellow", children: "Welcome to Axon. Pick a provider, then paste its API key." }),
-    SETUP_PROVIDERS.map((p, i) => /* @__PURE__ */ jsxs5(Text5, { color: p === provider ? "cyan" : "gray", children: [
-      p === provider ? "\u276F" : " ",
-      " [",
-      i + 1,
-      "] ",
-      p
-    ] }, p)),
-    /* @__PURE__ */ jsxs5(Text5, { children: [
-      "Active: ",
-      /* @__PURE__ */ jsx5(Text5, { bold: true, children: provider }),
-      " \u2014 set ",
-      /* @__PURE__ */ jsx5(Text5, { bold: true, children: info.envVar }),
-      ", or paste a key below to save it to ~/.axon/config.json."
-    ] }),
-    info.url ? /* @__PURE__ */ jsxs5(Text5, { color: "gray", children: [
-      "Get a ",
-      provider,
-      " key at: ",
-      info.url
-    ] }) : null,
-    /* @__PURE__ */ jsxs5(Box5, { children: [
-      /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: "key \u203A " }),
-      /* @__PURE__ */ jsx5(TextInput2, { value, onChange: setValue, onSubmit: submit, mask: "*" })
-    ] })
-  ] });
-}
-
-// src/ui/runTui.tsx
-import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
-function Root({ deps }) {
-  const { cfg, controller, yolo, buildEngine, persistKey } = deps;
-  const [ready, setReady] = useState3(hasUsableKey(cfg));
-  const engineRef = useRef(null);
-  if (ready && !engineRef.current) engineRef.current = buildEngine();
-  if (!ready || !engineRef.current) {
-    return /* @__PURE__ */ jsx6(
-      Setup,
-      {
-        initialProvider: cfg.provider,
-        onSubmit: (provider, key) => {
-          persistKey(provider, key);
-          cfg.provider = provider;
-          cfg.providers[provider] = { ...cfg.providers[provider] ?? {}, apiKey: key };
-          setReady(true);
-        }
-      }
-    );
-  }
-  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs6(Text6, { color: "green", children: [
-      "Axon \xB7 ",
-      cfg.provider,
-      "/",
-      resolveModel(cfg),
-      " \xB7 type a request, Ctrl+C to quit"
-    ] }),
-    /* @__PURE__ */ jsx6(
-      App,
-      {
-        engine: engineRef.current,
-        controller,
-        provider: cfg.provider,
-        model: resolveModel(cfg),
-        yolo
-      }
-    )
-  ] });
-}
-function runTui(opts) {
-  const cfg = loadConfig();
-  if (opts.provider) cfg.provider = opts.provider;
-  if (opts.model) cfg.model = opts.model;
-  const controller = createPermissionController();
-  const deps = {
-    cfg,
-    controller,
-    yolo: Boolean(opts.yolo),
-    persistKey: (provider, key) => {
-      try {
-        setApiKey(provider, key);
-        setConfigValue("provider", provider);
-      } catch {
-      }
-    },
-    buildEngine: () => {
-      const provider = createProvider(cfg);
-      const tools = buildAllTools();
-      const gate = opts.yolo ? allowAllGate : controller.gate;
-      const context = loadProjectContext(process.cwd());
-      const system = buildSystemPrompt({ provider: cfg.provider, model: resolveModel(cfg), tools: "all", context });
-      return new Engine({ provider, tools, system, cwd: process.cwd(), gate });
-    }
-  };
-  if (!process.stdin.isTTY) {
-    process.stderr.write('axon: the interactive chat needs a terminal. For non-interactive use, run: axon -p "your prompt"\n');
-    process.exit(1);
-  }
-  render(/* @__PURE__ */ jsx6(Root, { deps }));
-}
-
-// src/cli.ts
-function redactKeys(cfg) {
-  const providers = cfg.providers;
-  if (!providers || typeof providers !== "object") return cfg;
-  const masked = {};
-  for (const [name, p] of Object.entries(providers)) {
-    masked[name] = p && typeof p === "object" && "apiKey" in p && p.apiKey ? { ...p, apiKey: "***redacted***" } : p;
-  }
-  return { ...cfg, providers: masked };
-}
-var program = new Command();
-program.name("axon").version(VERSION).option("-p, --print <prompt>", "run one prompt non-interactively and stream the result").option("--provider <name>", "override the provider for this run (anthropic | openai | gemini)").option("--model <name>", "override the model for this run").option("--yolo", "allow write/edit/shell tools without prompting (non-interactive)");
-program.command("config").argument("<action>", "get | set").argument("[key]", "config key (provider | model | <provider>.<baseUrl|model>)").argument("[value]", "value to set").action((action, key, value) => {
-  if (action === "get") {
-    process.stdout.write(JSON.stringify(redactKeys(readConfigFile()), null, 2) + "\n");
-    return;
-  }
-  if (action === "set") {
-    if (!key || value === void 0) throw new Error("Usage: axon config set <key> <value>");
-    setConfigValue(key, value);
-    process.stdout.write(`set ${key} = ${value}
-`);
-    return;
-  }
-  throw new Error(`Unknown config action "${action}". Use get or set.`);
-});
-program.action(() => {
-  const opts = program.opts();
-  main(opts).catch((err) => {
-    process.stderr.write(`\u{1F4A5} ${err instanceof Error ? err.message : String(err)}
-`);
-    process.exit(1);
-  });
-});
-program.parse();
-async function main(opts) {
-  if (!opts.print) {
-    runTui({ provider: opts.provider, model: opts.model, yolo: opts.yolo });
-    return;
-  }
-  const cfg = loadConfig();
-  if (opts.provider) cfg.provider = opts.provider;
-  if (opts.model) cfg.model = opts.model;
-  const provider = createProvider(cfg);
-  const tools = opts.yolo ? buildAllTools() : buildReadOnlyTools();
-  const gate = opts.yolo ? allowAllGate : denyGate;
-  const context = loadProjectContext(process.cwd());
-  const system = buildSystemPrompt({
-    provider: cfg.provider,
-    model: resolveModel(cfg),
-    tools: opts.yolo ? "all" : "readonly",
-    context
-  });
-  const engine = new Engine({ provider, tools, system, cwd: process.cwd(), gate });
-  printRunner(engine, (s) => process.stdout.write(s));
-  process.stderr.write(`[axon: ${cfg.provider} / ${resolveModel(cfg)}${opts.yolo ? " / yolo" : ""}]
-`);
-  await engine.submit(opts.print);
-}