aether-code 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aether (trynoguard.com)
+
+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,140 @@
+# aether-code
+
+> Uncensored AI coding agent for your terminal. Aether reads your codebase, writes code, runs commands — like Claude Code, but with no refusal layer.
+
+```bash
+npx aether-code "build me a TypeScript todo CLI in this folder"
+npx aether-code --yes "add JSDoc to every exported function in src/"
+npx aether-code --cwd ./my-project "fix the failing tests"
+```
+
+Built on the same [Aether API](https://trynoguard.com) that powers [`aether-cli`](https://www.npmjs.com/package/aether-cli), [`aether-mcp`](https://www.npmjs.com/package/aether-mcp), and the browser DevTools extension. One API key, four surfaces.
+
+## What it does
+
+`aether-code` is a CLI that runs an AI coding agent locally. It uses tool calling under the hood — the model can read files, list directories, search across your codebase, write or edit files, and run shell commands. After each tool call, it sees the result and decides what to do next, looping until the task is complete or you hit the turn limit.
+
+It's the same architecture as Claude Code or Cursor's agent mode, with two differences:
+- **Uncensored** — no refusal layer when you ask it to write security tools, RE scripts, "edgy" content, etc.
+- **Uses your existing Aether credits** — same balance pool as the chat / MCP / DevTools extension.
+
+## Install
+
+```bash
+# One-off (recommended)
+npx aether-code "your task"
+
+# Or install globally
+npm install -g aether-code
+aether-code "your task"
+```
+
+Requires Node 18+. Zero runtime dependencies.
+
+## Setup
+
+If you've already used `aether-cli`, you're done — same `~/.aetherrc` config.
+
+Otherwise:
+
+```bash
+# Generate a key at https://trynoguard.com/account, then:
+export AETHER_API_KEY=ak_live_your_key_here
+# OR — save to ~/.aetherrc (mode 0600):
+npx aether-cli config set ak_live_your_key_here
+```
+
+## Tools the agent has access to
+
+| Tool | What it does | Approval |
+|---|---|---|
+| `read_file` | Read any file as UTF-8 text | auto |
+| `list_dir` | List entries in a directory | auto |
+| `search_files` | Recursive regex search across the codebase | auto |
+| `write_file` | Create or overwrite a file (shows diff) | y/N prompt |
+| `edit_file` | Replace one occurrence of `find` with `replace` (shows diff) | y/N prompt |
+| `run_shell` | Run a shell command, capture stdout/stderr (2-min timeout) | y/N prompt |
+
+## Safety
+
+By default the agent **will not act without your approval**. Each file write and each shell command shows you exactly what's about to happen and waits for `y/N`.
+
+- **`--yes`** — auto-approve all writes and commands. Use only for trusted, scoped tasks.
+- **`--cwd <path>`** — clamp all file operations to a specific directory.
+- **`--unsafe-paths`** — opt out of the cwd-clamping. Required only if the agent legitimately needs to touch files outside the working dir (e.g. global config).
+- **2-minute hard timeout** on each shell command (kills the process if it hangs).
+- **20 KB output truncation** — long stdout/stderr is truncated before being sent back to the model so a runaway test suite can't blow up your context.
+
+## Examples
+
+### Build a small project from scratch
+
+```bash
+mkdir todo-cli && cd todo-cli
+npx aether-code "build a TypeScript CLI that manages a todo list stored in todos.json. Use commander for arg parsing. Include npm scripts for build and test."
+```
+
+The agent will: list the empty dir → `npm init -y` → install deps → write `tsconfig.json`, `src/index.ts`, `package.json` updates → run `npm run build` to verify.
+
+### Fix failing tests
+
+```bash
+cd existing-project
+npx aether-code "run the tests, see what's failing, and fix them"
+```
+
+The agent will: `run_shell("npm test")` → read the failing files → make targeted edits → re-run tests → repeat until green.
+
+### Refactor
+
+```bash
+npx aether-code --max-turns 40 "convert all CommonJS requires to ES module imports across src/, then update package.json"
+```
+
+### Add documentation across a codebase
+
+```bash
+npx aether-code --yes "add a one-line JSDoc to every exported function in src/ that doesn't have one"
+```
+
+`--yes` is reasonable here because the operation is bounded and read-mostly with small additive edits.
+
+### Reverse engineering
+
+```bash
+npx aether-code "deobfuscate ./bundle.min.js, write the cleaned version to ./bundle.clean.js, then identify what the obfuscation was protecting"
+```
+
+## What it doesn't do (yet)
+
+- **No streaming** — each turn waits for a full model response. Future work.
+- **No interactive Ctrl+C handling** — kill with the OS-level signal.
+- **No multi-step plan preview** — the agent just acts. (Manual `--max-turns 1` to inspect first move.)
+- **No persistent session** — each invocation starts fresh. Workspaces feature on the roadmap.
+
+## How it differs from Claude Code
+
+| | Claude Code | aether-code |
+|---|---|---|
+| Refusal layer | Yes (Anthropic policy) | No |
+| Cost model | Per Anthropic API token | Aether credits (pay-per-use, crypto top-up) |
+| Streaming | Yes | Not yet |
+| Plan mode | Yes | Not yet |
+| MCP support | Yes (Anthropic's MCP) | Not yet (independent of `aether-mcp`) |
+| Open source | No | Yes (MIT) |
+
+## Privacy
+
+- Your prompts, file reads, and shell outputs go to `trynoguard.com/api/v1/agent` only.
+- Conversations are not stored server-side (no `Conversation` row, no `Message` rows). The agent endpoint is stateless beyond credit accounting.
+- Source code is plain ES modules. Read it before you trust it.
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+## Related
+
+- **[aether-cli](https://www.npmjs.com/package/aether-cli)** — non-agentic CLI for one-off prompts (`aether ask`, `deobf`, `explain`, etc.).
+- **[aether-mcp](https://www.npmjs.com/package/aether-mcp)** — MCP server. Use Aether inside Claude Desktop / Cursor / Cline / Zed.
+- **[aether-devtools](https://github.com/dannyphantomx64/aether-devtools)** — browser DevTools extension.

package/bin/aether-code.js

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+// aether-code — uncensored AI coding agent.
+//
+// Examples:
+//   aether-code "build me a TypeScript todo CLI in this folder"
+//   aether-code --yes "add JSDoc to every exported function in src/"
+//   aether-code --cwd ./my-project "fix the failing tests"
+//   aether-code --max-turns 40 "refactor the auth module to use bcrypt"
+
+import process from "node:process";
+import path from "node:path";
+import { runAgent } from "../src/agent.js";
+import { runRepl } from "../src/repl.js";
+import { runSetup } from "../src/setup.js";
+import { fetchBalance, AetherError } from "../src/api.js";
+import { writeConfigFile, getConfig, CONFIG_PATH } from "../src/config.js";
+import { c, errorLine, divider } from "../src/render.js";
+
+const VERSION = "0.3.0";
+
+const HELP = `${c.bold("aether")} — uncensored AI coding agent
+
+${c.bold("USAGE")}
+  aether                               Launch interactive REPL (Claude-CLI-style)
+  aether [flags] "<task>"              Run agent once on a single task
+  aether <subcommand> [args]           Run a utility subcommand
+
+${c.bold("SUBCOMMANDS")}
+  ${c.cyan("login")}                                Open browser, paste API key, save
+  ${c.cyan("logout")}                               Clear saved API key
+  ${c.cyan("balance")}                              Show plan + credit balance
+  ${c.cyan("config")} show|set|set-base|path        Manage config file
+
+${c.bold("EXAMPLES")}
+  aether                               # interactive REPL
+  aether login                         # first-time setup
+  aether balance                       # quick credit check
+  aether "build a TypeScript todo CLI in this folder"
+  aether --yes "add JSDoc to every exported function"
+  aether --cwd ./my-project "fix the failing tests"
+
+${c.bold("FLAGS")}
+  --yes              Auto-approve all writes and shell commands. Use with care.
+  --cwd <path>       Working directory for the agent (default: current dir).
+  --max-turns <n>    Maximum turns before stopping (default: 25).
+  --unsafe-paths     Allow the agent to read/write outside cwd.
+  --help, -h         Show this help.
+  --version, -v      Print version.
+
+${c.bold("CONFIG")}
+  Same config as aether-cli — uses ${c.cyan("AETHER_API_KEY")} or ${c.cyan("~/.aetherrc")}.
+  Get a key at ${c.blue("https://trynoguard.com/account")}.
+
+${c.bold("SAFETY")}
+  - File writes show a unified diff and require y/N confirmation by default.
+  - Shell commands show what's about to run and require y/N confirmation.
+  - Paths are clamped to ${c.cyan("--cwd")} (override with ${c.cyan("--unsafe-paths")}).
+  - Each shell command has a 2-minute hard timeout.
+
+${c.gray(`v${VERSION}`)}
+`;
+
+function parseArgs(argv) {
+  const args = { _: [], flags: {} };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--yes") { args.flags.yes = true; }
+    else if (a === "--unsafe-paths") { args.flags.unsafePaths = true; }
+    else if (a === "--help" || a === "-h") { args.flags.help = true; }
+    else if (a === "--version" || a === "-v") { args.flags.version = true; }
+    else if (a === "--cwd") { args.flags.cwd = argv[++i]; }
+    else if (a === "--max-turns") { args.flags.maxTurns = parseInt(argv[++i], 10); }
+    else if (a.startsWith("--")) {
+      const eq = a.indexOf("=");
+      if (eq >= 0) args.flags[a.slice(2, eq)] = a.slice(eq + 1);
+      else args.flags[a.slice(2)] = true;
+    } else {
+      args._.push(a);
+    }
+  }
+  return args;
+}
+
+function die(msg, code = 1) {
+  process.stderr.write(errorLine(msg) + "\n");
+  process.exit(code);
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  if (args.flags.help) {
+    process.stdout.write(HELP);
+    return;
+  }
+  if (args.flags.version) {
+    process.stdout.write(`aether-code ${VERSION}\n`);
+    return;
+  }
+
+  const cwd = args.flags.cwd ? path.resolve(args.flags.cwd) : process.cwd();
+  const autoYes = !!args.flags.yes;
+  const unsafePaths = !!args.flags.unsafePaths;
+  const maxTurns = Number.isInteger(args.flags.maxTurns) ? args.flags.maxTurns : 25;
+
+  // Subcommand routing — these shadow the "task as positional arg" mode
+  const sub = args._[0]?.toLowerCase();
+  if (sub === "login" || sub === "auth") {
+    const ok = await runSetup();
+    process.exit(ok ? 0 : 1);
+  }
+  if (sub === "logout") {
+    writeConfigFile({ apiKey: "" });
+    console.log(c.gray(`Cleared API key from ${CONFIG_PATH}.`));
+    return;
+  }
+  if (sub === "config") {
+    await handleConfig(args._.slice(1));
+    return;
+  }
+  if (sub === "balance") {
+    await handleBalance();
+    return;
+  }
+
+  const prompt = args._.join(" ").trim();
+
+  // No task → drop into interactive REPL (Claude-CLI-style)
+  if (!prompt) {
+    if (cwd !== process.cwd()) process.chdir(cwd);
+    await runRepl({ cwd, autoYes, maxTurns });
+    return;
+  }
+
+  // One-shot mode also needs an API key. If missing, run setup before the task.
+  const cfg = getConfig();
+  if (!cfg.apiKey) {
+    const ok = await runSetup();
+    if (!ok) process.exit(1);
+  }
+
+  console.log(divider());
+  console.log(c.magenta(c.bold("aether-code")) + c.gray(` · cwd ${cwd}${autoYes ? " · auto-yes" : ""}${unsafePaths ? " · unsafe-paths" : ""}`));
+  console.log(c.gray(`task: `) + prompt);
+  console.log(divider());
+
+  const result = await runAgent({
+    initialPrompt: prompt,
+    cwd,
+    autoYes,
+    unsafePaths,
+    maxTurns,
+  });
+
+  console.log("\n" + divider());
+  if (result.ok) {
+    console.log(c.green(c.bold("✓ Done")) + c.gray(`  ${result.turns} turn${result.turns === 1 ? "" : "s"} · ${result.totalCredits} credits · ${result.totalIn}→${result.totalOut} tokens`));
+    if (typeof result.balance === "number") {
+      console.log(c.gray(`  balance: ${result.balance.toLocaleString()} credits`));
+    }
+  } else {
+    console.log(c.red(c.bold("✗ Stopped")) + c.gray(`  ${result.totalCredits} credits used · ${result.totalIn}→${result.totalOut} tokens`));
+    if (result.error) console.log(errorLine(result.error.message));
+  }
+  console.log(divider());
+}
+
+async function handleConfig(rest) {
+  const sub = (rest[0] || "").toLowerCase();
+  if (sub === "show" || !sub) {
+    const cfg = getConfig();
+    console.log(`Config file: ${cfg.configPath}`);
+    console.log(`API key:     ${cfg.apiKey ? cfg.apiKey.slice(0, 12) + "…" + cfg.apiKey.slice(-4) : c.gray("(none)")}`);
+    console.log(`Base URL:    ${cfg.baseUrl}`);
+    console.log(`Source:      ${process.env.AETHER_API_KEY ? "AETHER_API_KEY env" : "config file"}`);
+    return;
+  }
+  if (sub === "set") {
+    const key = rest[1];
+    if (!key) die("config set: missing API key argument.");
+    if (!key.startsWith("ak_live_")) {
+      process.stderr.write(c.yellow("warning: keys normally start with ak_live_; saving anyway.\n"));
+    }
+    writeConfigFile({ apiKey: key });
+    console.log(`${c.green("✓")} API key saved to ${CONFIG_PATH}`);
+    return;
+  }
+  if (sub === "set-base") {
+    const url = rest[1];
+    if (!url) die("config set-base: missing URL argument.");
+    writeConfigFile({ baseUrl: url });
+    console.log(`${c.green("✓")} Base URL saved.`);
+    return;
+  }
+  if (sub === "path") {
+    console.log(CONFIG_PATH);
+    return;
+  }
+  die(`config: unknown subcommand "${sub}". Try 'config show', 'config set <key>', 'config path'.`);
+}
+
+async function handleBalance() {
+  try {
+    const me = await fetchBalance();
+    console.log(c.bold(c.magenta("Aether")));
+    console.log(c.gray("─".repeat(50)));
+    console.log(`Plan      ${c.cyan(me.plan)}${me.role !== "USER" ? c.gray(` · ${me.role}`) : ""}`);
+    console.log(`Balance   ${c.bold(me.balance.toLocaleString())} credits`);
+    console.log(`  plan    ${me.planCredits.toLocaleString()}`);
+    console.log(`  topup   ${me.topupCredits.toLocaleString()}`);
+    if (me.rate) {
+      console.log(`Rate      ${me.rate.used}/${me.rate.limit} this hour${me.rate.resetIn ? ` · resets in ${me.rate.resetIn}s` : ""}`);
+    }
+    if (me.isSuspended) console.log(c.red("\n⚠ Account is suspended."));
+  } catch (err) {
+    if (err instanceof AetherError && err.code === "NO_API_KEY") {
+      console.log(errorLine("No API key. Run `aether login` first."));
+    } else {
+      die(err.message || String(err));
+    }
+  }
+}
+
+main().catch((err) => {
+  console.error(errorLine(err.message || String(err)));
+  if (process.env.DEBUG) console.error(err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "aether-code",
+  "version": "0.3.0",
+  "description": "Uncensored AI coding agent for your terminal. Type `aether` to launch the interactive REPL — like Claude Code, with no refusal layer.",
+  "homepage": "https://trynoguard.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dannyphantomx64/aether-code"
+  },
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "aether": "bin/aether-code.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "lint": "node --check bin/aether-code.js src/agent.js src/api.js src/config.js src/render.js src/tools.js src/diff.js src/repl.js"
+  },
+  "keywords": [
+    "aether",
+    "uncensored",
+    "ai",
+    "coding-agent",
+    "claude-code-alternative",
+    "agent",
+    "cli",
+    "tool-use",
+    "agentic"
+  ]
+}

package/src/agent.js

@@ -0,0 +1,115 @@
+// Agent loop. Streams each turn from /api/v1/agent/stream, prints text deltas
+// in real-time, executes any tool calls, loops until the model returns no
+// tool calls (task done) or max-turns is reached.
+
+import { agentTurnStream, AetherError } from "./api.js";
+import { TOOL_DEFINITIONS, executeTool } from "./tools.js";
+import { c, divider, turn, toolHeader, toolResult, errorLine } from "./render.js";
+
+const DEFAULT_MAX_TURNS = 25;
+
+export async function runAgent({
+  initialPrompt,
+  priorMessages,
+  cwd,
+  autoYes = false,
+  unsafePaths = false,
+  maxTurns = DEFAULT_MAX_TURNS,
+  onTokens = () => {},
+}) {
+  // Two callers: one-shot (initialPrompt only, fresh conversation) and REPL
+  // (priorMessages + initialPrompt to continue an ongoing chat).
+  const messages = priorMessages
+    ? [...priorMessages, { role: "user", content: initialPrompt }]
+    : [{ role: "user", content: initialPrompt }];
+  let totalCredits = 0;
+  let totalIn = 0;
+  let totalOut = 0;
+  let lastBalance = null;
+
+  for (let i = 0; i < maxTurns; i++) {
+    process.stdout.write("\n" + turn(i + 1) + "\n");
+
+    // Stream the assistant's response. Print text deltas as they arrive,
+    // along with tool-call announcements as soon as the model commits to
+    // calling a particular tool (i.e. the `name` arrives in the stream).
+    const announced = new Set();
+    let lastWasText = false;
+
+    let res;
+    try {
+      res = await agentTurnStream({
+        messages,
+        tools: TOOL_DEFINITIONS,
+        onDelta: (text) => {
+          if (!lastWasText) {
+            process.stdout.write("  ");
+            lastWasText = true;
+          }
+          process.stdout.write(text);
+        },
+        onToolCallDelta: (delta) => {
+          // Print the tool header once we know the name (first chunk for that index)
+          if (delta.name && !announced.has(delta.index)) {
+            announced.add(delta.index);
+            if (lastWasText) process.stdout.write("\n");
+            lastWasText = false;
+            process.stdout.write(c.cyan(c.bold(delta.name)) + c.gray("(...)") + c.gray(" preparing args\n"));
+          }
+        },
+      });
+    } catch (err) {
+      if (err instanceof AetherError) {
+        return { ok: false, error: err, totalCredits, totalIn, totalOut, balance: lastBalance, messages };
+      }
+      throw err;
+    }
+
+    // End-of-turn newline + cost meter
+    if (lastWasText) process.stdout.write("\n");
+    totalCredits += res.creditsCharged ?? 0;
+    totalIn += res.usage?.prompt_tokens ?? 0;
+    totalOut += res.usage?.completion_tokens ?? 0;
+    if (typeof res.balanceAfter === "number") lastBalance = res.balanceAfter;
+    onTokens({ totalCredits, totalIn, totalOut, balance: lastBalance });
+    process.stdout.write(
+      c.dim(`  ${res.creditsCharged ?? 0} cr · ${res.usage?.prompt_tokens ?? 0}→${res.usage?.completion_tokens ?? 0} tokens · finish: ${res.finish_reason}\n`),
+    );
+
+    // Push assistant message into history
+    messages.push({
+      role: "assistant",
+      content: res.message.content,
+      tool_calls: res.message.tool_calls,
+    });
+
+    const toolCalls = res.message.tool_calls ?? [];
+    if (toolCalls.length === 0) {
+      return { ok: true, totalCredits, totalIn, totalOut, turns: i + 1, balance: lastBalance, messages };
+    }
+
+    // Execute each tool call. Show the actual args (now that we have them
+    // fully assembled) and run.
+    for (const call of toolCalls) {
+      let args = {};
+      try { args = JSON.parse(call.function.arguments || "{}"); } catch { /* leave empty */ }
+      console.log("");
+      console.log(toolHeader(call.function.name, args));
+
+      const result = await executeTool(call, { cwd, autoYes, unsafePaths });
+      if (result.output) {
+        const preview = result.output.length > 800 ? result.output.slice(0, 800) + "\n…(truncated)" : result.output;
+        console.log(toolResult(preview, result.ok));
+      }
+
+      messages.push({
+        role: "tool",
+        tool_call_id: call.id,
+        content: result.output ?? (result.ok ? "(no output)" : "Failed."),
+      });
+    }
+  }
+
+  console.log(c.yellow(`\nReached max turns (${maxTurns}). Stopping.`));
+  return { ok: false, error: new Error("Max turns reached"), totalCredits, totalIn, totalOut, balance: lastBalance, messages };
+}