aether-code 0.27.0 → 0.29.0

package/bin/aether-code.js

@@ -28,7 +28,7 @@ import {
 import readline from "node:readline";
 import { c, errorLine, divider, setTerminalTitle } from "../src/render.js";
 
-const VERSION = "0.27.0";
+const VERSION = "0.29.0";
 
 /**
  * Try to start MCP servers from ~/.aether/mcp.json. Returns a started
@@ -146,6 +146,19 @@ function isSystemDir(p) {
   );
 }
 
+// Always restore the terminal on exit. The raw-mode input box, the ask_user
+// menu, and the spinner hide the cursor (\x1b[?25l) and set raw mode; if the
+// process dies mid-prompt (an uncaught error, or the MCP SIGINT handler's
+// process.exit(130)) their own cleanup never runs and the user's shell is left
+// with no cursor and no echo. This idempotent backstop fires on every exit.
+function restoreTerminal() {
+  try {
+    if (process.stdout.isTTY) process.stdout.write("\x1b[?25h"); // show cursor
+    if (process.stdin.isTTY && process.stdin.setRawMode) process.stdin.setRawMode(false);
+  } catch { /* terminal already gone — nothing to restore */ }
+}
+process.on("exit", restoreTerminal);
+
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   setTerminalTitle("Aether");

package/package.json

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

@@ -18,6 +18,17 @@ function envContext(cwd) {
   const home = os.homedir();
   const desktop = path.join(home, "Desktop");
   const documents = path.join(home, "Documents");
+  const win = process.platform === "win32";
+  // OS-specific shell guidance: gemma tends to emit Unix commands (mkdir -p,
+  // touch, &&-chains) which FAIL in Windows cmd.exe ("The syntax of the command
+  // is incorrect"). Steer it to the file tools (which are cross-platform and
+  // auto-create parent dirs) and OS-appropriate shell usage.
+  const shellNote = win
+    ? `shell: Windows cmd.exe. To create files OR directories, use the write_file tool — ` +
+      `it creates any missing parent folders automatically. Do NOT use shell "mkdir -p", ` +
+      `"touch", "ls", "rm", "cp", "mv", or "&&"-chained Unix commands; they FAIL in cmd.exe. ` +
+      `Run programs/tests with their interpreter (python, node, java, etc.).`
+    : `shell: POSIX sh. Standard Unix commands are available. write_file still auto-creates parent dirs.`;
   return (
     `[environment]\n` +
     `os: ${process.platform}\n` +
@@ -25,6 +36,7 @@ function envContext(cwd) {
     `home: ${home}\n` +
     `desktop: ${desktop}\n` +
     `documents: ${documents}\n` +
+    `${shellNote}\n` +
     `When the user names a location ("my desktop", "home", "documents"), write to ` +
     `the matching ABSOLUTE path above (e.g. desktop -> ${desktop}). Otherwise ` +
     `work under the cwd. Use absolute paths when a specific location is named.\n` +
@@ -83,6 +95,16 @@ export async function runAgent({
   // Files the run created/edited, shown in a summary at the end so the user
   // knows exactly what was produced and where to find it.
   const filesTouched = new Map();
+  // Files the run read — used by the completeness guard to spot files that were
+  // read (e.g. callers in a refactor) but never edited.
+  const filesRead = new Set();
+  // Completeness guard: gemma sometimes reads files then narrates the fix as
+  // text, or refactors one file but forgets the others. If a MODIFICATION task
+  // finishes having read files it never edited, we nudge it once to finish.
+  const MOD_RE =
+    /\b(refactor|fix|add|adds?|change|update|implement|creat|writ|remov|delet|rename|extract|move|replace|build|generate|insert|append|convert|migrat|wire|hook|edit|modif|patch|integrat)/i;
+  const looksLikeModification = MOD_RE.test(initialPrompt);
+  let appliedNothingNudges = 0;
 
   for (let i = 0; i < maxTurns; i++) {
     // No turn header and no leading blank here — each step (assistant text and
@@ -173,6 +195,24 @@ export async function runAgent({
 
     const toolCalls = res.message.tool_calls ?? [];
     if (toolCalls.length === 0) {
+      // Completeness guard: on a modification task, if the model read files it
+      // never edited, it likely either described the fix instead of applying it
+      // (zero edits) or refactored some files but forgot others (partial). Nudge
+      // once (at most) to finish. The "if it needs no change, just finish" escape
+      // keeps a legitimately read-for-context file from forcing a wrong edit.
+      const unedited = [...filesRead].filter((p) => !filesTouched.has(p));
+      if (looksLikeModification && appliedNothingNudges < 1 && (filesTouched.size === 0 ? referencedPaths.length > 0 : unedited.length > 0)) {
+        appliedNothingNudges++;
+        const msg =
+          filesTouched.size === 0
+            ? "You read the file(s) but applied NO changes (no write_file / edit_file). This task asks you to " +
+              "modify code — ACTUALLY APPLY the change now with edit_file/write_file, don't just describe it."
+            : `You edited ${[...filesTouched.keys()].join(", ")} but read ${unedited.join(", ")} without editing ${unedited.length === 1 ? "it" : "them"}. ` +
+              `If the task needs ${unedited.length === 1 ? "that file" : "those files"} changed too (e.g. updating callers/imports after a refactor), do it NOW. ` +
+              `If ${unedited.length === 1 ? "it genuinely needs" : "they genuinely need"} no change, then finish.`;
+        messages.push({ role: "user", content: msg });
+        continue; // give the model another turn to finish
+      }
       if (filesTouched.size) {
         console.log("\n" + c.bold("Files") + c.gray(` in ${cwd}`));
         for (const [p, action] of filesTouched) {
@@ -230,9 +270,13 @@ export async function runAgent({
       if (call.function.name === "read_file" || call.function.name === "edit_file" || call.function.name === "write_file") {
         if (typeof args.path === "string") referencedPaths.push(args.path);
       }
-      if (result.ok && typeof args.path === "string" && (call.function.name === "write_file" || call.function.name === "edit_file")) {
+      if (result.ok && typeof args.path === "string") {
         const rel = path.relative(cwd, path.resolve(cwd, args.path)) || args.path;
-        filesTouched.set(rel, call.function.name === "write_file" ? "created" : "edited");
+        if (call.function.name === "write_file" || call.function.name === "edit_file") {
+          filesTouched.set(rel, call.function.name === "write_file" ? "created" : "edited");
+        } else if (call.function.name === "read_file") {
+          filesRead.add(rel);
+        }
       }
       const summary = toolSummary(call.function.name, result);
       if (summary) console.log(summary);

package/src/api.js

@@ -33,6 +33,9 @@ export async function fetchWithRetry(url, options, { retries = 2, baseDelay = 50
     try {
       const res = await fetch(url, options);
       if (res.status >= 500 && attempt < retries) {
+        // Release the connection back to the pool before retrying — an
+        // unconsumed body keeps the socket open (undici won't reuse it).
+        res.body?.cancel().catch(() => {});
         attempt++;
         if (onRetry) onRetry(attempt, `HTTP ${res.status}`);
         await sleep(baseDelay * 2 ** (attempt - 1));
@@ -175,39 +178,69 @@ export async function agentTurnStream({
   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;
-      }
+
+  // Dispatch a single parsed SSE "data:" line.
+  const handleLine = (line) => {
+    if (!line.startsWith("data:")) return;
+    const json = line.slice(5).trim(); // .trim() also drops a CRLF trailing \r
+    if (!json) return;
+    let evt;
+    try { evt = JSON.parse(json); } catch { return; }
+    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;
+    }
+  };
+
+  // Watchdog: if the open stream stalls (no bytes) for too long, abort instead
+  // of hanging the CLI forever.
+  const READ_TIMEOUT_MS = 120_000;
+  const readOnce = () => {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+      timer = setTimeout(
+        () => reject(new AetherError("Stream stalled — no data for 120s", "STREAM_TIMEOUT", 0)),
+        READ_TIMEOUT_MS,
+      );
+    });
+    return Promise.race([reader.read(), timeout]).finally(() => clearTimeout(timer));
+  };
+
+  try {
+    while (true) {
+      const { value, done } = await readOnce();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) handleLine(line);
     }
+    // Flush any multibyte bytes the decoder is holding, then process a final
+    // line that arrived without a trailing newline (else the "done" event with
+    // credits/usage is silently dropped).
+    buffer += decoder.decode();
+    if (buffer.trim()) handleLine(buffer);
+  } catch (e) {
+    reader.cancel().catch(() => {});
+    throw e;
+  } finally {
+    try { reader.releaseLock(); } catch { /* already released / pending — ignore */ }
   }
 
   if (streamError) {

package/src/repl.js

@@ -16,7 +16,7 @@ import { c, errorLine, boxLines, sideBySide } from "./render.js";
 import { checkForUpdate } from "./update-check.js";
 import { promptBox, EXIT_SIGNAL } from "./box-input.js";
 
-const VERSION = "0.27.0";
+const VERSION = "0.29.0";
 const MODEL_NAME = "Aether Core";
 
 const SHORTCUTS = `

package/src/tools.js

@@ -336,7 +336,14 @@ function resolveSafe(rel, opts) {
   const abs = path.isAbsolute(rel) ? path.normalize(rel) : path.resolve(opts.cwd, rel);
   if (!opts.unsafePaths) {
     const cwd = path.resolve(opts.cwd);
-    if (!abs.startsWith(cwd + path.sep) && abs !== cwd) {
+    // Use path.relative (not startsWith) so Windows drive-relative inputs like
+    // "C:evil.txt" — which path.isAbsolute() reports as NON-absolute and
+    // path.resolve() may anchor to a drive's own cwd outside the project — are
+    // caught. A path is inside cwd only if its relative form doesn't climb out
+    // (no leading "..") and isn't itself absolute (different drive/root).
+    const relToCwd = path.relative(cwd, abs);
+    const escapes = relToCwd === ".." || relToCwd.startsWith(".." + path.sep) || path.isAbsolute(relToCwd);
+    if (abs !== cwd && escapes) {
       throw new Error(
         `Refusing to touch path outside cwd: ${abs}\n  Run with --unsafe-paths if you really mean this.`,
       );
@@ -591,11 +598,11 @@ async function editFile(args, opts) {
       output: `\`find\` text appears ${occurrences} times — must be unique. Add more context to disambiguate, or set replace_all: true to replace all ${occurrences}.`,
     };
   }
-  // split/join replaces every occurrence without regex-escaping pitfalls; for
-  // the default single-edit path occurrences === 1 so it's equivalent.
-  const newContent = args.replace_all
-    ? oldContent.split(args.find).join(args.replace)
-    : oldContent.replace(args.find, args.replace);
+  // split/join for BOTH paths: String.replace(str, str) would interpret special
+  // patterns in the replacement ($&, $`, $', $$) and silently corrupt code that
+  // contains them (regex, jQuery $, template strings). split/join is literal.
+  // On the single-edit path occurrences === 1, so it's equivalent + safe.
+  const newContent = oldContent.split(args.find).join(args.replace);
   const rel = path.relative(opts.cwd, abs);
   console.log(c.dim(`edit ${rel}${args.replace_all ? ` (${occurrences} occurrences)` : ""}`));
   console.log(unifiedDiff(oldContent, newContent, rel));