aether-code 0.36.8 → 0.38.0

package/bin/aether-code.js

@@ -27,8 +27,9 @@ import {
 } from "../src/mcp-registry.js";
 import readline from "node:readline";
 import { c, errorLine, divider, setTerminalTitle } from "../src/render.js";
+import { getVersion } from "../src/version.js";
 
-const VERSION = "0.32.0";
+const VERSION = getVersion();
 
 /**
  * Try to start MCP servers from ~/.aether/mcp.json. Returns a started
@@ -315,13 +316,10 @@ async function handleBalance() {
     const me = await fetchBalance();
     console.log(c.bold(c.magenta("Aether")));
     console.log(c.gray("─".repeat(50)));
-    console.log(`Plan      ${c.cyan(me.plan)}${me.role !== "USER" ? c.gray(` · ${me.role}`) : ""}`);
+    console.log(`Plan      ${c.cyan(me.plan)}`);
     console.log(`Balance   ${c.bold(me.balance.toLocaleString())} credits`);
     console.log(`  plan    ${me.planCredits.toLocaleString()}`);
     console.log(`  topup   ${me.topupCredits.toLocaleString()}`);
-    if (me.rate) {
-      console.log(`Rate      ${me.rate.used}/${me.rate.limit} this hour${me.rate.resetIn ? ` · resets in ${me.rate.resetIn}s` : ""}`);
-    }
     if (me.isSuspended) console.log(c.red("\n⚠ Account is suspended."));
   } catch (err) {
     if (err instanceof AetherError && err.code === "NO_API_KEY") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aether-code",
-  "version": "0.36.8",
+  "version": "0.38.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": {
@@ -23,7 +23,7 @@
     "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",
+    "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"
   },

package/src/agent.js

@@ -8,27 +8,31 @@ 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 { c, divider, turn, toolLabel, toolSummary, makeTokenStripper, errorLine, startSpinner } from "./render.js";
 
 const DEFAULT_MAX_TURNS = 25;
 
-// Environment block prepended to the first user message so the model can
-// resolve named locations to real absolute paths.
-function envContext(cwd) {
+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;
+
+export function envContext(cwd) {
   const home = os.homedir();
   const desktop = path.join(home, "Desktop");
   const documents = path.join(home, "Documents");
   const win = process.platform === "win32";
-  // OS-specific shell guidance: gemma tends to emit Unix commands (mkdir -p,
-  // touch, &&-chains) which FAIL in Windows cmd.exe ("The syntax of the command
-  // is incorrect"). Steer it to the file tools (which are cross-platform and
-  // auto-create parent dirs) and OS-appropriate shell usage.
   const shellNote = win
     ? `shell: Windows cmd.exe. To create files OR directories, use the write_file tool — ` +
       `it creates any missing parent folders automatically. Do NOT use shell "mkdir -p", ` +
       `"touch", "ls", "rm", "cp", "mv", or "&&"-chained Unix commands; they FAIL in cmd.exe. ` +
       `Run programs/tests with their interpreter (python, node, java, etc.).`
     : `shell: POSIX sh. Standard Unix commands are available. write_file still auto-creates parent dirs.`;
+
+  let projectBlock = "";
+  try {
+    projectBlock = scanProject(cwd);
+  } catch { /* non-fatal */ }
+
   return (
     `[environment]\n` +
     `os: ${process.platform}\n` +
@@ -40,7 +44,8 @@ function envContext(cwd) {
     `When the user names a location ("my desktop", "home", "documents"), write to ` +
     `the matching ABSOLUTE path above (e.g. desktop -> ${desktop}). Otherwise ` +
     `work under the cwd. Use absolute paths when a specific location is named.\n` +
-    `[/environment]\n\n`
+    `[/environment]\n\n` +
+    (projectBlock ? projectBlock + "\n" : "")
   );
 }
 
@@ -102,8 +107,6 @@ export async function runAgent({
   // 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;
 
@@ -309,7 +312,7 @@ export async function runAgent({
  * worse than no skills at all. Prepending into the user message keeps
  * both layers active.
  */
-function buildTurnMessages(messages, allSkills, referencedPaths) {
+export function buildTurnMessages(messages, allSkills, referencedPaths) {
   if (allSkills.length === 0) return messages;
   // Find the latest user message — that's where the current task lives.
   let lastUserIdx = -1;

package/src/api.js

@@ -1,22 +1,9 @@
 // API client.
 
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { getConfig } from "./config.js";
+import { getVersion } from "./version.js";
 
-// Resolve our own version once for the User-Agent header — read from
-// package.json so it can't drift (the file previously sent three different
-// hardcoded versions across three calls).
-function readVersion() {
-  try {
-    const pkgPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "package.json");
-    return JSON.parse(fs.readFileSync(pkgPath, "utf8")).version || "0";
-  } catch {
-    return "0";
-  }
-}
-const USER_AGENT = `aether-code/${readVersion()}`;
+const USER_AGENT = `aether-code/${getVersion()}`;
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
@@ -93,7 +80,7 @@ export async function fetchBalance(apiKeyOverride) {
     const msg = data?.error || `${res.status} ${res.statusText}`;
     throw new AetherError(msg, code, res.status, data);
   }
-  return data; // { plan, role, planCredits, topupCredits, balance, isSuspended, rate }
+  return data; // { plan, planCredits, topupCredits, balance, isSuspended }
 }
 
 export class AetherError extends Error {

package/src/mcp.js

@@ -31,6 +31,7 @@ import os from "node:os";
 import path from "node:path";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { getVersion } from "./version.js";
 
 const DEFAULT_CONFIG_PATH = path.join(os.homedir(), ".aether", "mcp.json");
 const NAMESPACE_SEP = "__";
@@ -163,7 +164,7 @@ export class MCPManager {
       env: { ...process.env, ...(cfg.env ?? {}) },
     });
     const client = new Client(
-      { name: "aether-code", version: "0.9.0" },
+      { name: "aether-code", version: getVersion() },
       { capabilities: {} },
     );
     // Bound the init handshake so a hung server doesn't stall startup.

package/src/project-context.js

@@ -0,0 +1,279 @@
+// Project context scanner. Reads the cwd on startup to give the model
+// immediate understanding of what project it's working in — tech stack,
+// file structure, available scripts, dependencies, and any project-specific
+// instructions. This is the single biggest quality-of-life improvement for
+// a weaker model: instead of guessing, it KNOWS.
+
+import fs from "node:fs";
+import path from "node:path";
+
+const SKIP_DIRS = new Set([
+  "node_modules", ".git", ".next", "dist", "build", "__pycache__",
+  ".venv", "venv", "env", ".env", ".idea", ".vscode", "coverage",
+  ".cache", ".turbo", "target", "out", ".output", ".nuxt", ".svelte-kit",
+  "vendor", "bower_components", ".parcel-cache", ".webpack",
+]);
+
+const FRAMEWORK_SIGNATURES = {
+  "next.config.js": "Next.js",
+  "next.config.mjs": "Next.js",
+  "next.config.ts": "Next.js",
+  "nuxt.config.ts": "Nuxt",
+  "svelte.config.js": "SvelteKit",
+  "astro.config.mjs": "Astro",
+  "remix.config.js": "Remix",
+  "angular.json": "Angular",
+  "vue.config.js": "Vue CLI",
+  "vite.config.ts": "Vite",
+  "vite.config.js": "Vite",
+  "webpack.config.js": "Webpack",
+  "tsconfig.json": "TypeScript",
+  "Cargo.toml": "Rust (Cargo)",
+  "go.mod": "Go",
+  "pyproject.toml": "Python",
+  "setup.py": "Python (setuptools)",
+  "requirements.txt": "Python",
+  "Gemfile": "Ruby (Bundler)",
+  "pom.xml": "Java (Maven)",
+  "build.gradle": "Java/Kotlin (Gradle)",
+  "CMakeLists.txt": "C/C++ (CMake)",
+  "Makefile": "Make",
+  "Dockerfile": "Docker",
+  "docker-compose.yml": "Docker Compose",
+  "docker-compose.yaml": "Docker Compose",
+  ".env": "dotenv config",
+  "prisma/schema.prisma": "Prisma ORM",
+  "drizzle.config.ts": "Drizzle ORM",
+};
+
+const DEP_FRAMEWORKS = {
+  next: "Next.js",
+  react: "React",
+  vue: "Vue",
+  svelte: "Svelte",
+  angular: "Angular",
+  express: "Express",
+  fastify: "Fastify",
+  koa: "Koa",
+  hono: "Hono",
+  "socket.io": "Socket.IO",
+  prisma: "Prisma",
+  drizzle: "Drizzle",
+  mongoose: "Mongoose",
+  sequelize: "Sequelize",
+  tailwindcss: "Tailwind CSS",
+  "styled-components": "styled-components",
+  electron: "Electron",
+  jest: "Jest",
+  vitest: "Vitest",
+  mocha: "Mocha",
+  playwright: "Playwright",
+  cypress: "Cypress",
+};
+
+function readJsonSafe(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function readTextSafe(filePath, maxBytes = 2000) {
+  try {
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile() || stat.size > 500_000) return null;
+    const buf = Buffer.alloc(Math.min(stat.size, maxBytes));
+    const fd = fs.openSync(filePath, "r");
+    const bytesRead = fs.readSync(fd, buf, 0, buf.length, 0);
+    fs.closeSync(fd);
+    return buf.toString("utf8", 0, bytesRead);
+  } catch {
+    return null;
+  }
+}
+
+function listTopLevel(cwd) {
+  let entries;
+  try {
+    entries = fs.readdirSync(cwd, { withFileTypes: true });
+  } catch {
+    return { dirs: [], files: [] };
+  }
+  const dirs = [];
+  const files = [];
+  for (const e of entries) {
+    if (e.name.startsWith(".") && e.name !== ".env" && e.name !== ".gitignore") continue;
+    if (SKIP_DIRS.has(e.name)) continue;
+    if (e.isDirectory()) {
+      dirs.push(e.name + "/");
+    } else if (e.isFile()) {
+      files.push(e.name);
+    }
+  }
+  dirs.sort();
+  files.sort();
+  return { dirs, files };
+}
+
+function listSecondLevel(cwd, dirName) {
+  const full = path.join(cwd, dirName);
+  let entries;
+  try {
+    entries = fs.readdirSync(full, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const items = [];
+  for (const e of entries) {
+    if (e.name.startsWith(".")) continue;
+    if (SKIP_DIRS.has(e.name)) continue;
+    items.push(e.isDirectory() ? e.name + "/" : e.name);
+  }
+  items.sort();
+  return items.slice(0, 30);
+}
+
+function detectFrameworks(cwd, topFiles) {
+  const found = new Set();
+  for (const file of topFiles) {
+    if (FRAMEWORK_SIGNATURES[file]) found.add(FRAMEWORK_SIGNATURES[file]);
+  }
+  if (fs.existsSync(path.join(cwd, "prisma", "schema.prisma"))) {
+    found.add("Prisma ORM");
+  }
+  return [...found];
+}
+
+function extractPackageInfo(cwd) {
+  const pkg = readJsonSafe(path.join(cwd, "package.json"));
+  if (!pkg) return null;
+  const info = { name: pkg.name, version: pkg.version };
+  if (pkg.scripts && Object.keys(pkg.scripts).length > 0) {
+    info.scripts = Object.keys(pkg.scripts);
+  }
+  const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const detectedLibs = [];
+  for (const [dep, label] of Object.entries(DEP_FRAMEWORKS)) {
+    if (allDeps[dep]) detectedLibs.push(label);
+  }
+  if (detectedLibs.length > 0) info.frameworks = detectedLibs;
+  const depCount = Object.keys(pkg.dependencies || {}).length;
+  const devCount = Object.keys(pkg.devDependencies || {}).length;
+  if (depCount || devCount) {
+    info.depCounts = `${depCount} deps, ${devCount} devDeps`;
+  }
+  return info;
+}
+
+function extractCargoInfo(cwd) {
+  const raw = readTextSafe(path.join(cwd, "Cargo.toml"), 1500);
+  if (!raw) return null;
+  const name = raw.match(/^name\s*=\s*"(.+?)"/m)?.[1];
+  const version = raw.match(/^version\s*=\s*"(.+?)"/m)?.[1];
+  return { name, version, type: "Rust" };
+}
+
+function extractGoInfo(cwd) {
+  const raw = readTextSafe(path.join(cwd, "go.mod"), 500);
+  if (!raw) return null;
+  const mod = raw.match(/^module\s+(\S+)/m)?.[1];
+  const goVer = raw.match(/^go\s+(\S+)/m)?.[1];
+  return { module: mod, goVersion: goVer, type: "Go" };
+}
+
+function extractPythonInfo(cwd) {
+  const pyproject = readTextSafe(path.join(cwd, "pyproject.toml"), 1500);
+  if (pyproject) {
+    const name = pyproject.match(/^name\s*=\s*"(.+?)"/m)?.[1];
+    return { name, type: "Python" };
+  }
+  if (fs.existsSync(path.join(cwd, "requirements.txt"))) {
+    return { type: "Python (requirements.txt)" };
+  }
+  return null;
+}
+
+export function scanProject(cwd) {
+  const { dirs, files } = listTopLevel(cwd);
+  if (dirs.length === 0 && files.length === 0) {
+    return "[project]\nEmpty directory — no files detected.\n[/project]\n";
+  }
+
+  const lines = ["[project]"];
+
+  const frameworks = detectFrameworks(cwd, files);
+  if (frameworks.length > 0) {
+    lines.push(`stack: ${frameworks.join(", ")}`);
+  }
+
+  const pkg = extractPackageInfo(cwd);
+  const cargo = extractCargoInfo(cwd);
+  const goInfo = extractGoInfo(cwd);
+  const pyInfo = extractPythonInfo(cwd);
+
+  if (pkg) {
+    if (pkg.name) lines.push(`package: ${pkg.name}${pkg.version ? `@${pkg.version}` : ""}`);
+    if (pkg.frameworks) lines.push(`libraries: ${pkg.frameworks.join(", ")}`);
+    if (pkg.depCounts) lines.push(`dependencies: ${pkg.depCounts}`);
+    if (pkg.scripts) lines.push(`scripts: ${pkg.scripts.join(", ")}`);
+  }
+  if (cargo) {
+    lines.push(`crate: ${cargo.name || "unknown"}${cargo.version ? `@${cargo.version}` : ""}`);
+  }
+  if (goInfo) {
+    lines.push(`module: ${goInfo.module || "unknown"}${goInfo.goVersion ? ` (go ${goInfo.goVersion})` : ""}`);
+  }
+  if (pyInfo) {
+    lines.push(`python project: ${pyInfo.name || pyInfo.type}`);
+  }
+
+  lines.push("");
+  lines.push("structure:");
+  for (const d of dirs) {
+    lines.push(`  ${d}`);
+    const children = listSecondLevel(cwd, d.replace(/\/$/, ""));
+    for (const child of children.slice(0, 15)) {
+      lines.push(`    ${child}`);
+    }
+    if (children.length > 15) {
+      lines.push(`    ... (${children.length - 15} more)`);
+    }
+  }
+  for (const f of files) {
+    lines.push(`  ${f}`);
+  }
+
+  const contextFile = path.join(cwd, ".aether", "context.md");
+  const context = readTextSafe(contextFile, 3000);
+  if (context) {
+    lines.push("");
+    lines.push("project-instructions:");
+    lines.push(context.trim());
+  }
+
+  const readme = readTextSafe(path.join(cwd, "README.md"), 1500);
+  if (readme) {
+    lines.push("");
+    lines.push("readme-excerpt:");
+    lines.push(readme.trim());
+  }
+
+  lines.push("[/project]");
+  return lines.join("\n") + "\n";
+}
+
+export function scanProjectQuick(cwd) {
+  const { dirs, files } = listTopLevel(cwd);
+  const total = dirs.length + files.length;
+  if (total === 0) return "empty directory";
+  const frameworks = detectFrameworks(cwd, files);
+  const pkg = extractPackageInfo(cwd);
+  const parts = [];
+  if (pkg?.name) parts.push(pkg.name);
+  if (frameworks.length > 0) parts.push(frameworks.join(", "));
+  else if (pkg?.frameworks?.length) parts.push(pkg.frameworks[0]);
+  parts.push(`${total} items`);
+  if (pkg?.scripts) parts.push(`${pkg.scripts.length} scripts`);
+  return parts.join(" · ");
+}

package/src/render.js

@@ -88,6 +88,13 @@ export function toolLabel(name, args) {
     case "web_fetch":    return `${verb("fetch")}  ${arg(a.url)}`;
     case "todo_write":   return ""; // its Plan box is the label
     case "ask_user":     return ""; // the interactive menu is its display
+    case "git_status":   return `${verb("git")}    ${arg("status")}`;
+    case "git_diff":     return `${verb("git")}    ${arg("diff" + (a.staged ? " --staged" : "") + (a.base ? ` ${a.base}...${a.head || "HEAD"}` : ""))}`;
+    case "git_log":      return `${verb("git")}    ${arg("log" + (a.file ? ` -- ${a.file}` : "") + (a.branch ? ` ${a.branch}` : ""))}`;
+    case "git_commit":   return `${verb("git")}    ${arg(`commit "${ellip(a.message || "", 50)}"`)}`
+    case "git_branch":   return `${verb("git")}    ${arg(`branch ${a.name}`)}`;
+    case "git_push":     return `${verb("git")}    ${arg("push" + (a.force ? " --force" : ""))}`;
+    case "git_create_pr": return `${verb("git")}    ${arg(`pr "${ellip(a.title || "", 50)}"`)}`
     default:             return `${verb(name)} ${arg(JSON.stringify(a))}`;
   }
 }
@@ -142,6 +149,32 @@ export function toolSummary(name, result) {
   }
   if (name === "todo_write") return ""; // the Plan is its own feedback
   if (name === "ask_user") return ""; // the menu already showed the answer
+  if (name === "git_commit" || name === "git_push" || name === "git_create_pr") {
+    return `  ${branch} ${c.gray(ellip(firstLine, 100))}`;
+  }
+  if (name === "git_status") {
+    try {
+      const s = JSON.parse(out);
+      if (s.clean) return `  ${branch} ${c.gray("clean")}`;
+      const parts = [];
+      if (s.staged?.length) parts.push(`${s.staged.length} staged`);
+      if (s.unstaged?.length) parts.push(`${s.unstaged.length} modified`);
+      if (s.untracked?.length) parts.push(`${s.untracked.length} untracked`);
+      return `  ${branch} ${c.gray(parts.join(", "))}`;
+    } catch { /* fall through */ }
+  }
+  if (name === "git_diff") {
+    if (out === "(no changes)") return `  ${branch} ${c.gray("no changes")}`;
+    const diffLines = out.split("\n").length;
+    return `  ${branch} ${c.gray(`${diffLines} lines of diff`)}`;
+  }
+  if (name === "git_log") {
+    const logLines = out.trim().split("\n").filter((l) => l.trim()).length;
+    return `  ${branch} ${c.gray(`${logLines} lines`)}`;
+  }
+  if (name === "git_branch") {
+    return `  ${branch} ${c.gray(ellip(firstLine, 100))}`;
+  }
   if (name === "write_file" || name === "edit_file") {
     // Handler already printed the diff; echo its short status line.
     return `  ${branch} ${c.gray(ellip(firstLine, 100))}`;