aether-code 0.39.0 → 0.41.0

package/package.json

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

package/src/agent.js

@@ -9,7 +9,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 { scanProject, detectVerifyCommand } from "./project-context.js";
+import { scanProject, detectVerifyCommand, detectBuildCommand } from "./project-context.js";
 import { c, divider, turn, toolLabel, toolSummary, makeTokenStripper, errorLine, startSpinner } from "./render.js";
 
 const DEFAULT_MAX_TURNS = 25;
@@ -111,6 +111,7 @@ export async function runAgent({
   const looksLikeModification = MOD_RE.test(initialPrompt);
   let appliedNothingNudges = 0;
   let verifyRounds = 0;
+  let buildRounds = 0;
 
   for (let i = 0; i < maxTurns; i++) {
     // No turn header and no leading blank here — each step (assistant text and
@@ -220,6 +221,64 @@ export async function runAgent({
         messages.push({ role: "user", content: msg });
         continue; // give the model another turn to finish
       }
+      // Auto-build: if we wrote source files, detect the build toolchain and
+      // compile automatically. If build fails, feed errors back to the model
+      // so it can fix and recompile. Max 5 rounds to avoid infinite loops.
+      if (filesTouched.size > 0 && buildRounds < 5) {
+        const buildResult = await runBuild(cwd, [...filesTouched.keys()]);
+        if (buildResult && !buildResult.ok) {
+          buildRounds++;
+          console.log("\n" + c.yellow("●") + " " + c.bold("auto-build") + c.gray(` (${buildResult.label}) — round ${buildRounds}/5`));
+          console.log(c.red("  └─") + " " + c.gray("build failed — feeding errors back to fix"));
+          const errPreview = buildResult.output.length > 6000
+            ? buildResult.output.slice(0, 6000) + "\n…(truncated)"
+            : buildResult.output;
+          messages.push({
+            role: "user",
+            content:
+              `AUTO-BUILD FAILED (${buildResult.label}):\n\`\`\`\n${errPreview}\n\`\`\`\n` +
+              `Fix the build errors NOW using edit_file. Do not explain — just fix the code and move on.`,
+          });
+          continue;
+        }
+        if (buildResult && buildResult.ok) {
+          console.log("\n" + c.green("●") + " " + c.bold("auto-build") + c.gray(` (${buildResult.label}) — success`));
+          // If there's a run command and we haven't already run it, execute the result
+          if (buildResult.runCmd && buildRounds === 0) {
+            const runResult = await runBuiltProgram(cwd, buildResult.runCmd, buildResult.label);
+            if (runResult && !runResult.ok && buildRounds < 5) {
+              buildRounds++;
+              console.log(c.yellow("  ├─") + " " + c.bold("auto-run") + c.gray(` — crashed (exit ${runResult.code})`));
+              const errPreview = runResult.output.length > 6000
+                ? runResult.output.slice(0, 6000) + "\n…(truncated)"
+                : runResult.output;
+              messages.push({
+                role: "user",
+                content:
+                  `BUILD SUCCEEDED but the program CRASHED when run:\n\`\`\`\n${errPreview}\n\`\`\`\n` +
+                  `Fix the runtime error NOW using edit_file. Do not explain — just fix and move on.`,
+              });
+              continue;
+            }
+            if (runResult && runResult.ok) {
+              const preview = runResult.output.length > 2000
+                ? runResult.output.slice(0, 2000) + "\n…(truncated)"
+                : runResult.output;
+              if (runResult.timedOut) {
+                console.log(c.green("  ├─") + " " + c.bold("auto-run") + c.gray(" — running (still alive after 10s)"));
+              } else {
+                console.log(c.green("  ├─") + " " + c.bold("auto-run") + c.gray(` — exit 0`));
+              }
+              if (preview.trim()) {
+                const lines = preview.trim().split("\n").slice(0, 15);
+                for (const line of lines) {
+                  console.log(c.gray("  │  " + line));
+                }
+              }
+            }
+          }
+        }
+      }
       // Auto-verify: if we touched files, run the project's typecheck/lint
       // and feed errors back so the model can self-correct without the user
       // having to say "fix that." At most 2 verify rounds to avoid infinite loops.
@@ -350,6 +409,76 @@ async function runVerify(cwd) {
   });
 }
 
+// Auto-build: detect the build toolchain from written files and compile.
+// Returns { ok, output, label, runCmd } or null if no buildable project detected.
+let cachedBuild = undefined;
+async function runBuild(cwd, touchedFiles) {
+  // Re-detect every time because the model may create new files (e.g. Makefile)
+  // or change the project structure between rounds.
+  const detected = detectBuildCommand(cwd, touchedFiles);
+  if (!detected) {
+    // Fallback: if we previously detected a build command, reuse it (the model
+    // may have only edited files this round, not created new ones).
+    if (cachedBuild) return runBuildCmd(cwd, cachedBuild);
+    return null;
+  }
+  cachedBuild = detected;
+  return runBuildCmd(cwd, detected);
+}
+
+async function runBuildCmd(cwd, { cmd, label, type, runCmd }) {
+  return new Promise((resolve) => {
+    const child = spawn(cmd, [], { cwd, shell: true, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    const timer = setTimeout(() => { child.kill("SIGTERM"); }, 120_000);
+    child.stdout.on("data", (d) => { stdout += d.toString(); });
+    child.stderr.on("data", (d) => { stderr += d.toString(); });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      const output = (stdout + "\n" + stderr).trim();
+      resolve({ ok: code === 0, output, label, type, runCmd });
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      resolve({ ok: false, output: err.message, label, type, runCmd });
+    });
+  });
+}
+
+// Run the compiled/interpreted program after a successful build.
+// Returns { ok, output, code, timedOut } or null on spawn error.
+async function runBuiltProgram(cwd, runCmd, label) {
+  return new Promise((resolve) => {
+    const child = spawn(runCmd, [], { cwd, shell: true, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    const timer = setTimeout(() => { timedOut = true; child.kill("SIGTERM"); }, 10_000);
+    child.stdout.on("data", (d) => {
+      stdout += d.toString();
+      if (stdout.length > 50_000) { child.kill("SIGTERM"); }
+    });
+    child.stderr.on("data", (d) => {
+      stderr += d.toString();
+      if (stderr.length > 50_000) { child.kill("SIGTERM"); }
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      const output = (stdout + "\n" + stderr).trim();
+      if (timedOut) {
+        resolve({ ok: true, output, code: null, timedOut: true });
+      } else {
+        resolve({ ok: code === 0, output, code, timedOut: false });
+      }
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      resolve({ ok: false, output: err.message, code: null, timedOut: false });
+    });
+  });
+}
+
 /**
  * Per-turn skill injection. Selects skills against the latest user message
  * + paths the model has touched, then prepends matching bodies onto the

package/src/api.js

@@ -14,7 +14,7 @@ const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
  * string, so resending is safe. For the streaming endpoint only the initial
  * connection is retried.
  */
-export async function fetchWithRetry(url, options, { retries = 2, baseDelay = 500, onRetry } = {}) {
+export async function fetchWithRetry(url, options, { retries = 4, baseDelay = 1000, onRetry } = {}) {
   let attempt = 0;
   while (true) {
     try {
@@ -202,7 +202,7 @@ export async function agentTurnStream({
 
   // 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 READ_TIMEOUT_MS = 180_000;
   const readOnce = () => {
     let timer;
     const timeout = new Promise((_, reject) => {

package/src/project-context.js

@@ -535,6 +535,162 @@ export function detectVerifyCommand(cwd) {
   return null;
 }
 
+// ─────────── Auto-build: detect compilation / build commands ───────────
+
+export function detectBuildCommand(cwd, writtenFiles = []) {
+  const exts = new Set(writtenFiles.map((f) => path.extname(f).toLowerCase()));
+  const basenames = new Set(writtenFiles.map((f) => path.basename(f).toLowerCase()));
+  const win = process.platform === "win32";
+
+  // Assembly (NASM/FASM/MASM)
+  if (exts.has(".asm") || exts.has(".s")) {
+    const asmFiles = writtenFiles.filter((f) => /\.(asm|s)$/i.test(f));
+    if (asmFiles.length > 0) {
+      const outName = win ? "output.exe" : "output";
+      const objName = asmFiles[0].replace(/\.(asm|s)$/i, ".o");
+      return {
+        cmd: `nasm -f ${win ? "win64" : "elf64"} ${asmFiles[0]} -o ${objName} && ${win ? "link" : "ld"} ${objName} -o ${outName}`,
+        label: "nasm",
+        type: "compiled",
+        runCmd: win ? `.\\${outName}` : `./${outName}`,
+      };
+    }
+  }
+
+  // C/C++
+  if (exts.has(".c") || exts.has(".cpp") || exts.has(".cc") || exts.has(".cxx") || exts.has(".h") || exts.has(".hpp")) {
+    if (fs.existsSync(path.join(cwd, "CMakeLists.txt"))) {
+      return { cmd: "cmake -B build && cmake --build build", label: "cmake", type: "compiled" };
+    }
+    if (fs.existsSync(path.join(cwd, "Makefile")) || fs.existsSync(path.join(cwd, "makefile"))) {
+      return { cmd: "make", label: "make", type: "compiled" };
+    }
+    const cFiles = writtenFiles.filter((f) => /\.(c|cpp|cc|cxx)$/i.test(f));
+    if (cFiles.length > 0) {
+      const hasC = cFiles.some((f) => /\.c$/i.test(f) && !/\.(cpp|cc|cxx)$/i.test(f));
+      const hasCpp = cFiles.some((f) => /\.(cpp|cc|cxx)$/i.test(f));
+      const compiler = hasCpp ? "g++" : "gcc";
+      const outName = win ? "output.exe" : "output";
+      const flags = [];
+      if (hasCpp) flags.push("-std=c++17");
+      else if (hasC) flags.push("-std=c11");
+      flags.push("-Wall", "-O2");
+      // Check if they need threading, math, etc. from the source
+      const allSrc = cFiles.map((f) => {
+        try { return fs.readFileSync(path.join(cwd, f), "utf8"); } catch { return ""; }
+      }).join("\n");
+      if (allSrc.includes("pthread") || allSrc.includes("<thread>")) flags.push("-pthread");
+      if (allSrc.includes("<math.h>") || allSrc.includes("<cmath>")) flags.push("-lm");
+      if (win && (allSrc.includes("winsock") || allSrc.includes("WinSock") || allSrc.includes("ws2_32"))) flags.push("-lws2_32");
+      if (win && allSrc.includes("windows.h")) flags.push("-lkernel32", "-luser32");
+      return {
+        cmd: `${compiler} ${flags.join(" ")} ${cFiles.join(" ")} -o ${outName}`,
+        label: compiler,
+        type: "compiled",
+        runCmd: win ? `.\\${outName}` : `./${outName}`,
+      };
+    }
+  }
+
+  // Rust
+  if (exts.has(".rs") || fs.existsSync(path.join(cwd, "Cargo.toml"))) {
+    if (fs.existsSync(path.join(cwd, "Cargo.toml"))) {
+      return { cmd: "cargo build --release", label: "cargo", type: "compiled" };
+    }
+    const rsFiles = writtenFiles.filter((f) => /\.rs$/i.test(f));
+    if (rsFiles.length === 1) {
+      const outName = win ? "output.exe" : "output";
+      return { cmd: `rustc -o ${outName} ${rsFiles[0]}`, label: "rustc", type: "compiled", runCmd: win ? `.\\${outName}` : `./${outName}` };
+    }
+  }
+
+  // Go
+  if (exts.has(".go") || fs.existsSync(path.join(cwd, "go.mod"))) {
+    const outName = win ? "output.exe" : "output";
+    return { cmd: `go build -o ${outName} ./...`, label: "go build", type: "compiled", runCmd: win ? `.\\${outName}` : `./${outName}` };
+  }
+
+  // C# / .NET
+  if (exts.has(".cs")) {
+    const csproj = writtenFiles.find((f) => f.endsWith(".csproj"));
+    if (csproj || fs.existsSync(path.join(cwd, "*.csproj"))) {
+      return { cmd: "dotnet build", label: "dotnet", type: "compiled" };
+    }
+    const csFiles = writtenFiles.filter((f) => /\.cs$/i.test(f));
+    if (csFiles.length > 0) {
+      const outName = win ? "output.exe" : "output";
+      return { cmd: `dotnet-script ${csFiles[0]}`, label: "dotnet-script", type: "interpreted", runCmd: `dotnet-script ${csFiles[0]}` };
+    }
+  }
+
+  // Java
+  if (exts.has(".java")) {
+    const javaFiles = writtenFiles.filter((f) => /\.java$/i.test(f));
+    if (javaFiles.length > 0) {
+      // Find the file with main()
+      let mainClass = null;
+      for (const jf of javaFiles) {
+        try {
+          const src = fs.readFileSync(path.join(cwd, jf), "utf8");
+          if (src.includes("public static void main")) {
+            mainClass = path.basename(jf, ".java");
+            break;
+          }
+        } catch { /* skip */ }
+      }
+      return {
+        cmd: `javac ${javaFiles.join(" ")}`,
+        label: "javac",
+        type: "compiled",
+        runCmd: mainClass ? `java ${mainClass}` : null,
+      };
+    }
+  }
+
+  // Node/TypeScript — npm build script
+  if (fs.existsSync(path.join(cwd, "package.json"))) {
+    const pkg = readJsonSafe(path.join(cwd, "package.json"));
+    if (pkg?.scripts?.build) {
+      const startCmd = pkg.scripts.start ? "npm start" : null;
+      return { cmd: "npm install && npm run build", label: "npm build", type: "compiled", runCmd: startCmd };
+    }
+    if (pkg?.scripts?.start) {
+      return { cmd: "npm install", label: "npm install", type: "interpreted", runCmd: "npm start" };
+    }
+  }
+
+  // Python
+  if (exts.has(".py")) {
+    // Check for requirements.txt first
+    const hasReqs = fs.existsSync(path.join(cwd, "requirements.txt"));
+    const installCmd = hasReqs ? "pip install -r requirements.txt && " : "";
+    // Priority: main.py > __main__.py > app.py > single file
+    const pyFiles = writtenFiles.filter((f) => /\.py$/i.test(f));
+    const mainCandidates = ["main.py", "__main__.py", "app.py", "run.py"];
+    let entrypoint = null;
+    for (const mc of mainCandidates) {
+      const match = pyFiles.find((f) => path.basename(f).toLowerCase() === mc);
+      if (match) { entrypoint = match; break; }
+    }
+    if (!entrypoint && pyFiles.length === 1) entrypoint = pyFiles[0];
+    if (entrypoint) {
+      return {
+        cmd: installCmd ? installCmd.slice(0, -4) : `python ${entrypoint}`,
+        label: hasReqs ? "pip install" : "python",
+        type: "interpreted",
+        runCmd: `python ${entrypoint}`,
+      };
+    }
+  }
+
+  // Makefile fallback (no source files matched above but a Makefile exists)
+  if (fs.existsSync(path.join(cwd, "Makefile")) || fs.existsSync(path.join(cwd, "makefile"))) {
+    return { cmd: "make", label: "make", type: "compiled" };
+  }
+
+  return null;
+}
+
 export function scanProjectQuick(cwd) {
   const { dirs, files } = listTopLevel(cwd);
   const total = dirs.length + files.length;