aether-code 0.3.0

package/src/api.js

@@ -0,0 +1,234 @@
+// API client.
+
+import { getConfig } from "./config.js";
+
+/**
+ * Free balance + plan check via /api/v1/me. Doesn't charge credits.
+ */
+export async function fetchBalance() {
+  const { apiKey, baseUrl } = getConfig();
+  if (!apiKey) {
+    throw new AetherError(
+      "No API key. Set AETHER_API_KEY or run `aether config set <key>`.",
+      "NO_API_KEY",
+      0,
+    );
+  }
+  let res;
+  try {
+    res = await fetch(`${baseUrl}/api/v1/me`, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${apiKey}`,
+        "User-Agent": "aether-code/0.2.0",
+      },
+    });
+  } catch (e) {
+    throw new AetherError(`Network error: ${e.message}`, "NETWORK", 0);
+  }
+  let data = null;
+  try { data = await res.json(); } catch { /* non-JSON */ }
+  if (!res.ok) {
+    const code = data?.code || `HTTP_${res.status}`;
+    const msg = data?.error || `${res.status} ${res.statusText}`;
+    throw new AetherError(msg, code, res.status, data);
+  }
+  return data; // { plan, role, planCredits, topupCredits, balance, isSuspended, rate }
+}
+
+export class AetherError extends Error {
+  constructor(message, code, status, data) {
+    super(message);
+    this.name = "AetherError";
+    this.code = code;
+    this.status = status;
+    this.data = data;
+  }
+}
+
+/**
+ * Streaming agent turn. Calls /api/v1/agent/stream and invokes the supplied
+ * callbacks as events arrive. Returns the assembled assistant message + final
+ * usage/credit info once the stream ends.
+ *
+ * Event handlers (all optional):
+ *   onDelta(text)            — text fragment from the model
+ *   onToolCallDelta(part)    — partial tool call: { index, id?, name?, args_delta? }
+ *   onFinish(reason)         — per-choice finish reason ("stop" | "tool_calls" | "length")
+ *
+ * Returns:
+ *   { message: { role:"assistant", content, tool_calls }, finish_reason,
+ *     creditsCharged, balanceAfter, usage }
+ */
+export async function agentTurnStream({
+  messages,
+  tools,
+  maxTokens,
+  temperature,
+  onDelta,
+  onToolCallDelta,
+  onFinish,
+}) {
+  const { apiKey, baseUrl } = getConfig();
+  if (!apiKey) {
+    throw new AetherError(
+      "No API key. Set AETHER_API_KEY or run `aether config set <key>`.",
+      "NO_API_KEY",
+      0,
+    );
+  }
+
+  let res;
+  try {
+    res = await fetch(`${baseUrl}/api/v1/agent/stream`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "text/event-stream",
+        Authorization: `Bearer ${apiKey}`,
+        "User-Agent": "aether-code/0.1.0",
+      },
+      body: JSON.stringify({
+        messages,
+        tools,
+        max_tokens: maxTokens,
+        temperature,
+      }),
+    });
+  } catch (e) {
+    throw new AetherError(`Network error: ${e.message}`, "NETWORK", 0);
+  }
+
+  // Non-streaming JSON error response (auth, credit, validation failures)
+  if (!res.ok) {
+    let data = null;
+    try { data = await res.json(); } catch { /* non-JSON */ }
+    const code = data?.code || `HTTP_${res.status}`;
+    const msg = data?.error || `${res.status} ${res.statusText}`;
+    throw new AetherError(msg, code, res.status, data);
+  }
+  if (!res.body) throw new AetherError("Response has no body", "NO_BODY", res.status);
+
+  // Accumulate streaming state
+  let textBuf = "";
+  const toolBuf = new Map(); // index -> { id, name, args }
+  let finishReason = "stop";
+  let creditsCharged = 0;
+  let balanceAfter = null;
+  let usage = { prompt_tokens: 0, completion_tokens: 0 };
+  let streamError = null;
+
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      if (!line.startsWith("data:")) continue;
+      const json = line.slice(5).trim();
+      if (!json) continue;
+      let evt;
+      try { evt = JSON.parse(json); } catch { continue; }
+      if (evt.kind === "delta") {
+        textBuf += evt.content;
+        if (onDelta) onDelta(evt.content);
+      } else if (evt.kind === "tool_call_delta") {
+        const slot = toolBuf.get(evt.index) || { id: undefined, name: undefined, args: "" };
+        if (evt.id) slot.id = evt.id;
+        if (evt.name) slot.name = evt.name;
+        if (evt.args_delta) slot.args += evt.args_delta;
+        toolBuf.set(evt.index, slot);
+        if (onToolCallDelta) onToolCallDelta(evt);
+      } else if (evt.kind === "finish") {
+        finishReason = evt.reason;
+        if (onFinish) onFinish(evt.reason);
+      } else if (evt.kind === "done") {
+        creditsCharged = evt.creditsCharged ?? 0;
+        balanceAfter = evt.balanceAfter ?? null;
+        usage = evt.usage ?? usage;
+      } else if (evt.kind === "error") {
+        streamError = evt.error;
+      }
+    }
+  }
+
+  if (streamError) {
+    throw new AetherError(streamError, "STREAM_ERROR", 0);
+  }
+
+  // Assemble final tool_calls in stable index order
+  const tool_calls = [...toolBuf.entries()]
+    .sort((a, b) => a[0] - b[0])
+    .map(([, slot]) => ({
+      id: slot.id || `call_${Math.random().toString(36).slice(2, 10)}`,
+      type: "function",
+      function: { name: slot.name || "", arguments: slot.args || "" },
+    }));
+
+  return {
+    message: {
+      role: "assistant",
+      content: textBuf || null,
+      tool_calls: tool_calls.length > 0 ? tool_calls : undefined,
+    },
+    finish_reason: finishReason,
+    creditsCharged,
+    balanceAfter,
+    usage,
+  };
+}
+
+/**
+ * Non-streaming variant — kept as a fallback for environments where SSE is
+ * problematic (corporate proxies, weird client setups). The CLI defaults to
+ * streaming.
+ */
+export async function agentTurn({ messages, tools, maxTokens, temperature }) {
+  const { apiKey, baseUrl } = getConfig();
+  if (!apiKey) {
+    throw new AetherError(
+      "No API key. Set AETHER_API_KEY env var or run `aether-cli config set <key>`.",
+      "NO_API_KEY",
+      0,
+    );
+  }
+
+  let res;
+  try {
+    res = await fetch(`${baseUrl}/api/v1/agent`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+        "User-Agent": "aether-code/0.1.0",
+      },
+      body: JSON.stringify({
+        messages,
+        tools,
+        max_tokens: maxTokens,
+        temperature,
+      }),
+    });
+  } catch (e) {
+    throw new AetherError(`Network error: ${e.message}`, "NETWORK", 0);
+  }
+
+  let data = null;
+  try {
+    data = await res.json();
+  } catch {
+    /* non-JSON */
+  }
+
+  if (!res.ok) {
+    const code = (data && data.code) || `HTTP_${res.status}`;
+    const msg = (data && data.error) || `${res.status} ${res.statusText}`;
+    throw new AetherError(msg, code, res.status, data);
+  }
+  return data;
+}

package/src/config.js

@@ -0,0 +1,38 @@
+// Config — reads ~/.aetherrc (shared format with aether-cli) and env vars.
+// Same precedence: env wins over file.
+
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+const FILE = path.join(os.homedir(), ".aetherrc");
+const DEFAULT_BASE = "https://trynoguard.com";
+
+export function readConfigFile() {
+  try {
+    const raw = fs.readFileSync(FILE, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+export function writeConfigFile(patch) {
+  const current = readConfigFile();
+  const next = { ...current, ...patch };
+  // 0600 — readable only by the user. Mirrors what ssh, gnupg, etc. enforce
+  // on credential files. Treat the API key like an SSH key.
+  fs.writeFileSync(FILE, JSON.stringify(next, null, 2), { mode: 0o600 });
+  try { fs.chmodSync(FILE, 0o600); } catch { /* windows ignores */ }
+}
+
+export function getConfig() {
+  const file = readConfigFile();
+  return {
+    apiKey: process.env.AETHER_API_KEY || file.apiKey || "",
+    baseUrl: (process.env.AETHER_BASE_URL || file.baseUrl || DEFAULT_BASE).replace(/\/+$/, ""),
+    configPath: FILE,
+  };
+}
+
+export const CONFIG_PATH = FILE;

package/src/diff.js

@@ -0,0 +1,48 @@
+// Tiny line-by-line diff for write_file confirmation prompts.
+// Not a "real" diff — just a side-by-side highlight of what's changing.
+// Good enough for confirmation prompts, deliberately not pretending to be `git diff`.
+
+import { c } from "./render.js";
+
+export function unifiedDiff(oldText, newText, filename) {
+  const oldLines = (oldText || "").split("\n");
+  const newLines = (newText || "").split("\n");
+  const max = Math.max(oldLines.length, newLines.length);
+
+  // Find common prefix and suffix to keep the diff focused
+  let prefix = 0;
+  while (prefix < max && oldLines[prefix] === newLines[prefix]) prefix++;
+  let suffix = 0;
+  while (
+    suffix < max - prefix &&
+    oldLines[oldLines.length - 1 - suffix] === newLines[newLines.length - 1 - suffix]
+  ) {
+    suffix++;
+  }
+
+  const changedOld = oldLines.slice(prefix, oldLines.length - suffix);
+  const changedNew = newLines.slice(prefix, newLines.length - suffix);
+
+  const lines = [];
+  lines.push(c.bold(c.cyan(`@@ ${filename} @@`)));
+  if (prefix > 0) lines.push(c.gray(`  …${prefix} unchanged line${prefix === 1 ? "" : "s"} above…`));
+  for (const l of changedOld) lines.push(c.red(`- ${l}`));
+  for (const l of changedNew) lines.push(c.green(`+ ${l}`));
+  if (suffix > 0) lines.push(c.gray(`  …${suffix} unchanged line${suffix === 1 ? "" : "s"} below…`));
+
+  // Cap output so massive writes don't flood the terminal
+  if (lines.length > 60) {
+    return [...lines.slice(0, 30), c.gray(`  …${lines.length - 60} more lines hidden…`), ...lines.slice(-30)].join(
+      "\n",
+    );
+  }
+  return lines.join("\n");
+}
+
+export function summarizeWrite(oldText, newText, filename) {
+  const oldLines = (oldText || "").split("\n").length;
+  const newLines = (newText || "").split("\n").length;
+  const isCreate = oldText === null || oldText === undefined;
+  const verb = isCreate ? "create" : "rewrite";
+  return c.dim(`${verb} ${filename} (${oldLines} → ${newLines} lines, ${(newText || "").length} bytes)`);
+}

package/src/render.js

@@ -0,0 +1,58 @@
+// ANSI helpers — no chalk dependency.
+
+const isTty = process.stdout.isTTY;
+const noColor = !!process.env.NO_COLOR || !isTty;
+
+function wrap(open, close) {
+  return (s) => (noColor ? String(s) : `\x1b[${open}m${s}\x1b[${close}m`);
+}
+
+export const c = {
+  bold:    wrap(1, 22),
+  dim:     wrap(2, 22),
+  red:     wrap(31, 39),
+  green:   wrap(32, 39),
+  yellow:  wrap(33, 39),
+  blue:    wrap(34, 39),
+  magenta: wrap(35, 39),
+  cyan:    wrap(36, 39),
+  gray:    wrap(90, 39),
+};
+
+export function divider() {
+  const w = process.stdout.columns || 60;
+  return c.gray("─".repeat(Math.min(60, w)));
+}
+
+export function turn(n) {
+  return c.gray(`turn ${n}`);
+}
+
+export function toolHeader(name, args) {
+  // Format args compactly. If any value is huge, truncate it.
+  const compact = JSON.stringify(args);
+  const trimmed = compact.length > 120 ? compact.slice(0, 117) + "..." : compact;
+  return `${c.cyan(c.bold(name))}${c.gray("(")}${c.gray(trimmed)}${c.gray(")")}`;
+}
+
+export function toolResult(text, ok = true) {
+  const prefix = ok ? c.green("  ✓ ") : c.red("  ✗ ");
+  // First line bold-ish, then dim continuation
+  const lines = text.split("\n");
+  const head = lines[0].slice(0, 200);
+  const rest = lines.slice(1, 6).join("\n").slice(0, 600);
+  return `${prefix}${head}${rest ? "\n" + c.dim(rest) : ""}`;
+}
+
+export function assistant(text) {
+  // Indent each line for visual separation from tool calls
+  return text.split("\n").map((l) => `  ${l}`).join("\n");
+}
+
+export function errorLine(msg) {
+  return `${c.red(c.bold("Error:"))} ${msg}`;
+}
+
+export function note(msg) {
+  return c.dim(msg);
+}

package/src/repl.js

@@ -0,0 +1,246 @@
+// Interactive REPL — Claude-CLI-style. Launched when `aether-code` is run
+// without a task argument.
+//
+// Behaviors:
+//   - Banner on startup (version, model, balance, cwd, mode)
+//   - Persistent message history across prompts within the session
+//   - Slash commands: /help, /exit, /clear, /balance, /cwd, /yes, /turns
+//   - Bottom status line is rendered after each turn
+//   - Ctrl+C: first press cancels in-progress turn, second press exits
+
+import readline from "node:readline";
+import path from "node:path";
+import { runAgent } from "./agent.js";
+import { fetchBalance, AetherError } from "./api.js";
+import { runSetup } from "./setup.js";
+import { c, errorLine } from "./render.js";
+
+const VERSION = "0.2.0";
+const MODEL_NAME = "Aether Core";
+
+const SHORTCUTS = `
+  ${c.cyan("/help")}      Show this help
+  ${c.cyan("/exit")}      Exit (or Ctrl+C twice)
+  ${c.cyan("/clear")}     Clear conversation history (start fresh)
+  ${c.cyan("/balance")}   Refresh and show credit balance
+  ${c.cyan("/cwd")} ${c.gray("[path]")}    Show or change working directory
+  ${c.cyan("/yes")}       Toggle auto-approve mode (skip y/N prompts)
+  ${c.cyan("/turns")} ${c.gray("<n>")}     Set max turns per prompt (default 25)
+  ${c.cyan("/model")}     Show current model
+
+${c.gray("Anything else is sent to the agent as your next message.")}
+${c.gray("Conversation history is kept across messages until you /clear.")}
+`;
+
+export async function runRepl({ cwd: initialCwd, autoYes: initialAutoYes, maxTurns: initialMaxTurns }) {
+  const state = {
+    cwd: initialCwd,
+    autoYes: !!initialAutoYes,
+    maxTurns: initialMaxTurns ?? 25,
+    messages: [], // accumulates across turns
+    balance: null,
+    sessionCredits: 0,
+    sessionIn: 0,
+    sessionOut: 0,
+  };
+
+  // Free balance check up front. If no key configured, walk through first-time
+  // setup flow (open browser → paste key → verify → save).
+  let needsSetup = false;
+  try {
+    const me = await fetchBalance();
+    state.balance = me.balance;
+    state.plan = me.plan;
+  } catch (err) {
+    if (err instanceof AetherError && (err.code === "NO_API_KEY" || err.status === 401)) {
+      needsSetup = true;
+    } else {
+      // Transient network or other — surface but don't block
+      console.log(c.gray(`(could not fetch balance: ${err.message})`));
+    }
+  }
+
+  if (needsSetup) {
+    const ok = await runSetup();
+    if (!ok) {
+      console.log(c.gray("Aborting — no valid API key."));
+      process.exit(1);
+    }
+    // Re-fetch balance now that the key is saved
+    try {
+      const me = await fetchBalance();
+      state.balance = me.balance;
+      state.plan = me.plan;
+    } catch { /* tolerate — banner just won't show balance */ }
+  }
+
+  printBanner(state);
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: c.magenta("> "),
+    historySize: 200,
+  });
+
+  // Two-stage Ctrl+C: first cancels current line, second exits
+  let lastSigint = 0;
+  rl.on("SIGINT", () => {
+    const now = Date.now();
+    if (now - lastSigint < 1500) {
+      console.log(c.gray("\nbye."));
+      rl.close();
+      process.exit(0);
+    }
+    lastSigint = now;
+    console.log(c.gray(`\n(Press Ctrl+C again within 1.5s to exit, or type ${c.cyan("/exit")})`));
+    rl.prompt();
+  });
+
+  rl.prompt();
+
+  for await (const rawLine of rl) {
+    const line = rawLine.trim();
+    if (!line) {
+      rl.prompt();
+      continue;
+    }
+
+    // Slash command?
+    if (line.startsWith("/") || line === "?") {
+      const handled = await handleSlash(line, state);
+      if (handled === "exit") {
+        rl.close();
+        return;
+      }
+      printStatusLine(state);
+      rl.prompt();
+      continue;
+    }
+
+    // Otherwise — send as a message to the agent
+    const result = await runAgent({
+      initialPrompt: line,
+      priorMessages: state.messages.length > 0 ? state.messages : undefined,
+      cwd: state.cwd,
+      autoYes: state.autoYes,
+      maxTurns: state.maxTurns,
+    });
+
+    state.sessionCredits += result.totalCredits ?? 0;
+    state.sessionIn += result.totalIn ?? 0;
+    state.sessionOut += result.totalOut ?? 0;
+    if (typeof result.balance === "number") state.balance = result.balance;
+    if (result.messages) state.messages = result.messages;
+
+    if (!result.ok && result.error) {
+      console.log("\n" + errorLine(result.error.message || String(result.error)));
+      // Don't kill the session on a single error — surface it and continue.
+    }
+
+    printStatusLine(state);
+    rl.prompt();
+  }
+}
+
+/* ───────── slash commands ───────── */
+
+async function handleSlash(line, state) {
+  const [cmd, ...rest] = line.replace(/^\//, "").split(/\s+/);
+  const arg = rest.join(" ").trim();
+
+  switch ((cmd || "").toLowerCase()) {
+    case "":
+    case "help":
+    case "?":
+      console.log(SHORTCUTS);
+      break;
+    case "exit":
+    case "quit":
+    case "q":
+      console.log(c.gray("bye."));
+      return "exit";
+    case "clear":
+      state.messages = [];
+      state.sessionCredits = 0;
+      state.sessionIn = 0;
+      state.sessionOut = 0;
+      console.log(c.gray("Conversation cleared."));
+      break;
+    case "balance": {
+      try {
+        const me = await fetchBalance();
+        state.balance = me.balance;
+        state.plan = me.plan;
+        console.log(
+          c.cyan(`balance: ${me.balance.toLocaleString()} credits`) +
+            c.gray(` · plan: ${me.plan} (${me.planCredits} plan + ${me.topupCredits} topup)`),
+        );
+      } catch (err) {
+        console.log(errorLine(err.message || String(err)));
+      }
+      break;
+    }
+    case "cwd":
+      if (arg) {
+        const next = path.resolve(arg);
+        try {
+          process.chdir(next);
+          state.cwd = next;
+          console.log(c.gray(`cwd → ${state.cwd}`));
+        } catch (err) {
+          console.log(errorLine(err.message));
+        }
+      } else {
+        console.log(c.gray(`cwd: ${state.cwd}`));
+      }
+      break;
+    case "yes":
+      state.autoYes = !state.autoYes;
+      console.log(c.gray(`auto-yes: ${state.autoYes ? "on (writes/shells will skip y/N)" : "off"}`));
+      break;
+    case "turns": {
+      const n = parseInt(arg, 10);
+      if (!Number.isFinite(n) || n < 1 || n > 200) {
+        console.log(errorLine(`/turns expects 1..200, got "${arg}"`));
+      } else {
+        state.maxTurns = n;
+        console.log(c.gray(`max turns: ${state.maxTurns}`));
+      }
+      break;
+    }
+    case "model":
+      console.log(c.gray(`model: ${MODEL_NAME} · 1M context · uncensored`));
+      break;
+    default:
+      console.log(errorLine(`Unknown command: /${cmd}. Type ${c.cyan("/help")} for shortcuts.`));
+  }
+  return null;
+}
+
+/* ───────── banner + status ───────── */
+
+function printBanner(state) {
+  console.log("");
+  console.log(c.bold(c.magenta(`aether-code`)) + c.gray(`  v${VERSION}`));
+  console.log(
+    c.gray(`${MODEL_NAME} (1M context) · uncensored · `) +
+      c.cyan(state.autoYes ? "auto-yes" : "review mode") +
+      (state.balance != null ? c.gray(`  ·  ${state.balance.toLocaleString()} credits`) : ""),
+  );
+  console.log(c.gray(state.cwd));
+  console.log("");
+  console.log(c.gray(`Type ${c.cyan("/help")} for shortcuts. ${c.cyan("/exit")} or Ctrl+C twice to quit.`));
+  console.log("");
+}
+
+function printStatusLine(state) {
+  const parts = [];
+  parts.push(c.gray(`session: ${state.sessionCredits} cr · ${state.sessionIn}→${state.sessionOut} tokens`));
+  if (state.balance != null) parts.push(c.gray(`balance: ${state.balance.toLocaleString()}`));
+  if (state.messages.length > 0) {
+    parts.push(c.gray(`history: ${state.messages.length} msg${state.messages.length === 1 ? "" : "s"}`));
+  }
+  parts.push(c.cyan(state.autoYes ? "auto-yes" : "review"));
+  console.log(c.dim(parts.join("  ·  ")));
+}