@wanghuimvp/axon 0.0.1 → 0.2.0

package/README.md

@@ -1,56 +1,108 @@
-# Axon
-
-An agentic coding CLI. Axon streams from Anthropic and runs a multi-step tool loop over your codebase — it reads, searches, and reasons across your files to answer a prompt.
-
-> Foundation release (`0.0.x`). Non-interactive `axon -p` mode with read-only tools. Interactive TUI, write/edit/shell tools, and multi-provider support are on the roadmap.
-
-## Install
-
-```bash
-npm install -g @wanghuimvp/axon
-```
-
-## Setup
-
-Axon reads your Anthropic key from the environment:
-
-```bash
-# macOS / Linux
-export ANTHROPIC_API_KEY=sk-ant-...
-
-# Windows (PowerShell)
-$env:ANTHROPIC_API_KEY="sk-ant-..."
-```
-
-## Usage
-
-```bash
-axon -p "list the TypeScript files in src and explain what engine.ts does"
-```
-
-Axon will stream the model's reasoning, run read-only tools as needed (`read_file`, `list_dir`, `glob`, `grep`), and print the result.
-
-### Options
-
-- `-p, --print <prompt>` — run one prompt non-interactively and stream the result.
-- `--version` — print the version.
-
-## Configuration
-
-Optional config file at `~/.axon/config.json`:
-
-```json
-{
-  "provider": "anthropic",
-  "model": "claude-opus-4-8",
-  "providers": {
-    "anthropic": { "apiKey": "env:ANTHROPIC_API_KEY" }
-  }
-}
-```
-
-API keys are read from environment variables and never written to disk.
-
-## License
-
-MIT
+# Axon
+
+An agentic coding CLI. Axon streams from Anthropic and runs a multi-step tool loop over your codebase — it reads, searches, and reasons across your files to answer a prompt.
+
+> Foundation release (`0.0.x`). Non-interactive `axon -p` mode with read-only tools (always available) and write/edit/shell tools (enabled with `--yolo`). Interactive TUI is on the roadmap.
+
+## Install
+
+```bash
+npm install -g @wanghuimvp/axon
+```
+
+## Providers
+
+Axon speaks to three backends. The OpenAI-compatible provider also drives any
+OpenAI-protocol endpoint (DeepSeek, Qwen, Kimi, Groq, OpenRouter, ollama, LM Studio, …)
+by pointing `baseUrl` at it.
+
+| Provider   | `provider` value | API key env         | Notes |
+|------------|------------------|---------------------|-------|
+| Anthropic  | `anthropic`      | `ANTHROPIC_API_KEY` | Claude models |
+| OpenAI     | `openai`         | `OPENAI_API_KEY`    | GPT + any OpenAI-compatible endpoint via `baseUrl` |
+| Gemini     | `gemini`         | `GEMINI_API_KEY`    | Google Gemini models |
+
+Set the relevant API key in your environment before running:
+
+```bash
+# macOS / Linux
+export OPENAI_API_KEY=sk-...
+# Windows (PowerShell)
+$env:OPENAI_API_KEY="sk-..."
+```
+
+### Select a provider/model
+
+```bash
+# Per run:
+axon --provider openai --model gpt-4.1 -p "explain engine.ts"
+
+# Persisted:
+axon config set provider gemini
+axon config set gemini.model gemini-2.5-pro
+axon config get
+```
+
+### Point at an OpenAI-compatible endpoint (e.g. DeepSeek, ollama)
+
+```bash
+axon config set provider openai
+axon config set openai.baseUrl https://api.deepseek.com/v1
+axon config set openai.model deepseek-chat
+export OPENAI_API_KEY=sk-...      # the endpoint's key
+axon -p "summarize src/"
+```
+
+For a local ollama server:
+```bash
+axon config set openai.baseUrl http://localhost:11434/v1
+axon config set openai.model qwen2.5-coder
+export OPENAI_API_KEY=ollama      # ollama ignores the key but the field must be non-empty
+```
+
+## Usage
+
+```bash
+axon -p "list the TypeScript files in src and explain what engine.ts does"
+```
+
+Axon will stream the model's reasoning, run read-only tools as needed (`read_file`, `list_dir`, `glob`, `grep`), and print the result.
+
+### Options
+
+- `-p, --print <prompt>` — run one prompt non-interactively and stream the result.
+- `--provider <name>` — select a provider (anthropic, openai, gemini) for this run.
+- `--model <name>` — select a model for this run.
+- `--yolo` — enable the `write_file`/`edit_file`/`shell` tools without prompting (non-interactive). Off by default: these tools are not even offered to the model, so it sticks to read-only inspection.
+- `--version` — print the version.
+
+### Changing files
+
+Axon can modify your workspace with `write_file`, `edit_file`, and run commands with `shell`. In non-interactive (`-p`) mode these tools are **only available with `--yolo`** — without the flag they are not offered to the model at all (and a permission gate denies them as defense-in-depth).
+
+```bash
+axon --yolo -p "add a CHANGELOG.md with an initial entry, then run the tests"
+```
+
+Read/search tools (`read_file`, `list_dir`, `glob`, `grep`) always run without a prompt. `write_file` and `edit_file` are confined to the project root (path-escape and symlink-escape protected). `shell` is **not** sandboxed — under `--yolo` it runs arbitrary commands and can affect anything your shell can. Only pass `--yolo` to runs you trust.
+
+## Configuration
+
+Optional config file at `~/.axon/config.json`:
+
+```json
+{
+  "provider": "anthropic",
+  "providers": {
+    "anthropic": { "model": "claude-opus-4-8" },
+    "openai":    { "model": "gpt-4.1", "baseUrl": "https://api.openai.com/v1" },
+    "gemini":    { "model": "gemini-2.5-pro" }
+  }
+}
+```
+
+API keys are read from environment variables (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `GEMINI_API_KEY`) and never written to disk.
+
+## License
+
+MIT

package/dist/cli.js

@@ -10,13 +10,26 @@ var VERSION = "0.0.1";
 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",
-  model: "claude-opus-4-8",
   providers: {
-    anthropic: { apiKey: "env:ANTHROPIC_API_KEY" }
+    anthropic: { apiKey: "env:ANTHROPIC_API_KEY" },
+    openai: { apiKey: "env:OPENAI_API_KEY" },
+    gemini: { apiKey: "env:GEMINI_API_KEY" }
   }
 };
+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)) {
@@ -34,14 +47,50 @@ function loadConfig() {
   }
   const merged = {
     provider: fileCfg.provider ?? DEFAULTS.provider,
-    model: fileCfg.model ?? DEFAULTS.model,
+    model: fileCfg.model,
     providers: { ...DEFAULTS.providers, ...fileCfg.providers ?? {} }
   };
   return resolveEnvRefs(merged);
 }
 
+// src/config/configFile.ts
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync } 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");
+}
+
 // 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) {
@@ -131,24 +180,211 @@ var AnthropicProvider = class {
   }
 };
 
+// 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) {
-  if (cfg.provider === "anthropic") {
-    const apiKey = cfg.providers.anthropic?.apiKey;
-    if (!apiKey || !apiKey.trim()) throw new Error("Missing Anthropic API key. Set ANTHROPIC_API_KEY.");
-    const client = new Anthropic({ apiKey });
-    return new AnthropicProvider({ client, model: cfg.model });
+  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}`);
   }
-  throw new Error(`Unsupported provider: ${cfg.provider}`);
 }
 
 // src/tools/fs.ts
 import { readFile, readdir } from "node:fs/promises";
-import { join as join2, resolve as resolve2 } from "node:path";
+import { join as join3, resolve as resolve2 } from "node:path";
 import fg from "fast-glob";
 
 // src/tools/paths.ts
-import { resolve, relative, isAbsolute, sep } from "node:path";
+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);
@@ -164,6 +400,20 @@ function assertSafeGlob(pattern) {
     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) {
@@ -249,7 +499,7 @@ var grepTool = {
       const files = await fg(glob, { cwd: root, onlyFiles: true, dot: false });
       const hits = [];
       for (const rel of files) {
-        const text = await readFile(join2(root, rel), "utf8").catch(() => "");
+        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}`);
         });
@@ -261,11 +511,129 @@ var grepTool = {
   }
 };
 
+// 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 buildReadOnlyTools() {
-  const tools = [readFileTool, listDirTool, globTool, grepTool];
+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 {
@@ -344,6 +712,15 @@ var Engine = class {
           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 });
@@ -397,25 +774,48 @@ function truncate(s, max = 500) {
 }
 
 // src/cli.ts
-var SYSTEM = `You are Axon, an agentic coding assistant. Use the provided tools to inspect the project and answer precisely. When done, stop calling tools.`;
+var READONLY_SYSTEM = `You are Axon, an agentic coding assistant. Use the read-only tools \u2014 read_file, list_dir, glob, grep \u2014 to inspect the project and answer precisely. When done, stop calling tools.`;
+var YOLO_SYSTEM = `You are Axon, an agentic coding assistant. Use the provided 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). Prefer edit_file for surgical changes. When done, stop calling tools.`;
 var program = new Command();
-program.name("axon").version(VERSION).option("-p, --print <prompt>", "run one prompt non-interactively and stream the result");
+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(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();
-var opts = program.opts();
-async function main() {
+async function main(opts) {
   if (!opts.print) {
     process.stdout.write('Interactive TUI not built yet \u2014 use: axon -p "your prompt"\n');
     return;
   }
   const cfg = loadConfig();
+  if (opts.provider) cfg.provider = opts.provider;
+  if (opts.model) cfg.model = opts.model;
   const provider = createProvider(cfg);
-  const tools = buildReadOnlyTools();
-  const engine = new Engine({ provider, tools, system: SYSTEM, cwd: process.cwd() });
+  const tools = opts.yolo ? buildAllTools() : buildReadOnlyTools();
+  const gate = opts.yolo ? allowAllGate : denyGate;
+  const system = opts.yolo ? YOLO_SYSTEM : READONLY_SYSTEM;
+  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);
 }
-main().catch((err) => {
-  process.stderr.write(`\u{1F4A5} ${err instanceof Error ? err.message : String(err)}
-`);
-  process.exit(1);
-});

package/package.json

@@ -1,33 +1,58 @@
-{
-  "name": "@wanghuimvp/axon",
-  "version": "0.0.1",
-  "description": "Axon — an agentic coding CLI. Streams from Anthropic, runs a multi-step tool loop over your codebase.",
-  "type": "module",
-  "bin": { "axon": "dist/cli.js" },
-  "files": ["dist"],
-  "engines": { "node": ">=20" },
-  "license": "MIT",
-  "keywords": ["cli", "agent", "agentic", "coding", "anthropic", "claude", "ai", "assistant", "axon"],
-  "repository": { "type": "git", "url": "git+https://github.com/Wade-DevCode/axon.git" },
-  "homepage": "https://github.com/Wade-DevCode/axon#readme",
-  "bugs": { "url": "https://github.com/Wade-DevCode/axon/issues" },
-  "publishConfig": { "access": "public" },
-  "scripts": {
-    "dev": "tsx src/cli.ts",
-    "test": "vitest run",
-    "build": "esbuild src/cli.ts --bundle --platform=node --format=esm --outfile=dist/cli.js --packages=external",
-    "prepublishOnly": "npm test && npm run build"
-  },
-  "dependencies": {
-    "@anthropic-ai/sdk": "^0.40.0",
-    "commander": "^12.0.0",
-    "fast-glob": "^3.3.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "esbuild": "^0.23.0",
-    "tsx": "^4.0.0",
-    "typescript": "^5.5.0",
-    "vitest": "^2.0.0"
-  }
-}
+{
+  "name": "@wanghuimvp/axon",
+  "version": "0.2.0",
+  "description": "Axon — a multi-provider agentic coding CLI (Anthropic, OpenAI + OpenAI-compatible endpoints, Gemini). Runs a multi-step tool loop over your codebase.",
+  "type": "module",
+  "bin": {
+    "axon": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "keywords": [
+    "cli",
+    "agent",
+    "agentic",
+    "coding",
+    "anthropic",
+    "claude",
+    "ai",
+    "assistant",
+    "axon"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Wade-DevCode/axon.git"
+  },
+  "homepage": "https://github.com/Wade-DevCode/axon#readme",
+  "bugs": {
+    "url": "https://github.com/Wade-DevCode/axon/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "test": "vitest run",
+    "build": "esbuild src/cli.ts --bundle --platform=node --format=esm --outfile=dist/cli.js --packages=external",
+    "prepublishOnly": "npm test && npm run build"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.40.0",
+    "@google/genai": "^1.52.0",
+    "commander": "^12.0.0",
+    "fast-glob": "^3.3.0",
+    "openai": "^4.104.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "esbuild": "^0.23.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0"
+  }
+}