@wanghuimvp/axon 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Wade
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

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

package/dist/cli.js

@@ -0,0 +1,421 @@
+#!/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 DEFAULTS = {
+  provider: "anthropic",
+  model: "claude-opus-4-8",
+  providers: {
+    anthropic: { apiKey: "env:ANTHROPIC_API_KEY" }
+  }
+};
+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 ?? DEFAULTS.provider,
+    model: fileCfg.model ?? DEFAULTS.model,
+    providers: { ...DEFAULTS.providers, ...fileCfg.providers ?? {} }
+  };
+  return resolveEnvRefs(merged);
+}
+
+// src/providers/registry.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// 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/registry.ts
+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 });
+  }
+  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 fg from "fast-glob";
+
+// src/tools/paths.ts
+import { resolve, relative, isAbsolute, sep } from "node:path";
+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}`);
+  }
+}
+
+// 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(join2(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/registry.ts
+function buildReadOnlyTools() {
+  const tools = [readFileTool, listDirTool, globTool, grepTool];
+  return new Map(tools.map((t) => [t.name, t]));
+}
+
+// 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;
+        }
+        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/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 program = new Command();
+program.name("axon").version(VERSION).option("-p, --print <prompt>", "run one prompt non-interactively and stream the result");
+program.parse();
+var opts = program.opts();
+async function main() {
+  if (!opts.print) {
+    process.stdout.write('Interactive TUI not built yet \u2014 use: axon -p "your prompt"\n');
+    return;
+  }
+  const cfg = loadConfig();
+  const provider = createProvider(cfg);
+  const tools = buildReadOnlyTools();
+  const engine = new Engine({ provider, tools, system: SYSTEM, cwd: process.cwd() });
+  printRunner(engine, (s) => process.stdout.write(s));
+  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

@@ -0,0 +1,33 @@
+{
+  "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"
+  }
+}