aether-code 0.16.2 → 0.16.4

package/bin/aether-code.js

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

package/package.json

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

@@ -6,7 +6,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, toolHeader, toolResult, errorLine } from "./render.js";
+import { c, divider, turn, toolLabel, toolSummary, makeTokenStripper, errorLine } from "./render.js";
 
 const DEFAULT_MAX_TURNS = 25;
 
@@ -59,6 +59,7 @@ export async function runAgent({
     // calling a particular tool (i.e. the `name` arrives in the stream).
     const announced = new Set();
     let lastWasText = false;
+    const stripper = makeTokenStripper();
 
     // Select skills for this turn against the current user prompt + any
     // paths the model has read so far. Prepend the matching skills' bodies
@@ -73,19 +74,24 @@ export async function runAgent({
         messages: turnMessages,
         tools,
         onDelta: (text) => {
+          // Buffered strip of leaked model channel/control tokens (which can
+          // be split across stream chunks) before display.
+          const clean = stripper.push(text);
+          if (!clean) return;
           if (!lastWasText) {
             process.stdout.write("  ");
             lastWasText = true;
           }
-          process.stdout.write(text);
+          process.stdout.write(clean);
         },
         onToolCallDelta: (delta) => {
-          // Print the tool header once we know the name (first chunk for that index)
+          // Just close the streamed text line when the model starts a tool
+          // call — the clean label is printed at execution time, so no noisy
+          // "preparing args" placeholder here.
           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"));
           }
         },
       });
@@ -96,7 +102,12 @@ export async function runAgent({
       throw err;
     }
 
-    // End-of-turn newline + cost meter
+    // Flush any held-back partial token, then close the line.
+    const tail = stripper.flush();
+    if (tail) {
+      if (!lastWasText) { process.stdout.write("  "); lastWasText = true; }
+      process.stdout.write(tail);
+    }
     if (lastWasText) process.stdout.write("\n");
     totalCredits += res.creditsCharged ?? 0;
     totalIn += res.usage?.prompt_tokens ?? 0;
@@ -125,7 +136,7 @@ export async function runAgent({
       let args = {};
       try { args = JSON.parse(call.function.arguments || "{}"); } catch { /* leave empty */ }
       console.log("");
-      console.log(toolHeader(call.function.name, args));
+      console.log(toolLabel(call.function.name, args));
 
       // Route to MCP if the tool name is namespaced (mcp__server__tool);
       // otherwise execute the built-in tool. unnamespaceToolName returns
@@ -143,10 +154,7 @@ 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.output) {
-        const preview = result.output.length > 800 ? result.output.slice(0, 800) + "\n…(truncated)" : result.output;
-        console.log(toolResult(preview, result.ok));
-      }
+      console.log(toolSummary(call.function.name, result));
 
       messages.push({
         role: "tool",

package/src/render.js

@@ -35,6 +35,99 @@ export function toolHeader(name, args) {
   return `${c.cyan(c.bold(name))}${c.gray("(")}${c.gray(trimmed)}${c.gray(")")}`;
 }
 
+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));
+  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("glob")}   ${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 verb("plan");
+    default:             return `${verb(name)} ${arg(JSON.stringify(a))}`;
+  }
+}
+
+// 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 toolSummary(name, result) {
+  const ok = result.ok;
+  const mark = 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 `  ${mark} ${c.gray(code === null ? (ok ? "done" : "failed") : `exit ${code}`)}`;
+  }
+  if (name === "write_file" || name === "edit_file" || name === "todo_write") {
+    // Handler already printed the diff / plan; echo its short status line.
+    return `  ${mark} ${c.gray(ellip(firstLine, 100))}`;
+  }
+  let summary = "";
+  try {
+    const j = JSON.parse(out);
+    if (Array.isArray(j)) summary = `${j.length} result${j.length === 1 ? "" : "s"}`;
+    else if (Array.isArray(j.files)) summary = `${j.files.length} file${j.files.length === 1 ? "" : "s"}`;
+    else if (Array.isArray(j.matches)) summary = `${j.matches.length} match${j.matches.length === 1 ? "" : "es"}`;
+  } catch { /* not JSON */ }
+  if (!summary) {
+    summary = name === "read_file" ? `${out.split("\n").length} lines` : ellip(firstLine, 100);
+  }
+  return `  ${mark} ${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
+      if (partial) {
+        const emit = buf.slice(0, partial.index);
+        buf = buf.slice(partial.index);
+        return emit;
+      }
+      const emit = buf;
+      buf = "";
+      return emit;
+    },
+    flush() {
+      const out = buf.replace(MODEL_TOKEN_RE, "");
+      buf = "";
+      return out;
+    },
+  };
+}
+
 export function toolResult(text, ok = true) {
   const prefix = ok ? c.green("  ✓ ") : c.red("  ✗ ");
   // First line bold-ish, then dim continuation

package/src/repl.js

@@ -17,7 +17,7 @@ import { c, errorLine } from "./render.js";
 import { checkForUpdate } from "./update-check.js";
 import { promptBoxed, EXIT_SIGNAL } from "./ink-input.js";
 
-const VERSION = "0.16.2";
+const VERSION = "0.16.4";
 const MODEL_NAME = "Aether Core";
 
 const SHORTCUTS = `