aether-code 0.41.0 → 0.43.0

package/package.json

@@ -1,75 +1,75 @@
-{
-  "name": "aether-code",
-  "version": "0.41.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": {
-    "type": "git",
-    "url": "https://github.com/dannyphantomx64/aether-code"
-  },
-  "license": "MIT",
-  "type": "module",
-  "bin": {
-    "aether": "bin/aether-code.js"
-  },
-  "files": [
-    "bin",
-    "src",
-    "skills",
-    "README.md",
-    "LICENSE"
-  ],
-  "engines": {
-    "node": ">=18"
-  },
-  "scripts": {
-    "lint": "node --check bin/aether-code.js src/agent.js src/api.js src/config.js src/render.js src/tools.js src/diff.js src/repl.js src/mcp.js src/mcp-cli.js src/mcp-registry.js src/skills.js src/update-check.js src/ink-input.js src/version.js src/sessions.js src/project-context.js",
-    "test": "node --test \"test/**/*.test.js\"",
-    "prepublishOnly": "npm run lint && npm test"
-  },
-  "keywords": [
-    "aether",
-    "ai",
-    "ai-agent",
-    "ai-cli",
-    "ai-coding-assistant",
-    "ai-coding-agent",
-    "ai-pair-programmer",
-    "agent",
-    "agentic",
-    "agentic-ai",
-    "cli",
-    "claude-code",
-    "claude-code-alternative",
-    "cursor-alternative",
-    "coding-agent",
-    "code-generation",
-    "developer-tools",
-    "llm",
-    "llm-agent",
-    "llm-tools",
-    "mcp",
-    "mcp-client",
-    "model-context-protocol",
-    "modelcontextprotocol",
-    "ida-pro",
-    "reverse-engineering",
-    "roblox",
-    "uncensored",
-    "uncensored-ai",
-    "uncensored-llm",
-    "terminal",
-    "tool-use",
-    "tool-calling",
-    "trynoguard"
-  ],
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "ink": "^7.1.0",
-    "ink-text-input": "^6.0.0",
-    "react": "^19.2.7"
-  },
-  "devDependencies": {
-    "ink-testing-library": "^4.0.0"
-  }
-}
+{
+  "name": "aether-code",
+  "version": "0.43.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": {
+    "type": "git",
+    "url": "https://github.com/dannyphantomx64/aether-code"
+  },
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "aether": "bin/aether-code.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "skills",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "lint": "node --check bin/aether-code.js src/agent.js src/api.js src/config.js src/render.js src/tools.js src/diff.js src/repl.js src/mcp.js src/mcp-cli.js src/mcp-registry.js src/skills.js src/update-check.js src/ink-input.js src/version.js src/sessions.js src/project-context.js",
+    "test": "node --test \"test/**/*.test.js\"",
+    "prepublishOnly": "npm run lint && npm test"
+  },
+  "keywords": [
+    "aether",
+    "ai",
+    "ai-agent",
+    "ai-cli",
+    "ai-coding-assistant",
+    "ai-coding-agent",
+    "ai-pair-programmer",
+    "agent",
+    "agentic",
+    "agentic-ai",
+    "cli",
+    "claude-code",
+    "claude-code-alternative",
+    "cursor-alternative",
+    "coding-agent",
+    "code-generation",
+    "developer-tools",
+    "llm",
+    "llm-agent",
+    "llm-tools",
+    "mcp",
+    "mcp-client",
+    "model-context-protocol",
+    "modelcontextprotocol",
+    "ida-pro",
+    "reverse-engineering",
+    "roblox",
+    "uncensored",
+    "uncensored-ai",
+    "uncensored-llm",
+    "terminal",
+    "tool-use",
+    "tool-calling",
+    "trynoguard"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "ink": "^7.1.0",
+    "ink-text-input": "^6.0.0",
+    "react": "^19.2.7"
+  },
+  "devDependencies": {
+    "ink-testing-library": "^4.0.0"
+  }
+}

package/src/agent.js

@@ -14,6 +14,35 @@ import { c, divider, turn, toolLabel, toolSummary, makeTokenStripper, errorLine,
 
 const DEFAULT_MAX_TURNS = 25;
 
+// Rolling history window (messages) sent upstream per turn. The session keeps
+// the full transcript locally, but we only forward the anchor (first message,
+// which carries the [environment] block) plus the most recent N messages. This
+// bounds per-turn token cost AND keeps us safely under the server's own cap —
+// a long session used to grow unbounded and, past the server's limit, every
+// send failed with "Error: Invalid input." with no recovery but /clear.
+const HISTORY_WINDOW = 100;
+
+/**
+ * Trim a message array to `maxMessages`, preserving:
+ *   - the anchor message at index 0 (the first user turn carries the
+ *     [environment] block with real absolute paths — dropping it makes the
+ *     model lose cwd/home/desktop);
+ *   - tool-call/tool-result pairing at the window boundary: a `tool` message
+ *     must immediately follow the assistant message whose `tool_calls` produced
+ *     it, so the window is never allowed to BEGIN on an orphaned `tool` result.
+ * Returns the original array untouched when it's already within the window.
+ */
+export function trimHistory(messages, maxMessages = HISTORY_WINDOW) {
+  if (messages.length <= maxMessages) return messages;
+  const head = [messages[0]];
+  const windowSize = Math.max(1, maxMessages - 1);
+  let window = messages.slice(1).slice(-windowSize);
+  let start = 0;
+  while (start < window.length && window[start]?.role === "tool") start++;
+  window = window.slice(start);
+  return [...head, ...window];
+}
+
 export 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;
 
@@ -130,7 +159,7 @@ export async function runAgent({
     // to the last user message of a shallow-cloned messages array — we
     // don't want skill text accumulating in the persisted history, only
     // being available to the model for the turn where it's relevant.
-    const turnMessages = buildTurnMessages(messages, allSkills, referencedPaths);
+    const turnMessages = trimHistory(buildTurnMessages(messages, allSkills, referencedPaths));
 
     let res;
     // "Thinking" spinner: shown from request-send until the first token or tool
@@ -383,8 +412,23 @@ export async function runAgent({
   return { ok: false, error: new Error("Max turns reached"), totalCredits, totalIn, totalOut, balance: lastBalance, messages };
 }
 
+// A build/verify command failing because the TOOLCHAIN ITSELF is missing (e.g.
+// g++/cargo/dotnet not installed) is not a code bug — it must NOT be reported as
+// "build failed" and fed back to the model, which would derail the run into
+// 5 rounds of "fixing" code that's actually fine. These are the shell's
+// command-not-found messages (Windows cmd.exe + POSIX sh); real compiler
+// diagnostics look like `main.cpp:5:10: error: ...` and never match these.
+// Matches ONLY the shell's "I can't find this executable" messages — Windows
+// cmd.exe ("'g++' is not recognized…") and POSIX sh ("g++: command not found",
+// "sh: 1: g++: not found"). Real compiler diagnostics (`main.cpp:5: error:`,
+// `fatal error: foo.h: No such file or directory`) never match these, so a
+// genuine build error is still reported and fixed.
+const TOOLCHAIN_MISSING_RE =
+  /is not recognized as an internal or external command|: command not found|: not found\b/i;
+
 // Auto-verify: run the project's typecheck/lint command silently and return
-// { ok, output, label }. Returns null if no verify command is detected.
+// { ok, output, label }. Returns null if no verify command is detected OR the
+// toolchain isn't installed (skip, don't report a false failure).
 let cachedVerify = undefined;
 async function runVerify(cwd) {
   if (cachedVerify === undefined) cachedVerify = detectVerifyCommand(cwd);
@@ -400,6 +444,8 @@ async function runVerify(cwd) {
     child.on("close", (code) => {
       clearTimeout(timer);
       const output = (stdout + "\n" + stderr).trim();
+      // Toolchain not installed → skip silently rather than nag the model.
+      if (code !== 0 && TOOLCHAIN_MISSING_RE.test(output)) { resolve(null); return; }
       resolve({ ok: code === 0, output, label });
     });
     child.on("error", () => {
@@ -437,11 +483,15 @@ async function runBuildCmd(cwd, { cmd, label, type, runCmd }) {
     child.on("close", (code) => {
       clearTimeout(timer);
       const output = (stdout + "\n" + stderr).trim();
+      // Compiler/toolchain not installed → skip auto-build silently instead of
+      // reporting a build failure and derailing the run.
+      if (code !== 0 && TOOLCHAIN_MISSING_RE.test(output)) { resolve(null); return; }
       resolve({ ok: code === 0, output, label, type, runCmd });
     });
-    child.on("error", (err) => {
+    child.on("error", () => {
       clearTimeout(timer);
-      resolve({ ok: false, output: err.message, label, type, runCmd });
+      // ENOENT (command not found) → toolchain missing → skip.
+      resolve(null);
     });
   });
 }

package/src/api.js

@@ -7,18 +7,37 @@ const USER_AGENT = `aether-code/${getVersion()}`;
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
+// Per-request connect timeout. The server retries upstream internally (up to
+// 5 × 75s = 375s worst case), and during that time the CLI's fetch() just
+// hangs with zero feedback. This cap ensures we abort, show a retry message,
+// and try again rather than sitting dead for minutes.
+const CONNECT_TIMEOUT_MS = 90_000;
+
 /**
  * fetch() with bounded exponential-backoff retries. Retries on thrown network
  * errors (DNS/reset/offline blip) and transient 5xx; never retries 4xx
  * (auth/credit/validation — a retry won't help). Body is always a small JSON
  * string, so resending is safe. For the streaming endpoint only the initial
  * connection is retried.
+ *
+ * Each request has a hard 90s connect timeout via AbortController — if the
+ * server hasn't responded with headers by then, we abort and retry. This
+ * prevents the CLI from hanging indefinitely while the server retries
+ * upstream internally.
  */
-export async function fetchWithRetry(url, options, { retries = 4, baseDelay = 1000, onRetry } = {}) {
+export async function fetchWithRetry(url, options, { retries = 4, baseDelay = 1000, timeoutMs = CONNECT_TIMEOUT_MS, onRetry } = {}) {
   let attempt = 0;
   while (true) {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(new Error(`Server did not respond within ${Math.round(timeoutMs / 1000)}s`)), timeoutMs);
+    // If the caller already set a signal, chain it so both can abort.
+    const callerSignal = options?.signal;
+    if (callerSignal) {
+      callerSignal.addEventListener("abort", () => ac.abort(callerSignal.reason), { once: true });
+    }
     try {
-      const res = await fetch(url, options);
+      const res = await fetch(url, { ...options, signal: ac.signal });
+      clearTimeout(timer);
       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).
@@ -30,6 +49,7 @@ export async function fetchWithRetry(url, options, { retries = 4, baseDelay = 10
       }
       return res;
     } catch (e) {
+      clearTimeout(timer);
       if (attempt < retries) {
         attempt++;
         if (onRetry) onRetry(attempt, e.message);
@@ -207,7 +227,7 @@ export async function agentTurnStream({
     let timer;
     const timeout = new Promise((_, reject) => {
       timer = setTimeout(
-        () => reject(new AetherError("Stream stalled — no data for 120s", "STREAM_TIMEOUT", 0)),
+        () => reject(new AetherError(`Stream stalled — no data for ${Math.round(READ_TIMEOUT_MS / 1000)}s`, "STREAM_TIMEOUT", 0)),
         READ_TIMEOUT_MS,
       );
     });