aether-code 0.42.0 → 0.43.1

package/src/menu.js

@@ -1,83 +1,83 @@
-// Interactive multiple-choice menu — arrow/number selectable, cmd.exe-safe.
-//
-// Deliberately NOT Ink (which ghosts in the legacy Windows console). Uses a
-// simple manual redraw: print the list, and on each keypress move the cursor
-// back up to the top of the menu (ESC[nA) and clear-to-end (ESC[J), then
-// reprint. That's the same VT layer that already renders our ANSI colours, so
-// it works in cmd.exe, Windows Terminal, and POSIX terminals alike.
-//
-// Returns the chosen option object ({label, description}), or null if cancelled.
-
-import readline from "node:readline";
-import { c } from "./render.js";
-
-const ellip = (s, n) => (s && s.length > n ? s.slice(0, n - 1) + "…" : s || "");
-
-export function promptChoice({ question, options }) {
-  const opts = (options || [])
-    .map((o) => (typeof o === "string" ? { label: o } : o))
-    .filter((o) => o && o.label);
-
-  return new Promise((resolve) => {
-    // Non-interactive (piped / CI): pick the first option so automation never
-    // hangs waiting on a keypress that can't come. Print a note so it's visible.
-    if (!process.stdin.isTTY || opts.length === 0) {
-      const pick = opts[0] ?? null;
-      if (pick) process.stdout.write(c.cyan("● ") + c.bold(question) + c.gray(`  → ${pick.label} (auto)\n`));
-      resolve(pick);
-      return;
-    }
-
-    let sel = 0;
-    const total = opts.length + 3; // question line + options + blank + hint line
-
-    const draw = (first) => {
-      if (!first) process.stdout.write(`\x1b[${total}A`); // cursor up to menu top
-      process.stdout.write("\x1b[J"); // clear from cursor to end of screen
-      process.stdout.write(c.cyan("● ") + c.bold(question) + "\n");
-      opts.forEach((o, i) => {
-        const active = i === sel;
-        const pointer = active ? c.cyan("→") : " ";
-        const num = active ? c.cyan(c.bold(`${i + 1}.`)) : c.gray(`${i + 1}.`);
-        const label = active ? c.bold(o.label) : o.label;
-        const desc = o.description ? c.gray("  " + ellip(o.description, 60)) : "";
-        process.stdout.write(`  ${pointer} ${num} ${label}${desc}\n`);
-      });
-      process.stdout.write("\n" + c.gray("  ↑/↓ move · 1-9 pick · Enter select · Esc cancel") + "\n");
-    };
-
-    const cleanup = () => {
-      process.stdin.removeListener("keypress", onKey);
-      if (process.stdin.isTTY) process.stdin.setRawMode(false);
-      process.stdin.pause();
-    };
-
-    const finish = (result) => {
-      cleanup();
-      // Collapse the menu to a compact answer line so the transcript stays clean.
-      process.stdout.write(`\x1b[${total}A\x1b[J`);
-      process.stdout.write(c.cyan("● ") + c.bold(question) + "\n");
-      if (result) process.stdout.write("  " + c.cyan("→") + " " + c.green(result.label) + "\n\n");
-      else process.stdout.write("  " + c.gray("(cancelled — proceeding with best judgment)") + "\n\n");
-      resolve(result);
-    };
-
-    const onKey = (str, key) => {
-      if (!key) return;
-      if (key.name === "up" || key.name === "k") { sel = (sel - 1 + opts.length) % opts.length; draw(false); }
-      else if (key.name === "down" || key.name === "j" || key.name === "tab") { sel = (sel + 1) % opts.length; draw(false); }
-      else if (str && /^[1-9]$/.test(str)) {
-        const i = parseInt(str, 10) - 1;
-        if (i < opts.length) finish(opts[i]);
-      }
-      else if (key.name === "return") finish(opts[sel]);
-      else if (key.name === "escape" || (key.ctrl && key.name === "c")) finish(null);
-    };
-
-    readline.emitKeypressEvents(process.stdin);
-    if (process.stdin.isTTY) process.stdin.setRawMode(true);
-    process.stdin.resume();
-    process.stdin.on("keypress", onKey);
-    draw(true);
-  });
-}
+// Interactive multiple-choice menu — arrow/number selectable, cmd.exe-safe.
+//
+// Deliberately NOT Ink (which ghosts in the legacy Windows console). Uses a
+// simple manual redraw: print the list, and on each keypress move the cursor
+// back up to the top of the menu (ESC[nA) and clear-to-end (ESC[J), then
+// reprint. That's the same VT layer that already renders our ANSI colours, so
+// it works in cmd.exe, Windows Terminal, and POSIX terminals alike.
+//
+// Returns the chosen option object ({label, description}), or null if cancelled.
+
+import readline from "node:readline";
+import { c } from "./render.js";
+
+const ellip = (s, n) => (s && s.length > n ? s.slice(0, n - 1) + "…" : s || "");
+
+export function promptChoice({ question, options }) {
+  const opts = (options || [])
+    .map((o) => (typeof o === "string" ? { label: o } : o))
+    .filter((o) => o && o.label);
+
+  return new Promise((resolve) => {
+    // Non-interactive (piped / CI): pick the first option so automation never
+    // hangs waiting on a keypress that can't come. Print a note so it's visible.
+    if (!process.stdin.isTTY || opts.length === 0) {
+      const pick = opts[0] ?? null;
+      if (pick) process.stdout.write(c.cyan("● ") + c.bold(question) + c.gray(`  → ${pick.label} (auto)\n`));
+      resolve(pick);
+      return;
+    }
+
+    let sel = 0;
+    const total = opts.length + 3; // question line + options + blank + hint line
+
+    const draw = (first) => {
+      if (!first) process.stdout.write(`\x1b[${total}A`); // cursor up to menu top
+      process.stdout.write("\x1b[J"); // clear from cursor to end of screen
+      process.stdout.write(c.cyan("● ") + c.bold(question) + "\n");
+      opts.forEach((o, i) => {
+        const active = i === sel;
+        const pointer = active ? c.cyan("→") : " ";
+        const num = active ? c.cyan(c.bold(`${i + 1}.`)) : c.gray(`${i + 1}.`);
+        const label = active ? c.bold(o.label) : o.label;
+        const desc = o.description ? c.gray("  " + ellip(o.description, 60)) : "";
+        process.stdout.write(`  ${pointer} ${num} ${label}${desc}\n`);
+      });
+      process.stdout.write("\n" + c.gray("  ↑/↓ move · 1-9 pick · Enter select · Esc cancel") + "\n");
+    };
+
+    const cleanup = () => {
+      process.stdin.removeListener("keypress", onKey);
+      if (process.stdin.isTTY) process.stdin.setRawMode(false);
+      process.stdin.pause();
+    };
+
+    const finish = (result) => {
+      cleanup();
+      // Collapse the menu to a compact answer line so the transcript stays clean.
+      process.stdout.write(`\x1b[${total}A\x1b[J`);
+      process.stdout.write(c.cyan("● ") + c.bold(question) + "\n");
+      if (result) process.stdout.write("  " + c.cyan("→") + " " + c.green(result.label) + "\n\n");
+      else process.stdout.write("  " + c.gray("(cancelled — proceeding with best judgment)") + "\n\n");
+      resolve(result);
+    };
+
+    const onKey = (str, key) => {
+      if (!key) return;
+      if (key.name === "up" || key.name === "k") { sel = (sel - 1 + opts.length) % opts.length; draw(false); }
+      else if (key.name === "down" || key.name === "j" || key.name === "tab") { sel = (sel + 1) % opts.length; draw(false); }
+      else if (str && /^[1-9]$/.test(str)) {
+        const i = parseInt(str, 10) - 1;
+        if (i < opts.length) finish(opts[i]);
+      }
+      else if (key.name === "return") finish(opts[sel]);
+      else if (key.name === "escape" || (key.ctrl && key.name === "c")) finish(null);
+    };
+
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("keypress", onKey);
+    draw(true);
+  });
+}

package/src/render.js

@@ -26,8 +26,6 @@ export function divider() {
 
 const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
 
-// Draw a bordered box around content lines, returning the rows as an array (so
-// boxes can be composed side by side). Rounded box-drawing chars.
 export function boxLines(lines, { color = c.gray, padX = 2, minInner = 0 } = {}) {
   const inner = Math.max(minInner, 0, ...lines.map((l) => stripAnsi(l).length));
   const w = inner + padX * 2;
@@ -43,8 +41,6 @@ export function box(lines, opts) {
   return boxLines(lines, opts).join("\n");
 }
 
-// Join two blocks of lines horizontally with a gap, padding the left block to a
-// uniform width so the right block aligns. Shorter block is padded with blanks.
 export function sideBySide(a, b, gap = 3) {
   const wa = Math.max(0, ...a.map((l) => stripAnsi(l).length));
   const h = Math.max(a.length, b.length);
@@ -62,7 +58,6 @@ export function 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(")")}`;
@@ -70,114 +65,185 @@ export function toolHeader(name, args) {
 
 const ellip = (s, n) => (s && s.length > n ? s.slice(0, n - 1) + "…" : s || "");
 
-// Clean one-line label for a tool call — a verb + its key argument, instead of
-// dumping raw JSON (which buried file contents / queries in noise).
 export function toolLabel(name, args) {
   const a = args || {};
   const verb = (v) => c.cyan(c.bold(v));
-  const arg = (s) => c.gray(ellip(String(s), 72));
+  const arg = (s) => c.gray(ellip(s == null ? "" : String(s), 72));
   switch (name) {
-    case "read_file":    return `${verb("read")}   ${arg(a.path)}`;
-    case "write_file":   return `${verb("write")}  ${arg(a.path)}`;
-    case "edit_file":    return `${verb("edit")}   ${arg(a.path)}`;
-    case "list_dir":     return `${verb("list")}   ${arg(a.path)}`;
-    case "glob_files":   return `${verb("find")}   ${arg(a.pattern)}`;
-    case "search_files": return `${verb("search")} ${arg(`/${a.pattern}/ in ${a.path ?? "."}`)}`;
-    case "run_shell":    return `${verb("run")}    ${arg(a.command)}`;
-    case "web_search":   return `${verb("search web")} ${arg(JSON.stringify(a.query ?? ""))}`;
-    case "web_fetch":    return `${verb("fetch")}  ${arg(a.url)}`;
-    case "todo_write":   return ""; // its Plan box is the label
-    case "ask_user":     return ""; // the interactive menu is its display
-    case "git_status":   return `${verb("git")}    ${arg("status")}`;
-    case "git_diff":     return `${verb("git")}    ${arg("diff" + (a.staged ? " --staged" : "") + (a.base ? ` ${a.base}...${a.head || "HEAD"}` : ""))}`;
-    case "git_log":      return `${verb("git")}    ${arg("log" + (a.file ? ` -- ${a.file}` : "") + (a.branch ? ` ${a.branch}` : ""))}`;
-    case "git_commit":   return `${verb("git")}    ${arg(`commit "${ellip(a.message || "", 50)}"`)}`
-    case "git_branch":   return `${verb("git")}    ${arg(`branch ${a.name}`)}`;
-    case "git_push":     return `${verb("git")}    ${arg("push" + (a.force ? " --force" : ""))}`;
-    case "git_create_pr": return `${verb("git")}    ${arg(`pr "${ellip(a.title || "", 50)}"`)}`
+    case "read_file":    return `${verb("Read")}   ${arg(a.path)}`;
+    case "write_file":   return `${verb("Write")}  ${arg(a.path)}`;
+    case "edit_file":    return `${verb("Edit")}   ${arg(a.path)}`;
+    case "list_dir":     return `${verb("List")}   ${arg(a.path)}`;
+    case "glob_files":   return `${verb("Glob")}   ${arg(a.pattern)}`;
+    case "search_files": return `${verb("Grep")}   ${arg(`/${a.pattern}/ in ${a.path ?? "."}`)}`;
+    case "run_shell":    return `${verb("Bash")}   ${arg(a.command)}`;
+    case "web_search":   return `${verb("WebSearch")} ${arg(a.query ?? "")}`;
+    case "web_fetch":    return `${verb("WebFetch")}  ${arg(a.url)}`;
+    case "todo_write":   return "";
+    case "ask_user":     return "";
     default:             return `${verb(name)} ${arg(JSON.stringify(a))}`;
   }
 }
 
-// Set the terminal window/tab title (so cmd.exe shows "Aether", not the node
-// path). OSC 0 — supported by cmd.exe, Windows Terminal, and POSIX terminals.
 export function setTerminalTitle(title) {
   if (process.stdout.isTTY) process.stdout.write(`\x1b]0;${title}\x07`);
 }
 
-// Live "working…" spinner. Rewrites a single line in place (\r) with a rotating
-// half-circle (Geometric Shapes — same block as ●, so cmd.exe-safe) + elapsed
-// seconds, so the user sees the agent is alive while the model thinks or a slow
-// tool runs. stop() clears the line and restores the cursor. No-op in non-TTY.
+// Fun thinking words — like Claude Code's "Hullaballooing...", "Cogitating..."
+const THINKING_WORDS = [
+  "Thinking",
+  "Pondering",
+  "Mulling",
+  "Cogitating",
+  "Ruminating",
+  "Deliberating",
+  "Contemplating",
+  "Noodling",
+  "Musing",
+  "Brainstorming",
+  "Percolating",
+  "Brainwaving",
+  "Daydreaming",
+  "Hullaballooing",
+  "Churning",
+  "Brewing",
+  "Conjuring",
+  "Scheming",
+  "Hatching",
+  "Concocting",
+  "Simmering",
+  "Marinating",
+  "Fermenting",
+  "Stewing",
+  "Whittling",
+  "Tinkering",
+  "Puzzling",
+  "Deciphering",
+  "Unraveling",
+  "Distilling",
+];
+
+// Pick a random thinking word (seeded by current second so it varies per call)
+function pickThinkingWord() {
+  const idx = (Date.now() % (THINKING_WORDS.length * 1000)) / 1000 | 0;
+  return THINKING_WORDS[idx % THINKING_WORDS.length];
+}
+
 export function startSpinner(label) {
-  if (!process.stdout.isTTY) return { stop: () => {} };
-  const frames = ["◐", "◓", "◑", "◒"];
+  if (!process.stdout.isTTY) return { stop: () => {}, update: () => {} };
+  // Ping-pong animation — cmd.exe-safe chars inspired by Claude Code's sparkle cycle
+  const frames = ["\xB7", "*", "+", "*", "\xB7", ".", "\xB7", "*", "+", "*", "\xB7", "."];
   const t0 = Date.now();
   let i = 0;
-  process.stdout.write("\x1b[?25l"); // hide cursor
+  let tokenCount = 0;
+  let statusText = "";
+  const isThinking = label === "thinking";
+  const thinkWord = isThinking ? pickThinkingWord() : null;
+  process.stdout.write("\x1b[?25l");
   const render = () => {
-    const s = Math.floor((Date.now() - t0) / 1000);
-    const tail = s > 0 ? c.gray(`  ${s}s`) : "";
-    process.stdout.write(`\r\x1b[K${c.cyan(frames[i % frames.length])} ${c.gray(label + "…")}${tail}`);
+    const ms = Date.now() - t0;
+    const secs = Math.floor(ms / 1000);
+    const timeFmt = secs >= 60
+      ? `${Math.floor(secs / 60)}m ${String(secs % 60).padStart(2, "0")}s`
+      : `${secs}s`;
+    const parts = [];
+    if (secs > 0) parts.push(timeFmt);
+    if (tokenCount > 0) parts.push(`${fmtTokens(tokenCount)} tokens`);
+    if (statusText) parts.push(statusText);
+    const metrics = parts.length > 0 ? c.gray(` (${parts.join(" \xB7 ")})`) : "";
+    const displayLabel = isThinking ? thinkWord : label;
+    process.stdout.write(`\r\x1b[K${c.cyan(frames[i % frames.length])} ${c.dim(displayLabel + "...")}${metrics}`);
     i++;
   };
   render();
   const timer = setInterval(render, 120);
-  if (typeof timer.unref === "function") timer.unref(); // don't keep the process alive
+  if (typeof timer.unref === "function") timer.unref();
   return {
-    stop: () => {
+    update(data) {
+      if (data.tokens != null) tokenCount = data.tokens;
+      if (data.status != null) statusText = data.status;
+    },
+    stop() {
       clearInterval(timer);
-      process.stdout.write("\r\x1b[K\x1b[?25h"); // clear line + show cursor
+      process.stdout.write("\r\x1b[K\x1b[?25h");
     },
   };
 }
 
-// Terse one-line result summary instead of dumping raw JSON / file contents.
-// Tools whose handlers already render rich output (diffs, the shell stream, the
-// plan) just get a check — the detail was already printed.
+export function fmtTokens(n) {
+  if (n >= 1_000_000) return (n / 1_000_000).toFixed(1) + "M";
+  if (n >= 1_000) return (n / 1_000).toFixed(1) + "k";
+  return String(n);
+}
+
+export function turnStats({ elapsed, tokensIn, tokensOut, tools, credits }) {
+  const parts = [];
+  if (elapsed > 0) {
+    const s = Math.floor(elapsed / 1000);
+    parts.push(s >= 60 ? `${Math.floor(s / 60)}m ${String(s % 60).padStart(2, "0")}s` : `${s}s`);
+  }
+  if (tokensIn > 0 || tokensOut > 0) {
+    parts.push(`${fmtTokens(tokensIn)}->${fmtTokens(tokensOut)} tokens`);
+  }
+  if (tools > 0) parts.push(`${tools} tool call${tools === 1 ? "" : "s"}`);
+  if (credits > 0) parts.push(`${credits} credit${credits === 1 ? "" : "s"}`);
+  return parts.length > 0 ? c.dim(`  ${parts.join(" \xB7 ")}`) : "";
+}
+
+export function toolResult(text, ok = true) {
+  const prefix = ok ? c.green("  ● ") : c.red("  × ");
+  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) {
+  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);
+}
+
 export function toolSummary(name, result) {
   const ok = result.ok;
-  // A tree branch links the result to the action above it (modern CLI style).
   const branch = ok ? c.green("└─") : c.red("└─");
   const out = result.output ?? "";
   const firstLine = out.split("\n").find((l) => l.trim()) ?? "";
 
   if (name === "run_shell") {
     let code = null;
-    try { code = JSON.parse(out).exit_code; } catch { /* ignore */ }
-    return `  ${branch} ${c.gray(code === null ? (ok ? "done" : "failed") : `exit ${code}`)}`;
-  }
-  if (name === "todo_write") return ""; // the Plan is its own feedback
-  if (name === "ask_user") return ""; // the menu already showed the answer
-  if (name === "git_commit" || name === "git_push" || name === "git_create_pr") {
-    return `  ${branch} ${c.gray(ellip(firstLine, 100))}`;
-  }
-  if (name === "git_status") {
+    let stderr = "";
     try {
-      const s = JSON.parse(out);
-      if (s.clean) return `  ${branch} ${c.gray("clean")}`;
-      const parts = [];
-      if (s.staged?.length) parts.push(`${s.staged.length} staged`);
-      if (s.unstaged?.length) parts.push(`${s.unstaged.length} modified`);
-      if (s.untracked?.length) parts.push(`${s.untracked.length} untracked`);
-      return `  ${branch} ${c.gray(parts.join(", "))}`;
-    } catch { /* fall through */ }
-  }
-  if (name === "git_diff") {
-    if (out === "(no changes)") return `  ${branch} ${c.gray("no changes")}`;
-    const diffLines = out.split("\n").length;
-    return `  ${branch} ${c.gray(`${diffLines} lines of diff`)}`;
+      const j = JSON.parse(out);
+      code = j.exit_code;
+      stderr = (j.stderr || "").split("\n")[0] || "";
+    } catch { /* ignore */ }
+    const status = code === null ? (ok ? "done" : "failed") : code === 0 ? "done" : `exit ${code}`;
+    const detail = !ok && stderr ? ` ${ellip(stderr, 60)}` : "";
+    return `  ${branch} ${c.gray(status + detail)}`;
   }
-  if (name === "git_log") {
-    const logLines = out.trim().split("\n").filter((l) => l.trim()).length;
-    return `  ${branch} ${c.gray(`${logLines} lines`)}`;
+  if (name === "todo_write") return "";
+  if (name === "ask_user") return "";
+  if (name === "write_file") {
+    return `  ${branch} ${c.gray("wrote file")}`;
   }
-  if (name === "git_branch") {
+  if (name === "edit_file") {
     return `  ${branch} ${c.gray(ellip(firstLine, 100))}`;
   }
-  if (name === "write_file" || name === "edit_file") {
-    // Handler already printed the diff; echo its short status line.
-    return `  ${branch} ${c.gray(ellip(firstLine, 100))}`;
+  if (name === "web_search") {
+    let count = 0;
+    try { const j = JSON.parse(out); if (Array.isArray(j)) count = j.length; } catch { /* ignore */ }
+    return `  ${branch} ${c.gray(count > 0 ? `${count} results` : "no results")}`;
+  }
+  if (name === "web_fetch") {
+    const lines = out.split("\n").length;
+    return `  ${branch} ${c.gray(`${lines} lines fetched`)}`;
   }
   let summary = "";
   try {
@@ -192,28 +258,18 @@ export function toolSummary(name, result) {
   return `  ${branch} ${c.gray(summary)}`;
 }
 
-// Strip model "harmony"/channel control tokens (<|channel|>, <|message|>,
-// <|tool_response|>, <channel|>, …) that occasionally leak into the text
-// stream. Belt-and-suspenders alongside the server-side scrub.
-// Only strips tokens containing a PIPE — the harmony/channel control tokens
-// (<|channel|>, <|tool_response|>, <channel|>) always have one. Real code like
-// <div>, Vec<T>, a < b has no pipe and is left untouched.
 const MODEL_TOKEN_RE = /<\|[a-z_]*\|?>|<[a-z_]+\|>/gi;
 
 export function stripModelTokens(text) {
   return text.replace(MODEL_TOKEN_RE, "");
 }
 
-// Streaming-safe stripper: the leaked tokens (<|channel|>, <|tool_response|>, …)
-// can be split across stream chunks ("<chann" then "el|>"), which a per-delta
-// regex misses. This buffers any trailing "<…" that might be the start of a
-// token and only emits it once it's confirmed not-a-token (or on flush).
 export function makeTokenStripper() {
   let buf = "";
   return {
     push(text) {
       buf = (buf + text).replace(MODEL_TOKEN_RE, "");
-      const partial = buf.match(/<[|a-z_/]*$/i); // possible token start at the tail
+      const partial = buf.match(/<[|a-z_/]*$/i);
       if (partial) {
         const emit = buf.slice(0, partial.index);
         buf = buf.slice(partial.index);
@@ -230,25 +286,3 @@ export function makeTokenStripper() {
     },
   };
 }
-
-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);
-}