aether-code 0.38.0 → 0.40.0

package/package.json

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

@@ -4,11 +4,12 @@
 
 import os from "node:os";
 import path from "node:path";
+import { spawn } from "node:child_process";
 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 } 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;
@@ -109,6 +110,8 @@ export async function runAgent({
   // finishes having read files it never edited, we nudge it once to finish.
   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
@@ -218,6 +221,88 @@ 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.
+      if (filesTouched.size > 0 && verifyRounds < 2) {
+        const verifyResult = await runVerify(cwd);
+        if (verifyResult && !verifyResult.ok) {
+          verifyRounds++;
+          console.log("\n" + c.yellow("●") + " " + c.bold("auto-verify") + c.gray(` (${verifyResult.label})`));
+          console.log(c.red("  └─") + " " + c.gray("errors found — feeding back to fix"));
+          const errPreview = verifyResult.output.length > 4000
+            ? verifyResult.output.slice(0, 4000) + "\n…(truncated)"
+            : verifyResult.output;
+          messages.push({
+            role: "user",
+            content:
+              `AUTO-VERIFY FAILED (${verifyResult.label}):\n\`\`\`\n${errPreview}\n\`\`\`\n` +
+              `Fix these errors NOW using edit_file. Do not explain — just fix and move on.`,
+          });
+          continue;
+        }
+        if (verifyResult && verifyResult.ok) {
+          console.log("\n" + c.green("●") + " " + c.bold("auto-verify") + c.gray(` (${verifyResult.label}) — passed`));
+        }
+      }
       if (filesTouched.size) {
         console.log("\n" + c.bold("Files") + c.gray(` in ${cwd}`));
         for (const [p, action] of filesTouched) {
@@ -298,6 +383,102 @@ export async function runAgent({
   return { ok: false, error: new Error("Max turns reached"), totalCredits, totalIn, totalOut, balance: lastBalance, messages };
 }
 
+// Auto-verify: run the project's typecheck/lint command silently and return
+// { ok, output, label }. Returns null if no verify command is detected.
+let cachedVerify = undefined;
+async function runVerify(cwd) {
+  if (cachedVerify === undefined) cachedVerify = detectVerifyCommand(cwd);
+  if (!cachedVerify) return null;
+  const { cmd, label } = cachedVerify;
+  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"); }, 60_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 });
+    });
+    child.on("error", () => {
+      clearTimeout(timer);
+      resolve(null);
+    });
+  });
+}
+
+// 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/project-context.js

@@ -263,6 +263,434 @@ export function scanProject(cwd) {
   return lines.join("\n") + "\n";
 }
 
+// ─────────── /init — deep project indexing ───────────
+
+const KEY_FILES = [
+  "README.md", "CLAUDE.md", ".env.example", "Dockerfile",
+  "docker-compose.yml", "docker-compose.yaml",
+];
+
+const ENTRY_PATTERNS = [
+  /^(src\/)?index\.[jt]sx?$/,
+  /^(src\/)?main\.[jt]sx?$/,
+  /^(src\/)?app\.[jt]sx?$/,
+  /^(src\/)?server\.[jt]sx?$/,
+  /^(bin|cli|cmd)\/[^/]+\.[jt]sx?$/,
+  /^(pages|app)\/_app\.[jt]sx?$/,
+  /^(pages|app)\/layout\.[jt]sx?$/,
+];
+
+const CONFIG_FILES = [
+  "next.config.js", "next.config.mjs", "next.config.ts",
+  "vite.config.ts", "vite.config.js", "webpack.config.js",
+  "tsconfig.json", "tailwind.config.js", "tailwind.config.ts",
+  "eslint.config.js", ".eslintrc.js", ".eslintrc.json",
+  "jest.config.js", "jest.config.ts", "vitest.config.ts",
+  "prisma/schema.prisma", "drizzle.config.ts",
+];
+
+function collectSourceFiles(dir, base, maxFiles = 500) {
+  const results = [];
+  function walk(current, rel) {
+    if (results.length >= maxFiles) return;
+    let entries;
+    try { entries = fs.readdirSync(current, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      if (results.length >= maxFiles) return;
+      if (e.name.startsWith(".") && e.name !== ".env.example") continue;
+      if (SKIP_DIRS.has(e.name)) continue;
+      const fullPath = path.join(current, e.name);
+      const relPath = rel ? `${rel}/${e.name}` : e.name;
+      if (e.isDirectory()) {
+        walk(fullPath, relPath);
+      } else if (e.isFile()) {
+        let size = 0;
+        try { size = fs.statSync(fullPath).size; } catch { /* skip */ }
+        results.push({ path: relPath, size });
+      }
+    }
+  }
+  walk(dir, "");
+  return results;
+}
+
+function identifyKeyFiles(allFiles, cwd) {
+  const key = [];
+  for (const f of allFiles) {
+    const name = f.path.split("/").pop();
+    if (KEY_FILES.includes(name)) { key.push(f.path); continue; }
+    if (CONFIG_FILES.includes(f.path)) { key.push(f.path); continue; }
+    for (const pat of ENTRY_PATTERNS) {
+      if (pat.test(f.path)) { key.push(f.path); break; }
+    }
+  }
+  return key;
+}
+
+function summarizeFile(filePath, maxLines = 30) {
+  try {
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile() || stat.size > 200_000) return null;
+    const content = fs.readFileSync(filePath, "utf8");
+    const lines = content.split("\n");
+    const exports = [];
+    const imports = [];
+    for (const line of lines.slice(0, 100)) {
+      if (/^export\s+(default\s+)?(function|class|const|let|async)\s+(\w+)/m.test(line)) {
+        const match = line.match(/^export\s+(?:default\s+)?(?:function|class|const|let|async\s+function)\s+(\w+)/);
+        if (match) exports.push(match[1]);
+      }
+      if (/^import\s/.test(line)) {
+        const match = line.match(/from\s+["']([^"']+)["']/);
+        if (match && !match[1].startsWith(".")) imports.push(match[1]);
+      }
+    }
+    const summary = { lines: lines.length };
+    if (exports.length > 0) summary.exports = exports.slice(0, 15);
+    if (imports.length > 0) summary.externalImports = [...new Set(imports)].slice(0, 10);
+    const firstComment = content.match(/^\/\/\s*(.+)/m);
+    if (firstComment) summary.description = firstComment[1].trim().slice(0, 120);
+    return summary;
+  } catch {
+    return null;
+  }
+}
+
+function detectConventions(allFiles, cwd) {
+  const conventions = [];
+  const extensions = new Set();
+  for (const f of allFiles) {
+    const ext = path.extname(f.path);
+    if (ext) extensions.add(ext);
+  }
+  if (extensions.has(".ts") || extensions.has(".tsx")) conventions.push("TypeScript");
+  if (extensions.has(".jsx") || extensions.has(".tsx")) conventions.push("JSX/TSX (React-style)");
+  const hasTest = allFiles.some((f) =>
+    /\.(test|spec)\.[jt]sx?$/.test(f.path) || f.path.startsWith("test/") || f.path.startsWith("__tests__/"),
+  );
+  if (hasTest) {
+    const testDirs = [];
+    if (allFiles.some((f) => f.path.startsWith("test/"))) testDirs.push("test/");
+    if (allFiles.some((f) => f.path.startsWith("__tests__/"))) testDirs.push("__tests__/");
+    const colocated = allFiles.some((f) => /src\/.*\.(test|spec)\.[jt]sx?$/.test(f.path));
+    if (colocated) testDirs.push("colocated in src/");
+    conventions.push(`Tests: ${testDirs.join(", ") || "detected"}`);
+  }
+  if (fs.existsSync(path.join(cwd, ".prettierrc")) || fs.existsSync(path.join(cwd, ".prettierrc.json"))) {
+    conventions.push("Prettier formatting");
+  }
+  if (fs.existsSync(path.join(cwd, ".eslintrc.js")) || fs.existsSync(path.join(cwd, "eslint.config.js"))) {
+    conventions.push("ESLint");
+  }
+  return conventions;
+}
+
+function buildDirectoryTree(allFiles, maxDepth = 3) {
+  const tree = {};
+  for (const f of allFiles) {
+    const parts = f.path.split("/");
+    let node = tree;
+    for (let i = 0; i < Math.min(parts.length - 1, maxDepth); i++) {
+      if (!node[parts[i]]) node[parts[i]] = {};
+      node = node[parts[i]];
+    }
+  }
+  function render(node, indent = "") {
+    const lines = [];
+    const entries = Object.keys(node).sort();
+    for (const key of entries) {
+      const children = Object.keys(node[key]);
+      lines.push(`${indent}${key}/`);
+      if (children.length > 0 && indent.length < maxDepth * 2) {
+        lines.push(...render(node[key], indent + "  "));
+      }
+    }
+    return lines;
+  }
+  return render(tree);
+}
+
+export function generateProjectIndex(cwd) {
+  const lines = [];
+  lines.push("# Project Context");
+  lines.push(`# Auto-generated by \`aether /init\` — edit freely, this file is yours.`);
+  lines.push(`# Loaded on every agent turn to give the model deep project understanding.`);
+  lines.push("");
+
+  const { dirs, files: topFiles } = listTopLevel(cwd);
+  const frameworks = detectFrameworks(cwd, topFiles);
+  const pkg = extractPackageInfo(cwd);
+  const cargo = extractCargoInfo(cwd);
+  const goInfo = extractGoInfo(cwd);
+  const pyInfo = extractPythonInfo(cwd);
+
+  lines.push("## Overview");
+  if (pkg?.name) lines.push(`- **Package:** ${pkg.name}${pkg.version ? ` v${pkg.version}` : ""}`);
+  if (cargo?.name) lines.push(`- **Crate:** ${cargo.name}${cargo.version ? ` v${cargo.version}` : ""}`);
+  if (goInfo?.module) lines.push(`- **Module:** ${goInfo.module}${goInfo.goVersion ? ` (go ${goInfo.goVersion})` : ""}`);
+  if (pyInfo?.name) lines.push(`- **Python:** ${pyInfo.name || pyInfo.type}`);
+  if (frameworks.length > 0) lines.push(`- **Stack:** ${frameworks.join(", ")}`);
+  if (pkg?.frameworks?.length) lines.push(`- **Libraries:** ${pkg.frameworks.join(", ")}`);
+  if (pkg?.depCounts) lines.push(`- **Dependencies:** ${pkg.depCounts}`);
+  lines.push("");
+
+  const allFiles = collectSourceFiles(cwd);
+  const conventions = detectConventions(allFiles, cwd);
+  if (conventions.length > 0) {
+    lines.push("## Conventions");
+    for (const c of conventions) lines.push(`- ${c}`);
+    lines.push("");
+  }
+
+  if (pkg?.scripts?.length) {
+    lines.push("## Scripts");
+    const pkgFull = readJsonSafe(path.join(cwd, "package.json"));
+    if (pkgFull?.scripts) {
+      for (const [name, cmd] of Object.entries(pkgFull.scripts)) {
+        lines.push(`- \`npm run ${name}\` → \`${cmd}\``);
+      }
+    }
+    lines.push("");
+  }
+
+  lines.push("## Structure");
+  const tree = buildDirectoryTree(allFiles);
+  for (const t of tree.slice(0, 60)) lines.push(t);
+  if (tree.length > 60) lines.push(`... (${tree.length - 60} more directories)`);
+  lines.push("");
+
+  const keyFiles = identifyKeyFiles(allFiles, cwd);
+  if (keyFiles.length > 0) {
+    lines.push("## Key Files");
+    for (const kf of keyFiles.slice(0, 25)) {
+      const abs = path.join(cwd, kf.replace(/\//g, path.sep));
+      const summary = summarizeFile(abs);
+      if (summary) {
+        const desc = summary.description ? ` — ${summary.description}` : "";
+        const exports = summary.exports?.length ? ` (exports: ${summary.exports.join(", ")})` : "";
+        lines.push(`- \`${kf}\` [${summary.lines} lines]${desc}${exports}`);
+      } else {
+        lines.push(`- \`${kf}\``);
+      }
+    }
+    lines.push("");
+  }
+
+  const sourceByDir = {};
+  for (const f of allFiles) {
+    const dir = f.path.includes("/") ? f.path.split("/").slice(0, -1).join("/") : ".";
+    if (!sourceByDir[dir]) sourceByDir[dir] = [];
+    sourceByDir[dir].push(f);
+  }
+  const topDirs = Object.entries(sourceByDir)
+    .sort((a, b) => b[1].length - a[1].length)
+    .slice(0, 10);
+  if (topDirs.length > 0) {
+    lines.push("## Module Map");
+    for (const [dir, dirFiles] of topDirs) {
+      const exts = {};
+      for (const f of dirFiles) {
+        const ext = path.extname(f.path) || "(no ext)";
+        exts[ext] = (exts[ext] || 0) + 1;
+      }
+      const extStr = Object.entries(exts).map(([e, c]) => `${c}${e}`).join(", ");
+      lines.push(`- \`${dir}/\` — ${dirFiles.length} files (${extStr})`);
+    }
+    lines.push("");
+  }
+
+  lines.push("## Notes");
+  lines.push("<!-- Add project-specific instructions, patterns, or gotchas below. -->");
+  lines.push("<!-- The agent reads this file on every turn. -->");
+  lines.push("");
+
+  return lines.join("\n");
+}
+
+// ─────────── Auto-verify: detect project check commands ───────────
+
+export function detectVerifyCommand(cwd) {
+  const pkg = readJsonSafe(path.join(cwd, "package.json"));
+  if (pkg?.scripts) {
+    if (pkg.scripts.typecheck) return { cmd: "npm run typecheck", label: "typecheck" };
+    if (pkg.scripts["type-check"]) return { cmd: "npm run type-check", label: "typecheck" };
+  }
+  if (fs.existsSync(path.join(cwd, "tsconfig.json"))) {
+    const hasTsc = pkg?.devDependencies?.typescript || pkg?.dependencies?.typescript;
+    if (hasTsc) return { cmd: "npx tsc --noEmit", label: "typecheck" };
+  }
+  if (pkg?.scripts) {
+    if (pkg.scripts.lint) return { cmd: "npm run lint", label: "lint" };
+    if (pkg.scripts.check) return { cmd: "npm run check", label: "check" };
+  }
+  const cargo = readTextSafe(path.join(cwd, "Cargo.toml"), 500);
+  if (cargo) return { cmd: "cargo check", label: "cargo check" };
+  const goMod = readTextSafe(path.join(cwd, "go.mod"), 500);
+  if (goMod) return { cmd: "go vet ./...", label: "go vet" };
+  if (fs.existsSync(path.join(cwd, "pyproject.toml"))) {
+    if (pkg?.scripts?.mypy || fs.existsSync(path.join(cwd, "mypy.ini"))) {
+      return { cmd: "mypy .", label: "mypy" };
+    }
+  }
+  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;

package/src/repl.js

@@ -8,6 +8,7 @@
 //   - Bottom status line is rendered after each turn
 //   - Ctrl+C: first press cancels in-progress turn, second press exits
 
+import fs from "node:fs";
 import path from "node:path";
 import { runAgent } from "./agent.js";
 import { fetchBalance, AetherError } from "./api.js";
@@ -20,7 +21,7 @@ import {
   generateSessionId, saveSession, loadSession, listSessions,
   findRecentSession, deleteSession, extractSummary, formatAge,
 } from "./sessions.js";
-import { scanProjectQuick } from "./project-context.js";
+import { scanProjectQuick, generateProjectIndex } from "./project-context.js";
 
 const VERSION = getVersion();
 const MODEL_NAME = "Aether Core";
@@ -44,6 +45,7 @@ const SHORTCUTS = `
   ${c.cyan("/yes")}       Toggle auto-approve mode (skip y/N prompts)
   ${c.cyan("/turns")} ${c.gray("<n>")}     Set max turns per prompt (default 25)
   ${c.cyan("/model")} ${c.gray("[core|ultra]")}  Show or switch model (ultra=Opus — premium)
+  ${c.cyan("/init")}      Deep-scan project → generate .aether/context.md
   ${c.cyan("/sessions")}  List saved sessions for this directory
   ${c.cyan("/resume")} ${c.gray("[id]")}   Resume a saved session (default: most recent)
   ${c.cyan("/new")}       Start a fresh session (save current first)
@@ -286,6 +288,31 @@ async function handleSlash(line, state) {
       }
       break;
     }
+    case "init": {
+      console.log(c.gray("Scanning project..."));
+      try {
+        const content = generateProjectIndex(state.cwd);
+        const dir = path.join(state.cwd, ".aether");
+        fs.mkdirSync(dir, { recursive: true });
+        const filePath = path.join(dir, "context.md");
+        fs.writeFileSync(filePath, content, "utf8");
+        const lineCount = content.split("\n").length;
+        console.log(c.green("●") + " " + c.bold(`.aether/context.md`) + c.gray(` generated (${lineCount} lines)`));
+        console.log(c.gray("  The agent now reads this on every turn. Edit it freely to add project-specific notes."));
+        // Add to .gitignore if not already there
+        const gitignorePath = path.join(state.cwd, ".gitignore");
+        try {
+          const existing = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, "utf8") : "";
+          if (!existing.includes(".aether/")) {
+            fs.appendFileSync(gitignorePath, `\n# Aether agent context\n.aether/\n`, "utf8");
+            console.log(c.gray("  Added .aether/ to .gitignore"));
+          }
+        } catch { /* non-fatal */ }
+      } catch (err) {
+        console.log(errorLine(`/init failed: ${err.message}`));
+      }
+      break;
+    }
     case "sessions": {
       const sessions = listSessions(state.cwd);
       if (sessions.length === 0) {