aether-code 0.3.1 → 0.5.0

package/bin/aether-code.js

@@ -14,9 +14,10 @@ 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 { generateAndApprovePlan } from "../src/plan.js";
 import { c, errorLine, divider } from "../src/render.js";
 
-const VERSION = "0.3.1";
+const VERSION = "0.5.0";
 
 const HELP = `${c.bold("aether")} — uncensored AI coding agent
 
@@ -40,6 +41,7 @@ ${c.bold("EXAMPLES")}
   aether --cwd ./my-project "fix the failing tests"
 
 ${c.bold("FLAGS")}
+  --plan             Show a numbered plan first; approve / refine / cancel before any tools fire.
   --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).
@@ -65,6 +67,7 @@ function parseArgs(argv) {
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a === "--yes") { args.flags.yes = true; }
+    else if (a === "--plan") { args.flags.plan = 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; }
@@ -140,12 +143,45 @@ async function main() {
   }
 
   console.log(divider());
-  console.log(c.magenta(c.bold("aether-code")) + c.gray(` · cwd ${cwd}${autoYes ? " · auto-yes" : ""}${unsafePaths ? " · unsafe-paths" : ""}`));
+  console.log(c.magenta(c.bold("aether-code")) + c.gray(` · cwd ${cwd}${autoYes ? " · auto-yes" : ""}${unsafePaths ? " · unsafe-paths" : ""}${args.flags.plan ? " · plan-mode" : ""}`));
   console.log(c.gray(`task: `) + prompt);
   console.log(divider());
 
+  // Plan mode: generate plan first, get approval, then execute with the plan
+  // injected into the conversation as context.
+  let priorMessages = undefined;
+  if (args.flags.plan) {
+    let currentTask = prompt;
+    // Up to 3 plan/refine cycles before bailing
+    for (let attempt = 0; attempt < 3; attempt++) {
+      const planResult = await generateAndApprovePlan({ initialPrompt: currentTask, cwd });
+      if (planResult.cancelled) {
+        console.log(c.gray("\nCancelled. No tools were run."));
+        return;
+      }
+      if (planResult.approved) {
+        // Inject the plan as prior context so the agent remembers it as it executes
+        priorMessages = [
+          { role: "user", content: currentTask },
+          { role: "assistant", content: `Plan:\n${planResult.planText}` },
+        ];
+        break;
+      }
+      if (planResult.refinement) {
+        console.log(c.gray(`Refining: ${planResult.refinement}`));
+        currentTask = `${currentTask}\n\nRefinement: ${planResult.refinement}`;
+      }
+    }
+    if (!priorMessages) {
+      console.log(c.yellow("\nGave up after 3 refinement cycles. Try a clearer task."));
+      return;
+    }
+    console.log("");
+  }
+
   const result = await runAgent({
     initialPrompt: prompt,
+    priorMessages,
     cwd,
     autoYes,
     unsafePaths,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aether-code",
-  "version": "0.3.1",
+  "version": "0.5.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": {
@@ -22,7 +22,7 @@
     "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"
+    "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 src/plan.js"
   },
   "keywords": [
     "aether",

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,20 +65,21 @@ 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. Coerce null → "" — some upstream
-    // APIs (Venice in particular) reject assistant messages with null content
-    // even when tool_calls is set. Empty string is the safest universal value.
+    // Push assistant message into history. Coerce null → "" (Venice hates null).
     messages.push({
       role: "assistant",
       content: res.message.content ?? "",
@@ -90,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",
@@ -112,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/api.js

@@ -66,6 +66,7 @@ export async function agentTurnStream({
   tools,
   maxTokens,
   temperature,
+  toolChoice,
   onDelta,
   onToolCallDelta,
   onFinish,
@@ -94,6 +95,7 @@ export async function agentTurnStream({
         tools,
         max_tokens: maxTokens,
         temperature,
+        ...(toolChoice ? { tool_choice: toolChoice } : {}),
       }),
     });
   } catch (e) {

package/src/plan.js

@@ -0,0 +1,133 @@
+// Plan mode — get a structured multi-step plan from the model BEFORE any
+// tools fire, show it to the user, let them approve or refine.
+//
+// Flow:
+//   1. Send a preflight request to /api/v1/agent with tool_choice: "none"
+//      and a planning system prompt. Model returns a numbered plan as text.
+//   2. Render the plan with borders. Prompt user: approve / refine / cancel.
+//   3. If approved, the plan text is appended as a tool-style "plan" entry
+//      in the message history (so the model remembers it as it executes).
+//   4. Normal agent loop continues with tools enabled.
+
+import readline from "node:readline";
+import { agentTurnStream, AetherError } from "./api.js";
+import { TOOL_DEFINITIONS } from "./tools.js";
+import { c, errorLine } from "./render.js";
+
+const PLAN_SYSTEM = `You are in PLAN MODE. The user wants to see what you'll do BEFORE you do it.
+
+Output a NUMBERED PLAN of the concrete steps you'll take. Each step should be:
+- One short line
+- Reference a specific tool you'll call (read_file, write_file, edit_file, run_shell, list_dir, search_files)
+- Mention the file path or command involved
+
+DO NOT call any tools. DO NOT include code blocks. Just the numbered plan.
+
+End with one line: "Approve this plan? (y / n / refine)"
+
+Example output:
+
+1. read_file: src/auth.ts  — inspect the existing handler
+2. edit_file: src/auth.ts  — add input validation before the password check
+3. write_file: src/auth.test.ts  — add a test for invalid input
+4. run_shell: npm test  — verify the test passes
+
+Approve this plan? (y / n / refine)`;
+
+function ask(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+function renderPlanBox(plan) {
+  const w = Math.min(process.stdout.columns || 80, 90);
+  const top = c.gray("╭" + "─".repeat(w - 2) + "╮");
+  const bot = c.gray("╰" + "─".repeat(w - 2) + "╯");
+  const blank = c.gray("│") + " ".repeat(w - 2) + c.gray("│");
+  const lines = [top, blank, c.gray("│ ") + c.bold(c.cyan("📋 Plan")) + " ".repeat(w - 11) + c.gray("│"), blank];
+  for (const line of plan.split("\n")) {
+    // Wrap long lines
+    const wrapWidth = w - 4;
+    let rest = line;
+    while (rest.length > wrapWidth) {
+      const slice = rest.slice(0, wrapWidth);
+      lines.push(c.gray("│ ") + slice + " ".repeat(w - 3 - slice.length) + c.gray("│"));
+      rest = rest.slice(wrapWidth);
+    }
+    lines.push(c.gray("│ ") + rest + " ".repeat(Math.max(0, w - 3 - rest.length)) + c.gray("│"));
+  }
+  lines.push(blank, bot);
+  return lines.join("\n");
+}
+
+/**
+ * Generate a plan, show it, get approval. Returns:
+ *   { approved: true, planText: "..." }       — user said yes
+ *   { approved: false, cancelled: true }       — user said no
+ *   { approved: false, refinement: "..." }     — user wants to refine
+ */
+export async function generateAndApprovePlan({ initialPrompt, cwd, priorMessages }) {
+  process.stdout.write(c.dim("Generating plan...\n"));
+
+  const messages = priorMessages
+    ? [...priorMessages, { role: "user", content: initialPrompt }]
+    : [
+        { role: "system", content: PLAN_SYSTEM },
+        { role: "user", content: initialPrompt },
+      ];
+
+  let planText = "";
+  let creditsCharged = 0;
+  let inputTokens = 0;
+  let outputTokens = 0;
+
+  try {
+    const res = await agentTurnStream({
+      messages,
+      tools: TOOL_DEFINITIONS,
+      // Override server heuristic — we explicitly want NO tools here.
+      toolChoice: "none",
+      maxTokens: 1200,
+    });
+    planText = (res.message.content || "").trim();
+    creditsCharged = res.creditsCharged ?? 0;
+    inputTokens = res.usage?.prompt_tokens ?? 0;
+    outputTokens = res.usage?.completion_tokens ?? 0;
+  } catch (err) {
+    if (err instanceof AetherError) {
+      console.log(errorLine(err.message));
+      return { approved: false, cancelled: true };
+    }
+    throw err;
+  }
+
+  if (!planText) {
+    console.log(errorLine("Got empty plan from model. Try again or run without --plan."));
+    return { approved: false, cancelled: true };
+  }
+
+  // Render the plan in a box
+  console.log("");
+  console.log(renderPlanBox(planText));
+  console.log(c.dim(`  ${creditsCharged} cr · ${inputTokens}→${outputTokens} tokens (planning)\n`));
+
+  // Prompt for approval
+  const answer = await ask(
+    c.yellow("  ? ") + c.bold("Run this plan?") + c.gray(" [y / n / refine]: "),
+  );
+  const lower = answer.toLowerCase();
+
+  if (lower === "y" || lower === "yes") {
+    return { approved: true, planText, creditsCharged, inputTokens, outputTokens };
+  }
+  if (lower === "n" || lower === "no" || lower === "" || lower === "exit") {
+    return { approved: false, cancelled: true };
+  }
+  // Anything else is treated as refinement text
+  return { approved: false, refinement: answer || lower };
+}

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.3.1";
+const VERSION = "0.5.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 ─────────────────────── */