aether-code 0.36.8 → 0.38.0

package/src/repl.js

@@ -15,8 +15,14 @@ import { runSetup } from "./setup.js";
 import { c, errorLine, boxLines, sideBySide } from "./render.js";
 import { checkForUpdate } from "./update-check.js";
 import { promptBox, EXIT_SIGNAL } from "./box-input.js";
+import { getVersion } from "./version.js";
+import {
+  generateSessionId, saveSession, loadSession, listSessions,
+  findRecentSession, deleteSession, extractSummary, formatAge,
+} from "./sessions.js";
+import { scanProjectQuick } from "./project-context.js";
 
-const VERSION = "0.32.0";
+const VERSION = getVersion();
 const MODEL_NAME = "Aether Core";
 
 // /model aliases → { id, name }. id=null = server default (gemma / Aether Core).
@@ -38,9 +44,12 @@ 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("/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)
 
 ${c.gray("Anything else is sent to the agent as your next message.")}
-${c.gray("Conversation history is kept across messages until you /clear.")}
+${c.gray("Sessions auto-save — close the terminal and come back later.")}
 `;
 
 export async function runRepl({ cwd: initialCwd, autoYes: initialAutoYes, unsafePaths: initialUnsafePaths, maxTurns: initialMaxTurns, model: initialModel = null, mcpManager = null }) {
@@ -52,19 +61,17 @@ export async function runRepl({ cwd: initialCwd, autoYes: initialAutoYes, unsafe
     maxTurns: initialMaxTurns ?? 25,
     model: initialModel ?? null,
     modelName: initialAlias?.name ?? MODEL_NAME,
-    messages: [], // accumulates across turns
+    messages: [],
     balance: null,
     sessionCredits: 0,
     sessionIn: 0,
     sessionOut: 0,
+    sessionId: generateSessionId(initialCwd),
+    turnCount: 0,
   };
 
-  // Kick off the npm update check concurrently with the balance fetch so it
-  // adds no startup latency; the nudge (if any) prints just under the banner.
   const updatePromise = checkForUpdate().catch(() => null);
 
-  // Free balance check up front. If no key configured, walk through first-time
-  // setup flow (open browser → paste key → verify → save).
   let needsSetup = false;
   try {
     const me = await fetchBalance();
@@ -74,7 +81,6 @@ export async function runRepl({ cwd: initialCwd, autoYes: initialAutoYes, unsafe
     if (err instanceof AetherError && (err.code === "NO_API_KEY" || err.status === 401)) {
       needsSetup = true;
     } else {
-      // Transient network or other — surface but don't block
       console.log(c.gray(`(could not fetch balance: ${err.message})`));
     }
   }
@@ -85,42 +91,73 @@ export async function runRepl({ cwd: initialCwd, autoYes: initialAutoYes, unsafe
       console.log(c.gray("Aborting — no valid API key."));
       process.exit(1);
     }
-    // Re-fetch balance now that the key is saved
     try {
       const me = await fetchBalance();
       state.balance = me.balance;
       state.plan = me.plan;
-    } catch { /* tolerate — banner just won't show balance */ }
+    } catch { /* tolerate */ }
   }
 
-  printBanner(state);
+  // Check for a resumable session before printing the banner
+  let resumed = false;
+  try {
+    const recent = findRecentSession(state.cwd);
+    if (recent && recent.messageCount >= 2) {
+      const full = loadSession(recent.id);
+      if (full && full.messages?.length >= 2) {
+        console.log(
+          c.gray(`\n  Found session from ${formatAge(recent.updatedAt)} — `) +
+          c.cyan(extractSummary(full.messages) || "(no summary)"),
+        );
+        console.log(c.gray("  Resuming automatically. Use /new to start fresh.\n"));
+        state.sessionId = full.id;
+        state.messages = full.messages;
+        state.sessionCredits = full.credits ?? 0;
+        state.sessionIn = full.tokensIn ?? 0;
+        state.sessionOut = full.tokensOut ?? 0;
+        state.turnCount = full.turnCount ?? 0;
+        if (full.model !== undefined) state.model = full.model;
+        if (full.modelName) state.modelName = full.modelName;
+        resumed = true;
+      }
+    }
+  } catch { /* non-fatal */ }
+
+  // Project quick-scan for banner
+  let projectLine = "";
+  try {
+    projectLine = scanProjectQuick(state.cwd);
+  } catch { /* non-fatal */ }
+
+  printBanner(state, projectLine, resumed);
   const updateNudge = await updatePromise;
   if (updateNudge) console.log(updateNudge + "\n");
 
-  // Input: a bordered raw-mode box (box-input.js) — cmd.exe-safe and identical
-  // everywhere. (Ink's live redraw ghosts in the legacy Windows console, so we
-  // don't use it.) Each prompt is independent; the tool y/N prompts and the
-  // ask_user menu run BETWEEN prompts in raw mode too, so nothing overlaps.
   const inputHistory = [];
 
   while (true) {
     const raw = await promptBox({ history: inputHistory });
-    if (raw === EXIT_SIGNAL) { console.log(c.gray("bye.")); return; }
+    if (raw === EXIT_SIGNAL) {
+      autoSave(state);
+      console.log(c.gray("bye."));
+      return;
+    }
     const line = (raw ?? "").trim();
     if (!line) continue;
 
-    // promptBox already echoes "› <line>" on submit, so no echo needed here.
     inputHistory.push(line);
 
-    // Slash command?
     if (line.startsWith("/") || line === "?") {
       const handled = await handleSlash(line, state);
-      if (handled === "exit") return;
+      if (handled === "exit") {
+        autoSave(state);
+        return;
+      }
       printStatusLine(state);
       continue;
     }
 
-    // Otherwise — send as a message to the agent
+    state.turnCount++;
     const result = await runAgent({
       initialPrompt: line,
       priorMessages: state.messages.length > 0 ? state.messages : undefined,
@@ -140,13 +177,31 @@ export async function runRepl({ cwd: initialCwd, autoYes: initialAutoYes, unsafe
 
     if (!result.ok && result.error) {
       console.log("\n" + errorLine(result.error.message || String(result.error)));
-      // Don't kill the session on a single error — surface it and continue.
     }
 
+    autoSave(state);
     printStatusLine(state);
   }
 }
 
+function autoSave(state) {
+  if (state.messages.length < 2) return;
+  try {
+    saveSession({
+      id: state.sessionId,
+      cwd: state.cwd,
+      model: state.model,
+      modelName: state.modelName,
+      messages: state.messages,
+      credits: state.sessionCredits,
+      tokensIn: state.sessionIn,
+      tokensOut: state.sessionOut,
+      turnCount: state.turnCount,
+      summary: extractSummary(state.messages),
+    });
+  } catch { /* non-fatal — don't kill the session over a save failure */ }
+}
+
 /* ───────── slash commands ───────── */
 
 async function handleSlash(line, state) {
@@ -231,6 +286,75 @@ async function handleSlash(line, state) {
       }
       break;
     }
+    case "sessions": {
+      const sessions = listSessions(state.cwd);
+      if (sessions.length === 0) {
+        console.log(c.gray("No saved sessions for this directory."));
+      } else {
+        console.log(c.bold("Saved sessions") + c.gray(` (${state.cwd})`));
+        for (const s of sessions.slice(0, 10)) {
+          const active = s.id === state.sessionId ? c.cyan(" ← current") : "";
+          const summary = s.summary || "(no summary)";
+          const truncated = summary.length > 60 ? summary.slice(0, 57) + "..." : summary;
+          console.log(
+            `  ${c.gray(formatAge(s.updatedAt).padEnd(8))} ` +
+            `${c.gray(s.id.slice(0, 16))}  ` +
+            `${truncated}` +
+            `${c.gray(` · ${s.turnCount} turns`)}` +
+            active,
+          );
+        }
+        if (sessions.length > 10) {
+          console.log(c.gray(`  ... and ${sessions.length - 10} more`));
+        }
+        console.log(c.gray("\nUse /resume <id-prefix> to load one."));
+      }
+      break;
+    }
+    case "resume": {
+      const target = (arg || "").trim();
+      let session = null;
+      if (target) {
+        const sessions = listSessions(state.cwd);
+        const match = sessions.find((s) => s.id.startsWith(target));
+        if (match) session = loadSession(match.id);
+        if (!session) {
+          console.log(errorLine(`No session matching "${target}" found.`));
+          break;
+        }
+      } else {
+        const recent = findRecentSession(state.cwd);
+        if (recent) session = loadSession(recent.id);
+        if (!session) {
+          console.log(errorLine("No recent session to resume. Use /sessions to list."));
+          break;
+        }
+      }
+      autoSave(state);
+      state.sessionId = session.id;
+      state.messages = session.messages ?? [];
+      state.sessionCredits = session.credits ?? 0;
+      state.sessionIn = session.tokensIn ?? 0;
+      state.sessionOut = session.tokensOut ?? 0;
+      state.turnCount = session.turnCount ?? 0;
+      if (session.model !== undefined) state.model = session.model;
+      if (session.modelName) state.modelName = session.modelName;
+      const summary = extractSummary(session.messages) || "(no summary)";
+      console.log(c.gray(`Resumed: `) + c.cyan(summary));
+      console.log(c.gray(`  ${state.messages.length} messages · ${state.turnCount} turns · ${formatAge(session.updatedAt)}`));
+      break;
+    }
+    case "new": {
+      autoSave(state);
+      state.sessionId = generateSessionId(state.cwd);
+      state.messages = [];
+      state.sessionCredits = 0;
+      state.sessionIn = 0;
+      state.sessionOut = 0;
+      state.turnCount = 0;
+      console.log(c.gray("New session started. Previous session saved."));
+      break;
+    }
     default:
       console.log(errorLine(`Unknown command: /${cmd}. Type ${c.cyan("/help")} for shortcuts.`));
   }
@@ -245,23 +369,27 @@ const shortenPath = (p, max) => (p.length <= max ? p : "..." + p.slice(p.length
 // Short, hand-curated highlights shown in the "What's new" box. Update with
 // notable releases — keep it to ~3 lines so it balances the banner height.
 const WHATS_NEW = [
-  "Files now save to your Desktop",
+  "Session persistence — close & resume",
+  "Project auto-understanding on startup",
   "Live thinking spinner + loop guard",
-  "Asks you when a task is unclear",
 ];
 
-function printBanner(state) {
+function printBanner(state, projectLine = "", resumed = false) {
   const mode = state.autoYes ? (state.unsafePaths ? "skip-permissions" : "auto-yes") : "review mode";
   const credits = state.balance != null ? `${state.balance.toLocaleString()} credits` : "";
-  const left = boxLines(
-    [
-      c.bold(c.magenta("aether")) + c.gray("  ·  ") + c.bold(state.modelName) + c.gray("   v" + VERSION),
-      c.gray("uncensored AI coding agent"),
-      c.gray((credits ? credits + " · " : "") + mode),
-      c.gray(shortenPath(state.cwd, 52)),
-    ],
-    { color: c.magenta, padX: 2 },
-  );
+  const leftLines = [
+    c.bold(c.magenta("aether")) + c.gray("  ·  ") + c.bold(state.modelName) + c.gray("   v" + VERSION),
+    c.gray("uncensored AI coding agent"),
+    c.gray((credits ? credits + " · " : "") + mode),
+    c.gray(shortenPath(state.cwd, 52)),
+  ];
+  if (projectLine) {
+    leftLines.push(c.gray("project: " + (projectLine.length > 48 ? projectLine.slice(0, 45) + "..." : projectLine)));
+  }
+  if (resumed) {
+    leftLines.push(c.cyan("↻ resumed session") + c.gray(` · ${state.turnCount} turns · ${state.messages.length} msgs`));
+  }
+  const left = boxLines(leftLines, { color: c.magenta, padX: 2 });
   const right = boxLines(
     [c.bold(c.cyan("What's new")), ...WHATS_NEW.map((s) => c.gray("• " + s))],
     { color: c.cyan, padX: 2 },
@@ -269,8 +397,6 @@ function printBanner(state) {
 
   console.log("");
   const cols = process.stdout.columns || 80;
-  // Only place the two boxes side by side when there's room; otherwise the
-  // banner alone (narrow terminals would wrap and tear the second box).
   if (cols >= visLen(left[0]) + visLen(right[0]) + 4) {
     console.log(sideBySide(left, right, 3));
   } else {

package/src/sessions.js

@@ -0,0 +1,167 @@
+// Session persistence. Saves conversation state to ~/.aether/sessions/ so
+// users can close the terminal, come back tomorrow, and resume exactly
+// where they left off. Auto-saves after every agent turn.
+
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import crypto from "node:crypto";
+
+const SESSIONS_DIR = path.join(os.homedir(), ".aether", "sessions");
+const MAX_SESSIONS = 50;
+const STALE_DAYS = 14;
+
+function ensureDir() {
+  fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+}
+
+function cwdHash(cwd) {
+  return crypto.createHash("sha256").update(cwd.toLowerCase()).digest("hex").slice(0, 12);
+}
+
+function sessionPath(id) {
+  return path.join(SESSIONS_DIR, `${id}.json`);
+}
+
+export function generateSessionId(cwd) {
+  const hash = cwdHash(cwd);
+  const ts = Date.now().toString(36);
+  return `${hash}-${ts}`;
+}
+
+export function saveSession(session) {
+  ensureDir();
+  const data = {
+    id: session.id,
+    cwd: session.cwd,
+    model: session.model ?? null,
+    modelName: session.modelName ?? "Aether Core",
+    messages: session.messages ?? [],
+    credits: session.credits ?? 0,
+    tokensIn: session.tokensIn ?? 0,
+    tokensOut: session.tokensOut ?? 0,
+    createdAt: session.createdAt ?? new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    summary: session.summary ?? "",
+    turnCount: session.turnCount ?? 0,
+  };
+  const filePath = sessionPath(data.id);
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2), { mode: 0o600 });
+  try { fs.chmodSync(filePath, 0o600); } catch { /* windows */ }
+  pruneOldSessions();
+  return data;
+}
+
+export function loadSession(id) {
+  const filePath = sessionPath(id);
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export function deleteSession(id) {
+  try {
+    fs.unlinkSync(sessionPath(id));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function listSessions(filterCwd) {
+  ensureDir();
+  let files;
+  try {
+    files = fs.readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const sessions = [];
+  for (const f of files) {
+    try {
+      const raw = fs.readFileSync(path.join(SESSIONS_DIR, f), "utf8");
+      const data = JSON.parse(raw);
+      if (filterCwd && data.cwd?.toLowerCase() !== filterCwd.toLowerCase()) continue;
+      sessions.push({
+        id: data.id,
+        cwd: data.cwd,
+        model: data.model,
+        modelName: data.modelName,
+        summary: data.summary,
+        turnCount: data.turnCount ?? 0,
+        messageCount: data.messages?.length ?? 0,
+        credits: data.credits ?? 0,
+        createdAt: data.createdAt,
+        updatedAt: data.updatedAt,
+      });
+    } catch {
+      continue;
+    }
+  }
+  sessions.sort((a, b) => (b.updatedAt || "").localeCompare(a.updatedAt || ""));
+  return sessions;
+}
+
+export function findRecentSession(cwd, maxAgeMs = 24 * 60 * 60 * 1000) {
+  const sessions = listSessions(cwd);
+  if (sessions.length === 0) return null;
+  const newest = sessions[0];
+  if (!newest.updatedAt) return null;
+  const age = Date.now() - new Date(newest.updatedAt).getTime();
+  if (age > maxAgeMs) return null;
+  if (newest.messageCount < 2) return null;
+  return newest;
+}
+
+function pruneOldSessions() {
+  let files;
+  try {
+    files = fs.readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".json"));
+  } catch {
+    return;
+  }
+  if (files.length <= MAX_SESSIONS) return;
+  const entries = [];
+  for (const f of files) {
+    try {
+      const stat = fs.statSync(path.join(SESSIONS_DIR, f));
+      entries.push({ file: f, mtime: stat.mtimeMs });
+    } catch {
+      continue;
+    }
+  }
+  entries.sort((a, b) => b.mtime - a.mtime);
+  const cutoff = Date.now() - STALE_DAYS * 24 * 60 * 60 * 1000;
+  for (const e of entries.slice(MAX_SESSIONS)) {
+    if (e.mtime < cutoff) {
+      try { fs.unlinkSync(path.join(SESSIONS_DIR, e.file)); } catch { /* ignore */ }
+    }
+  }
+}
+
+export function extractSummary(messages) {
+  if (!messages || messages.length === 0) return "";
+  const firstUser = messages.find((m) => m.role === "user");
+  if (!firstUser || typeof firstUser.content !== "string") return "";
+  const text = firstUser.content
+    .replace(/\[environment\][\s\S]*?\[\/environment\]\s*/g, "")
+    .replace(/\[project\][\s\S]*?\[\/project\]\s*/g, "")
+    .replace(/=== LOADED SKILLS[\s\S]*?---\s*/g, "")
+    .trim();
+  return text.length > 120 ? text.slice(0, 117) + "..." : text;
+}
+
+export function formatAge(isoDate) {
+  if (!isoDate) return "unknown";
+  const ms = Date.now() - new Date(isoDate).getTime();
+  const mins = Math.floor(ms / 60_000);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}