aether-code 0.3.0 → 0.4.0

package/bin/aether-code.js

@@ -16,7 +16,7 @@ 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 VERSION = "0.4.0";
 
 const HELP = `${c.bold("aether")} — uncensored AI coding agent
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aether-code",
-  "version": "0.3.0",
+  "version": "0.4.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": {

package/src/agent.js

@@ -4,7 +4,9 @@
 
 import { agentTurnStream, AetherError } from "./api.js";
 import { TOOL_DEFINITIONS, executeTool } from "./tools.js";
-import { c, divider, turn, toolHeader, toolResult, errorLine } from "./render.js";
+import {
+  c, turnLine, costLine, toolAnnounce, toolResultLine, errorLine, assistantPrefix,
+} from "./render.js";
 
 const DEFAULT_MAX_TURNS = 25;
 
@@ -17,8 +19,6 @@ export async function runAgent({
   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 }];
@@ -28,13 +28,10 @@ export async function runAgent({
   let lastBalance = null;
 
   for (let i = 0; i < maxTurns; i++) {
-    process.stdout.write("\n" + turn(i + 1) + "\n");
+    process.stdout.write("\n" + turnLine(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 textOpened = false;
 
     let res;
     try {
@@ -42,19 +39,22 @@ export async function runAgent({
         messages,
         tools: TOOL_DEFINITIONS,
         onDelta: (text) => {
-          if (!lastWasText) {
-            process.stdout.write("  ");
-            lastWasText = true;
+          if (!textOpened) {
+            process.stdout.write(assistantPrefix() + " ");
+            textOpened = true;
           }
           process.stdout.write(text);
         },
         onToolCallDelta: (delta) => {
-          // Print the tool header once we know the name (first chunk for that index)
+          // Print friendly tool-call header once name + (eventually) args land.
+          // We delay the announce until args are mostly assembled — see below.
           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"));
+            if (textOpened) {
+              process.stdout.write("\n");
+              textOpened = false;
+            }
+            process.stdout.write(c.cyan("  ⚡ ") + c.bold(c.cyan(delta.name)) + c.dim(" preparing…\n"));
           }
         },
       });
@@ -65,21 +65,24 @@ export async function runAgent({
       throw err;
     }
 
-    // End-of-turn newline + cost meter
-    if (lastWasText) process.stdout.write("\n");
+    // End-of-turn: newline + cost meter
+    if (textOpened) 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`),
-    );
+    process.stdout.write(costLine({
+      creditsCharged: res.creditsCharged ?? 0,
+      inputTokens: res.usage?.prompt_tokens ?? 0,
+      outputTokens: res.usage?.completion_tokens ?? 0,
+      finishReason: res.finish_reason,
+    }) + "\n");
 
-    // Push assistant message into history
+    // Push assistant message into history. Coerce null → "" (Venice hates null).
     messages.push({
       role: "assistant",
-      content: res.message.content,
+      content: res.message.content ?? "",
       tool_calls: res.message.tool_calls,
     });
 
@@ -88,19 +91,16 @@ export async function runAgent({
       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.
+    // Execute each tool call. Now we know the full args, render the friendly
+    // label + execute + show summarized result.
     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));
+      console.log(toolAnnounce(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));
-      }
+      console.log(toolResultLine(call.function.name, result));
 
       messages.push({
         role: "tool",
@@ -110,6 +110,6 @@ export async function runAgent({
     }
   }
 
-  console.log(c.yellow(`\nReached max turns (${maxTurns}). Stopping.`));
+  console.log(c.yellow(`\n⚠ Reached max turns (${maxTurns}). Stopping.`));
   return { ok: false, error: new Error("Max turns reached"), totalCredits, totalIn, totalOut, balance: lastBalance, messages };
 }

package/src/render.js

@@ -1,4 +1,5 @@
-// ANSI helpers — no chalk dependency.
+// ANSI helpers — no chalk dependency. Designed to feel like Claude Code:
+// bordered banner, indented tool calls, structured tool-result rendering.
 
 const isTty = process.stdout.isTTY;
 const noColor = !!process.env.NO_COLOR || !isTty;
@@ -10,6 +11,7 @@ function wrap(open, close) {
 export const c = {
   bold:    wrap(1, 22),
   dim:     wrap(2, 22),
+  italic:  wrap(3, 23),
   red:     wrap(31, 39),
   green:   wrap(32, 39),
   yellow:  wrap(33, 39),
@@ -17,42 +19,180 @@ export const c = {
   magenta: wrap(35, 39),
   cyan:    wrap(36, 39),
   gray:    wrap(90, 39),
+  white:   wrap(37, 39),
 };
 
+const W = () => Math.min(process.stdout.columns || 80, 90);
+
+export function hr() {
+  return c.gray("─".repeat(W()));
+}
+
 export function divider() {
-  const w = process.stdout.columns || 60;
-  return c.gray("─".repeat(Math.min(60, w)));
+  return hr();
+}
+
+/* ─── Banner — Claude-Code-style box ─── */
+
+export function banner({ version, model, mode, balance, cwd }) {
+  const w = Math.min(W(), 78);
+  const top = c.gray("╭" + "─".repeat(w - 2) + "╮");
+  const bot = c.gray("╰" + "─".repeat(w - 2) + "╯");
+  const pad = (line) => {
+    // Strip ANSI for length calc
+    const visible = line.replace(/\x1b\[[0-9;]*m/g, "");
+    const space = Math.max(0, w - 2 - visible.length - 2);
+    return c.gray("│ ") + line + " ".repeat(space) + c.gray(" │");
+  };
+  const blank = pad("");
+  const title = pad(`${c.magenta(c.bold("✻ aether-code"))}  ${c.gray("v" + version)}`);
+  const sub = pad(`${c.gray(model + " · uncensored · " + mode + (balance != null ? "  ·  " + balance.toLocaleString() + " credits" : ""))}`);
+  const cwdLine = pad(c.gray("📁 " + truncatePath(cwd, w - 6)));
+  const tip = pad(c.gray("Type ") + c.cyan("/help") + c.gray(" for shortcuts. ") + c.cyan("/exit") + c.gray(" or Ctrl+C twice to quit."));
+  return [top, blank, title, sub, cwdLine, blank, tip, bot].join("\n");
+}
+
+function truncatePath(p, max) {
+  if (!p) return "";
+  if (p.length <= max) return p;
+  return "…" + p.slice(-(max - 1));
+}
+
+/* ─── Turn / cost line ─── */
+
+export function turnLine(n) {
+  return c.dim("─── turn " + n + " " + "─".repeat(Math.max(0, W() - 12 - String(n).length)));
+}
+
+export function costLine({ creditsCharged, inputTokens, outputTokens, finishReason }) {
+  const parts = [
+    `${creditsCharged} cr`,
+    `${inputTokens}→${outputTokens} tok`,
+    finishReason ? `finish: ${finishReason}` : null,
+  ].filter(Boolean);
+  return "  " + c.dim(parts.join(" · "));
+}
+
+/* ─── Assistant text ─── */
+
+export function assistantPrefix() {
+  return c.magenta("● ") + c.bold(c.magenta("Aether")) + c.gray(":");
 }
 
-export function turn(n) {
-  return c.gray(`turn ${n}`);
+/* ─── Tool calls — friendly labels instead of raw JSON ─── */
+
+export function toolAnnounce(name, args) {
+  const label = TOOL_LABELS[name] ? TOOL_LABELS[name](args) : `${name}(${jsonPreview(args)})`;
+  return c.cyan("  ⚡ ") + c.bold(c.cyan(name)) + c.gray("  ") + c.gray(label);
+}
+
+const TOOL_LABELS = {
+  read_file: (a) => `→ ${a.path || "?"}`,
+  list_dir: (a) => `→ ${a.path || "."}`,
+  search_files: (a) => `→ ${a.pattern || "?"} in ${a.path || "."}`,
+  write_file: (a) => `→ ${a.path || "?"}  ${c.gray("(" + (a.content?.length || 0) + " bytes)")}`,
+  edit_file: (a) => `→ ${a.path || "?"}`,
+  run_shell: (a) => `${c.yellow("$")} ${a.command || "?"}` + (a.cwd && a.cwd !== "." ? c.gray(`  (cwd: ${a.cwd})`) : ""),
+};
+
+function jsonPreview(obj) {
+  const s = JSON.stringify(obj);
+  return s.length > 80 ? s.slice(0, 77) + "..." : s;
 }
 
-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(")")}`;
+/* ─── Tool results — structured render per tool ─── */
+
+export function toolResultLine(name, result) {
+  const icon = result.ok ? c.green("  ✓") : c.red("  ✗");
+  const summary = summarizeResult(name, result);
+  return `${icon} ${c.dim(summary)}`;
 }
 
-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) : ""}`;
+function summarizeResult(name, result) {
+  if (!result.ok) {
+    // Try to extract a useful one-liner from error JSON
+    let txt = result.output || "";
+    try {
+      const j = JSON.parse(txt);
+      if (j.exit_code !== undefined) {
+        // Shell error
+        const stderr = (j.stderr || "").trim().split("\n")[0] || "(no stderr)";
+        return `exit ${j.exit_code} — ${stderr}`;
+      }
+    } catch { /* not JSON */ }
+    const firstLine = txt.split("\n")[0];
+    return firstLine.length > 100 ? firstLine.slice(0, 97) + "..." : firstLine;
+  }
+  // Success — short summary by tool type
+  const out = result.output || "";
+  if (name === "read_file") {
+    const lines = out.split("\n").length;
+    return `read ${out.length} bytes (${lines} line${lines === 1 ? "" : "s"})`;
+  }
+  if (name === "list_dir") {
+    try {
+      const items = JSON.parse(out);
+      return `${items.length} entr${items.length === 1 ? "y" : "ies"}`;
+    } catch {
+      return "ok";
+    }
+  }
+  if (name === "search_files") {
+    try {
+      const matches = JSON.parse(out);
+      return `${matches.length} match${matches.length === 1 ? "" : "es"}`;
+    } catch {
+      return "ok";
+    }
+  }
+  if (name === "write_file" || name === "edit_file") {
+    return out.split("\n")[0];
+  }
+  if (name === "run_shell") {
+    try {
+      const j = JSON.parse(out);
+      const stdoutLines = (j.stdout || "").split("\n").filter(Boolean).length;
+      return `exit ${j.exit_code} · ${stdoutLines} stdout line${stdoutLines === 1 ? "" : "s"}`;
+    } catch {
+      return "ok";
+    }
+  }
+  return out.split("\n")[0].slice(0, 80);
 }
 
-export function assistant(text) {
-  // Indent each line for visual separation from tool calls
-  return text.split("\n").map((l) => `  ${l}`).join("\n");
+/* ─── Status line at end of turn ─── */
+
+export function statusLine({ sessionCredits, sessionIn, sessionOut, balance, history, mode }) {
+  const parts = [];
+  parts.push(`session: ${sessionCredits} cr · ${sessionIn}→${sessionOut} tok`);
+  if (balance != null) parts.push(`balance: ${balance.toLocaleString()}`);
+  if (history > 0) parts.push(`history: ${history} msg${history === 1 ? "" : "s"}`);
+  parts.push(c.cyan(mode));
+  return c.dim(parts.join("  ·  "));
 }
 
+/* ─── Errors ─── */
+
 export function errorLine(msg) {
-  return `${c.red(c.bold("Error:"))} ${msg}`;
+  return `${c.red(c.bold("✗ Error:"))} ${msg}`;
+}
+
+export function warnLine(msg) {
+  return `${c.yellow("⚠ ")} ${msg}`;
 }
 
 export function note(msg) {
   return c.dim(msg);
 }
+
+/* ─── Confirmation prompt rendering ─── */
+
+export function confirmPrompt(label) {
+  return c.yellow("  ? ") + c.bold(label) + c.gray("  [y/N] ");
+}
+
+/* ─── Spinner / pending indicator (no animation, just text) ─── */
+
+export function pending(msg) {
+  return c.gray("  ⋯ " + msg);
+}

package/src/repl.js

@@ -13,9 +13,9 @@ 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";
+import { c, errorLine, banner, statusLine } from "./render.js";
 
-const VERSION = "0.2.0";
+const VERSION = "0.4.0";
 const MODEL_NAME = "Aether Core";
 
 const SHORTCUTS = `
@@ -222,25 +222,23 @@ async function handleSlash(line, state) {
 
 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(banner({
+    version: VERSION,
+    model: MODEL_NAME + " (1M context)",
+    mode: state.autoYes ? "auto-yes" : "review mode",
+    balance: state.balance,
+    cwd: state.cwd,
+  }));
   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("  ·  ")));
+  console.log(statusLine({
+    sessionCredits: state.sessionCredits,
+    sessionIn: state.sessionIn,
+    sessionOut: state.sessionOut,
+    balance: state.balance,
+    history: state.messages.length,
+    mode: state.autoYes ? "auto-yes" : "review",
+  }));
 }

package/src/tools.js

@@ -147,8 +147,9 @@ function ask(question) {
 
 async function confirm(question, autoYes) {
   if (autoYes) return true;
-  const ans = await ask(`${question} ${c.dim("[y/N]: ")}`);
-  return ans === "y" || ans === "yes";
+  const ans = await ask(c.yellow("  ? ") + c.bold(question) + c.gray(" [y/N] "));
+  // Accept y, yes, or any string starting with y (handles double-tap "yy")
+  return /^y/i.test(ans.trim());
 }
 
 /* ─────────────────────── Implementations ─────────────────────── */