aether-code 0.22.0 → 0.24.0

package/bin/aether-code.js

@@ -26,7 +26,7 @@ import {
 import readline from "node:readline";
 import { c, errorLine, divider, setTerminalTitle } from "../src/render.js";
 
-const VERSION = "0.22.0";
+const VERSION = "0.24.0";
 
 /**
  * Try to start MCP servers from ~/.aether/mcp.json. Returns a started

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aether-code",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "Uncensored AI coding agent for your terminal — Claude Code alternative with MCP support. Reads code, writes files, runs commands. Drives IDA Pro, Roblox Studio, Wireshark, Blender, and any MCP server. No refusal layer.",
   "homepage": "https://trynoguard.com",
   "repository": {

package/src/agent.js

@@ -8,7 +8,7 @@ import { agentTurnStream, AetherError } from "./api.js";
 import { TOOL_DEFINITIONS, executeTool } from "./tools.js";
 import { unnamespaceToolName } from "./mcp.js";
 import { loadAllSkills, selectSkills, renderSkillsBlock } from "./skills.js";
-import { c, divider, turn, toolLabel, toolSummary, makeTokenStripper, errorLine } from "./render.js";
+import { c, divider, turn, toolLabel, toolSummary, makeTokenStripper, errorLine, startSpinner } from "./render.js";
 
 const DEFAULT_MAX_TURNS = 25;
 
@@ -77,6 +77,9 @@ export async function runAgent({
   let totalIn = 0;
   let totalOut = 0;
   let lastBalance = null;
+  // Loop guard: count identical (name+args) tool calls across the whole run so a
+  // confused model can't burn turns re-running the same call (e.g. glob *.md x9).
+  const callCounts = new Map();
 
   for (let i = 0; i < maxTurns; i++) {
     // No turn header and no leading blank here — each step (assistant text and
@@ -98,6 +101,11 @@ export async function runAgent({
     const turnMessages = buildTurnMessages(messages, allSkills, referencedPaths);
 
     let res;
+    // "Thinking" spinner: shown from request-send until the first token or tool
+    // call arrives, so the wait doesn't look dead. Stopped exactly once.
+    const spinner = startSpinner("thinking");
+    let spinStopped = false;
+    const stopSpin = () => { if (!spinStopped) { spinStopped = true; spinner.stop(); } };
     try {
       res = await agentTurnStream({
         messages: turnMessages,
@@ -107,6 +115,7 @@ export async function runAgent({
           // be split across stream chunks) before display.
           const clean = stripper.push(text);
           if (!clean) return;
+          stopSpin();
           if (!lastWasText) {
             process.stdout.write("\n" + c.cyan("● "));
             lastWasText = true;
@@ -118,6 +127,7 @@ export async function runAgent({
           // call — the clean label is printed at execution time, so no noisy
           // "preparing args" placeholder here.
           if (delta.name && !announced.has(delta.index)) {
+            stopSpin();
             announced.add(delta.index);
             if (lastWasText) process.stdout.write("\n");
             lastWasText = false;
@@ -125,11 +135,13 @@ export async function runAgent({
         },
       });
     } catch (err) {
+      stopSpin();
       if (err instanceof AetherError) {
         return { ok: false, error: err, totalCredits, totalIn, totalOut, balance: lastBalance, messages };
       }
       throw err;
     }
+    stopSpin(); // ensure it's cleared even if the turn produced no output
 
     // Flush any held-back partial token, then close the line.
     const tail = stripper.flush();
@@ -167,14 +179,37 @@ export async function runAgent({
       const label = toolLabel(call.function.name, args);
       if (label) console.log("\n" + c.cyan("●") + " " + label);
 
+      // Loop guard — short-circuit a tool call we've already run 3+ times with
+      // the same args, and tell the model to change approach instead of looping.
+      const sig = `${call.function.name}:${call.function.arguments || ""}`;
+      const seen = (callCounts.get(sig) || 0) + 1;
+      callCounts.set(sig, seen);
+      if (seen > 3) {
+        console.log("  " + c.red("└─") + " " + c.gray("skipped (repeated call)"));
+        messages.push({
+          role: "tool",
+          tool_call_id: call.id,
+          content:
+            "STOP: you have already run this exact tool call 3 times and the result will not change. Do NOT call it again. " +
+            "If you were looking for a file that doesn't exist, create it with write_file. Otherwise change approach or finish and summarize.",
+        });
+        continue;
+      }
+
       // Route to MCP if the tool name is namespaced (mcp__server__tool);
       // otherwise execute the built-in tool. unnamespaceToolName returns
       // null for non-MCP names, which is our cheap dispatch test.
+      const slow = call.function.name === "web_search" || call.function.name === "web_fetch";
+      const tspin = slow ? startSpinner(call.function.name === "web_search" ? "searching the web" : "fetching page") : null;
       let result;
-      if (mcpManager && unnamespaceToolName(call.function.name)) {
-        result = await mcpManager.callTool(call.function.name, args);
-      } else {
-        result = await executeTool(call, { cwd, autoYes, unsafePaths });
+      try {
+        if (mcpManager && unnamespaceToolName(call.function.name)) {
+          result = await mcpManager.callTool(call.function.name, args);
+        } else {
+          result = await executeTool(call, { cwd, autoYes, unsafePaths });
+        }
+      } finally {
+        if (tspin) tspin.stop();
       }
 
       // Track paths the model has touched. Skills with path-pattern triggers

package/src/box-input.js

@@ -0,0 +1,132 @@
+// Bordered single-line text input — raw-mode, cmd.exe-safe.
+//
+// Like the ask_user menu, this is NOT Ink (which ghosts in the legacy Windows
+// console). It draws a 3-line box + hint, and on every keystroke moves the
+// cursor back up (ESC[nA), clears (ESC[J), and reprints. The caret is a FAKE
+// cursor (inverse-video cell) and the real terminal cursor is hidden, so there
+// is no cursor-column math to get wrong. Long input scrolls horizontally under
+// a fixed right border.
+//
+// Returns the typed string, or EXIT_SIGNAL on Ctrl+C / Ctrl+D.
+
+import readline from "node:readline";
+import { c } from "./render.js";
+
+export const EXIT_SIGNAL = "<<aether-exit>>";
+
+const HIDE = "\x1b[?25l";
+const SHOW = "\x1b[?25h";
+const INV = (s) => `\x1b[7m${s}\x1b[27m`;
+
+export function promptBox({ history = [], placeholder = "type a message…  /help for commands" } = {}) {
+  return new Promise((resolve) => {
+    // Non-interactive (piped / tests): plain readline, no box.
+    if (!process.stdin.isTTY) {
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      rl.question(c.magenta("› "), (a) => { rl.close(); resolve(a); });
+      return;
+    }
+
+    let buf = "";
+    let pos = 0;                 // caret index within buf
+    const hist = history.slice();
+    let histIdx = hist.length;   // points one past the end (current draft)
+    let draft = "";
+    let drawn = 0;
+    let lastSigint = 0;
+
+    const innerW = () => Math.max(24, Math.min(process.stdout.columns || 80, 100) - 6);
+
+    const draw = (first) => {
+      const W = innerW();
+      if (!first) process.stdout.write(`\x1b[${drawn}A`);
+      process.stdout.write("\x1b[J");
+
+      // Horizontal scroll: keep the caret within the visible window.
+      const maxVisible = W - 1;
+      const start = pos > maxVisible ? pos - maxVisible : 0;
+      const view = buf.slice(start, start + W);
+      const rel = pos - start;
+
+      let content;
+      if (buf.length === 0) {
+        const ph = placeholder.slice(0, W - 1);
+        content = INV(" ") + c.dim(ph) + " ".repeat(Math.max(0, W - 1 - ph.length));
+      } else {
+        let s = "";
+        for (let i = 0; i < W; i++) {
+          const ch = view[i] ?? " ";
+          s += i === rel ? INV(ch) : ch;
+        }
+        content = s;
+      }
+
+      const top = c.magenta("╭" + "─".repeat(W + 4) + "╮");
+      const mid = c.magenta("│") + " " + c.magenta("›") + " " + content + " " + c.magenta("│");
+      const bot = c.magenta("╰" + "─".repeat(W + 4) + "╯");
+      const hint = c.dim("  Enter send · ↑↓ history · /help · /exit");
+
+      process.stdout.write(top + "\n" + mid + "\n" + bot + "\n" + hint + "\n");
+      drawn = 4;
+    };
+
+    const finish = (result) => {
+      process.stdin.removeListener("keypress", onKey);
+      if (process.stdin.isTTY) process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.stdout.write(`\x1b[${drawn}A\x1b[J` + SHOW);
+      // Echo the submitted line so it persists in scrollback.
+      if (result && result !== EXIT_SIGNAL && result.trim()) {
+        process.stdout.write(c.magenta("› ") + result + "\n");
+      }
+      resolve(result);
+    };
+
+    const onKey = (str, key) => {
+      if (!key) return;
+      const k = key.name;
+
+      if (k === "return" || k === "enter") return finish(buf);
+      if (key.ctrl && k === "c") {
+        const now = Date.now();
+        if (now - lastSigint < 1500 || buf.length === 0) return finish(EXIT_SIGNAL);
+        lastSigint = now;
+        buf = ""; pos = 0; draw(false);
+        return;
+      }
+      if (key.ctrl && k === "d") return finish(buf.length === 0 ? EXIT_SIGNAL : buf);
+
+      if (k === "backspace") { if (pos > 0) { buf = buf.slice(0, pos - 1) + buf.slice(pos); pos--; } }
+      else if (k === "delete") { buf = buf.slice(0, pos) + buf.slice(pos + 1); }
+      else if (k === "left") { if (pos > 0) pos--; }
+      else if (k === "right") { if (pos < buf.length) pos++; }
+      else if (k === "home" || (key.ctrl && k === "a")) pos = 0;
+      else if (k === "end" || (key.ctrl && k === "e")) pos = buf.length;
+      else if (key.ctrl && k === "u") { buf = ""; pos = 0; }
+      else if (k === "up") {
+        if (histIdx === hist.length) draft = buf;
+        if (histIdx > 0) { histIdx--; buf = hist[histIdx] ?? ""; pos = buf.length; }
+      }
+      else if (k === "down") {
+        if (histIdx < hist.length) {
+          histIdx++;
+          buf = histIdx === hist.length ? draft : (hist[histIdx] ?? "");
+          pos = buf.length;
+        }
+      }
+      else if (str && !key.ctrl && !key.meta && str >= " " && str !== "\x7f") {
+        buf = buf.slice(0, pos) + str + buf.slice(pos);
+        pos += str.length;
+      }
+      else return; // ignore unhandled keys without a redraw
+      draw(false);
+    };
+
+    process.stdout.write(HIDE);
+    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

@@ -80,6 +80,33 @@ 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.
+export function startSpinner(label) {
+  if (!process.stdout.isTTY) return { stop: () => {} };
+  const frames = ["◐", "◓", "◑", "◒"];
+  const t0 = Date.now();
+  let i = 0;
+  process.stdout.write("\x1b[?25l"); // hide cursor
+  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}`);
+    i++;
+  };
+  render();
+  const timer = setInterval(render, 120);
+  if (typeof timer.unref === "function") timer.unref(); // don't keep the process alive
+  return {
+    stop: () => {
+      clearInterval(timer);
+      process.stdout.write("\r\x1b[K\x1b[?25h"); // clear line + show cursor
+    },
+  };
+}
+
 // 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.

package/src/repl.js

@@ -8,16 +8,15 @@
 //   - 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, box } from "./render.js";
 import { checkForUpdate } from "./update-check.js";
-import { promptBoxed, EXIT_SIGNAL } from "./ink-input.js";
+import { promptBox, EXIT_SIGNAL } from "./box-input.js";
 
-const VERSION = "0.22.0";
+const VERSION = "0.24.0";
 const MODEL_NAME = "Aether Core";
 
 const SHORTCUTS = `
@@ -85,76 +84,19 @@ export async function runRepl({ cwd: initialCwd, autoYes: initialAutoYes, unsafe
   const updateNudge = await updatePromise;
   if (updateNudge) console.log(updateNudge + "\n");
 
-  // Input: the Ink boxed input (bordered, Claude-style) when the terminal
-  // renders it cleanly, with a readline fallback otherwise.
-  //
-  // The legacy Windows console (cmd.exe / conhost) mishandles Ink's live
-  // redraw + raw-mode: typed characters ghost (the console echoes what Ink
-  // already drew) and the box border tears on each keystroke. Windows Terminal
-  // (sets WT_SESSION) and non-Windows render Ink correctly. So we default to
-  // the clean prompt on legacy Windows console; AETHER_INK=1 forces Ink there
-  // for anyone who wants to try it, AETHER_NO_INK=1 forces the plain prompt.
+  // Input: a bordered raw-mode box (box-input.js) — cmd.exe-safe and identical
+  // everywhere. (Ink's live redraw ghosts in the legacy Windows console, so we
+  // don't use it.) Each prompt is independent; the tool y/N prompts and the
+  // ask_user menu run BETWEEN prompts in raw mode too, so nothing overlaps.
   const inputHistory = [];
-  const legacyWinConsole = process.platform === "win32" && !process.env.WT_SESSION;
-  const useInk =
-    !!process.stdin.isTTY &&
-    process.env.AETHER_NO_INK !== "1" &&
-    (process.env.AETHER_INK === "1" || !legacyWinConsole);
-  let inkBroken = false;
-
-  // The Ink box carries its own status bar; the plain prompt doesn't, so show a
-  // one-line hint up front when we won't be using Ink.
-  if (!useInk) console.log(` ${c.cyan("/help")}${c.dim(" shortcuts")}   ${c.cyan("/exit")}${c.dim(" quit")}\n`);
-
-  // Fresh readline interface PER PROMPT. A single persistent interface
-  // conflicted with the per-confirmation readline interfaces the tools open
-  // during a turn (each [y/N] prompt). When a tool's interface closed it left
-  // the REPL's stdin dead — so after finishing a request aether printed the
-  // prompt and immediately EXITED instead of waiting for the next message.
-  // Opening a fresh one each prompt guarantees only one interface exists at a
-  // time, so the REPL keeps running until the user /exits. Returns EXIT_SIGNAL
-  // on a double Ctrl+C.
-  function readlineQuestion() {
-    return new Promise((resolve) => {
-      const r = readline.createInterface({ input: process.stdin, output: process.stdout, historySize: 200 });
-      let lastSigint = 0;
-      r.on("SIGINT", () => {
-        const now = Date.now();
-        if (now - lastSigint < 1500) { r.close(); resolve(EXIT_SIGNAL); return; }
-        lastSigint = now;
-        process.stdout.write(c.gray(`\n(Press Ctrl+C again within 1.5s to exit, or type ${c.cyan("/exit")})\n`));
-        r.prompt();
-      });
-      r.question(c.magenta("> "), (ans) => { r.close(); resolve(ans); });
-    });
-  }
-
-  // Returns the next raw input line, or EXIT_SIGNAL to quit.
-  async function nextLine() {
-    if (useInk && !inkBroken) {
-      try {
-        return await promptBoxed({
-          statusLeft: ` ${c.cyan("/help")}${c.dim(" shortcuts")}   ${c.cyan("/exit")}${c.dim(" quit")}`,
-          statusRight: `${state.autoYes ? "auto-yes" : "review"} · ${MODEL_NAME}`,
-          history: inputHistory,
-        });
-      } catch {
-        inkBroken = true;
-        console.log(c.gray("(rich input unavailable here — using the basic prompt)"));
-      }
-    }
-    return readlineQuestion();
-  }
 
   while (true) {
-    const raw = await nextLine();
+    const raw = await promptBox({ history: inputHistory });
     if (raw === EXIT_SIGNAL) { console.log(c.gray("bye.")); return; }
     const line = (raw ?? "").trim();
     if (!line) continue;
 
-    // Echo the submitted line so it persists in scrollback (Ink clears its box
-    // region on unmount). Skip in readline mode — the terminal already echoed it.
-    if (useInk && !inkBroken) console.log(c.magenta("> ") + line);
+    // promptBox already echoes "› <line>" on submit, so no echo needed here.
     inputHistory.push(line);
 
     // Slash command?

package/src/tools.js

@@ -574,7 +574,12 @@ async function editFile(args, opts) {
     return { ok: false, output: "path, find, replace are required" };
   }
   const abs = resolveSafe(args.path, opts);
-  if (!fs.existsSync(abs)) return { ok: false, output: `File not found: ${args.path}` };
+  if (!fs.existsSync(abs)) {
+    return {
+      ok: false,
+      output: `File not found: ${args.path}. It doesn't exist yet — use write_file to CREATE it (edit_file only modifies existing files). Do not retry edit_file on this path.`,
+    };
+  }
   const oldContent = fs.readFileSync(abs, "utf8");
   const occurrences = oldContent.split(args.find).length - 1;
   if (occurrences === 0) {