aether-code 0.26.0 → 0.28.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.26.0";
+const VERSION = "0.28.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.26.0",
+  "version": "0.28.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

@@ -83,6 +83,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
@@ -118,6 +128,9 @@ export async function runAgent({
           // be split across stream chunks) before display.
           const clean = stripper.push(text);
           if (!clean) return;
+          // Don't open a "● " bullet for leading whitespace (e.g. when a whole
+          // turn's text was suppressed as a leak, leaving only a stray newline).
+          if (!lastWasText && !clean.trim()) return;
           stopSpin();
           if (!lastWasText) {
             process.stdout.write("\n" + c.cyan("● "));
@@ -148,7 +161,7 @@ export async function runAgent({
 
     // Flush any held-back partial token, then close the line.
     const tail = stripper.flush();
-    if (tail) {
+    if (tail && (lastWasText || tail.trim())) {
       if (!lastWasText) { process.stdout.write("\n" + c.cyan("● ")); lastWasText = true; }
       process.stdout.write(tail);
     }
@@ -170,6 +183,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) {
@@ -227,9 +258,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/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.26.0";
+const VERSION = "0.28.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));