aether-code 0.36.7 → 0.37.0

package/src/menu.js

@@ -1,83 +1,83 @@
-// Interactive multiple-choice menu — arrow/number selectable, cmd.exe-safe.
-//
-// Deliberately NOT Ink (which ghosts in the legacy Windows console). Uses a
-// simple manual redraw: print the list, and on each keypress move the cursor
-// back up to the top of the menu (ESC[nA) and clear-to-end (ESC[J), then
-// reprint. That's the same VT layer that already renders our ANSI colours, so
-// it works in cmd.exe, Windows Terminal, and POSIX terminals alike.
-//
-// Returns the chosen option object ({label, description}), or null if cancelled.
-
-import readline from "node:readline";
-import { c } from "./render.js";
-
-const ellip = (s, n) => (s && s.length > n ? s.slice(0, n - 1) + "…" : s || "");
-
-export function promptChoice({ question, options }) {
-  const opts = (options || [])
-    .map((o) => (typeof o === "string" ? { label: o } : o))
-    .filter((o) => o && o.label);
-
-  return new Promise((resolve) => {
-    // Non-interactive (piped / CI): pick the first option so automation never
-    // hangs waiting on a keypress that can't come. Print a note so it's visible.
-    if (!process.stdin.isTTY || opts.length === 0) {
-      const pick = opts[0] ?? null;
-      if (pick) process.stdout.write(c.cyan("● ") + c.bold(question) + c.gray(`  → ${pick.label} (auto)\n`));
-      resolve(pick);
-      return;
-    }
-
-    let sel = 0;
-    const total = opts.length + 3; // question line + options + blank + hint line
-
-    const draw = (first) => {
-      if (!first) process.stdout.write(`\x1b[${total}A`); // cursor up to menu top
-      process.stdout.write("\x1b[J"); // clear from cursor to end of screen
-      process.stdout.write(c.cyan("● ") + c.bold(question) + "\n");
-      opts.forEach((o, i) => {
-        const active = i === sel;
-        const pointer = active ? c.cyan("→") : " ";
-        const num = active ? c.cyan(c.bold(`${i + 1}.`)) : c.gray(`${i + 1}.`);
-        const label = active ? c.bold(o.label) : o.label;
-        const desc = o.description ? c.gray("  " + ellip(o.description, 60)) : "";
-        process.stdout.write(`  ${pointer} ${num} ${label}${desc}\n`);
-      });
-      process.stdout.write("\n" + c.gray("  ↑/↓ move · 1-9 pick · Enter select · Esc cancel") + "\n");
-    };
-
-    const cleanup = () => {
-      process.stdin.removeListener("keypress", onKey);
-      if (process.stdin.isTTY) process.stdin.setRawMode(false);
-      process.stdin.pause();
-    };
-
-    const finish = (result) => {
-      cleanup();
-      // Collapse the menu to a compact answer line so the transcript stays clean.
-      process.stdout.write(`\x1b[${total}A\x1b[J`);
-      process.stdout.write(c.cyan("● ") + c.bold(question) + "\n");
-      if (result) process.stdout.write("  " + c.cyan("→") + " " + c.green(result.label) + "\n\n");
-      else process.stdout.write("  " + c.gray("(cancelled — proceeding with best judgment)") + "\n\n");
-      resolve(result);
-    };
-
-    const onKey = (str, key) => {
-      if (!key) return;
-      if (key.name === "up" || key.name === "k") { sel = (sel - 1 + opts.length) % opts.length; draw(false); }
-      else if (key.name === "down" || key.name === "j" || key.name === "tab") { sel = (sel + 1) % opts.length; draw(false); }
-      else if (str && /^[1-9]$/.test(str)) {
-        const i = parseInt(str, 10) - 1;
-        if (i < opts.length) finish(opts[i]);
-      }
-      else if (key.name === "return") finish(opts[sel]);
-      else if (key.name === "escape" || (key.ctrl && key.name === "c")) finish(null);
-    };
-
-    readline.emitKeypressEvents(process.stdin);
-    if (process.stdin.isTTY) process.stdin.setRawMode(true);
-    process.stdin.resume();
-    process.stdin.on("keypress", onKey);
-    draw(true);
-  });
-}
+// Interactive multiple-choice menu — arrow/number selectable, cmd.exe-safe.
+//
+// Deliberately NOT Ink (which ghosts in the legacy Windows console). Uses a
+// simple manual redraw: print the list, and on each keypress move the cursor
+// back up to the top of the menu (ESC[nA) and clear-to-end (ESC[J), then
+// reprint. That's the same VT layer that already renders our ANSI colours, so
+// it works in cmd.exe, Windows Terminal, and POSIX terminals alike.
+//
+// Returns the chosen option object ({label, description}), or null if cancelled.
+
+import readline from "node:readline";
+import { c } from "./render.js";
+
+const ellip = (s, n) => (s && s.length > n ? s.slice(0, n - 1) + "…" : s || "");
+
+export function promptChoice({ question, options }) {
+  const opts = (options || [])
+    .map((o) => (typeof o === "string" ? { label: o } : o))
+    .filter((o) => o && o.label);
+
+  return new Promise((resolve) => {
+    // Non-interactive (piped / CI): pick the first option so automation never
+    // hangs waiting on a keypress that can't come. Print a note so it's visible.
+    if (!process.stdin.isTTY || opts.length === 0) {
+      const pick = opts[0] ?? null;
+      if (pick) process.stdout.write(c.cyan("● ") + c.bold(question) + c.gray(`  → ${pick.label} (auto)\n`));
+      resolve(pick);
+      return;
+    }
+
+    let sel = 0;
+    const total = opts.length + 3; // question line + options + blank + hint line
+
+    const draw = (first) => {
+      if (!first) process.stdout.write(`\x1b[${total}A`); // cursor up to menu top
+      process.stdout.write("\x1b[J"); // clear from cursor to end of screen
+      process.stdout.write(c.cyan("● ") + c.bold(question) + "\n");
+      opts.forEach((o, i) => {
+        const active = i === sel;
+        const pointer = active ? c.cyan("→") : " ";
+        const num = active ? c.cyan(c.bold(`${i + 1}.`)) : c.gray(`${i + 1}.`);
+        const label = active ? c.bold(o.label) : o.label;
+        const desc = o.description ? c.gray("  " + ellip(o.description, 60)) : "";
+        process.stdout.write(`  ${pointer} ${num} ${label}${desc}\n`);
+      });
+      process.stdout.write("\n" + c.gray("  ↑/↓ move · 1-9 pick · Enter select · Esc cancel") + "\n");
+    };
+
+    const cleanup = () => {
+      process.stdin.removeListener("keypress", onKey);
+      if (process.stdin.isTTY) process.stdin.setRawMode(false);
+      process.stdin.pause();
+    };
+
+    const finish = (result) => {
+      cleanup();
+      // Collapse the menu to a compact answer line so the transcript stays clean.
+      process.stdout.write(`\x1b[${total}A\x1b[J`);
+      process.stdout.write(c.cyan("● ") + c.bold(question) + "\n");
+      if (result) process.stdout.write("  " + c.cyan("→") + " " + c.green(result.label) + "\n\n");
+      else process.stdout.write("  " + c.gray("(cancelled — proceeding with best judgment)") + "\n\n");
+      resolve(result);
+    };
+
+    const onKey = (str, key) => {
+      if (!key) return;
+      if (key.name === "up" || key.name === "k") { sel = (sel - 1 + opts.length) % opts.length; draw(false); }
+      else if (key.name === "down" || key.name === "j" || key.name === "tab") { sel = (sel + 1) % opts.length; draw(false); }
+      else if (str && /^[1-9]$/.test(str)) {
+        const i = parseInt(str, 10) - 1;
+        if (i < opts.length) finish(opts[i]);
+      }
+      else if (key.name === "return") finish(opts[sel]);
+      else if (key.name === "escape" || (key.ctrl && key.name === "c")) finish(null);
+    };
+
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("keypress", onKey);
+    draw(true);
+  });
+}

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(" · ");
+}