codemax-cli 0.1.1 → 0.1.4

package/src/chat/logo.ts

@@ -0,0 +1,37 @@
+/**
+ * The codemax wordmark for the terminal: the same halftone grid the website
+ * uses ("codemax" in Inter Tight 800, 13 rows, 0 = empty … 9 = full), drawn
+ * with half blocks so two grid rows fit in one terminal line.
+ */
+const GRID = [
+  "0000000000000000000000000028870000000000000000000000000000000000000000000000",
+  "0000000000000000000000000029970000000000000000000000000000000000000000000000",
+  "0000000000000000000000000029970000000000000000000000000000000000000000000000",
+  "0036876200003687510000477429970004787410057715773027861000267863004773005773",
+  "0699999930069999993006999979970079999981079969999499998104999999501998029970",
+  "3999559980499856998039996599970599635996079996899976999319983399910599369920",
+  "7994006992899300799359960049970899100799079930299800699402210189920189899600",
+  "8992000000999100599569940029971999999999179920199700599401578999920049999100",
+  "8992000000999100599569940029971999777777179920199700599418998689920049999100",
+  "7994006992899300799359960049970999000121079920199700599449950079920199899600",
+  "3998459980599846999139996599970599634998079920199700599459951399920699369930",
+  "0699999930079999993007999979970189999993079920199700599429999989922997029980",
+  "0047886200004788620000577517750015788620057720177500477303787347725772004773",
+] as const;
+
+/** Logo lines for a terminal this wide: the full 76-column logo from 78 columns, none below. */
+export function logoLines(width: number): string[] {
+  // Squeezed to half width the letters run together, so narrow terminals get the text title instead.
+  if (width < 78) return [];
+  const on = (r: number, c: number) => Number(GRID[r]?.[c] ?? "0") >= 4;
+  const lines: string[] = [];
+  for (let r = 0; r < GRID.length; r += 2) {
+    let line = "";
+    for (let c = 0; c < GRID[0]!.length; c++) {
+      const up = on(r, c), down = on(r + 1, c);
+      line += up && down ? "█" : up ? "▀" : down ? "▄" : " ";
+    }
+    lines.push(line.replace(/\s+$/, ""));
+  }
+  return lines;
+}

package/src/chat/models.ts

@@ -0,0 +1,33 @@
+/**
+ * Model menus list exactly what the agent offers, newest first: "Default" /
+ * "Auto" stay on top, then models by the version in their name ("Opus 5.5"
+ * before "Opus 4.6", "GPT-6.1" before "GPT-5.6"); equal versions keep the
+ * agent's own order.
+ */
+export interface ModelEntry {
+  id: string;
+  name: string;
+}
+
+const PINNED = /^(default|auto)\b/i;
+
+/** "Opus 5.5" → 5.5, "GPT-6.1-Sol" → 6.1, "claude-opus-4-7" → 4.7, "Sonnet 5" → 5; none → undefined. */
+export function modelVersion(m: ModelEntry): number | undefined {
+  for (const s of [m.name, m.id]) {
+    // Skip date stamps like 20251001; a version is a small major with an optional minor.
+    const hit = s.match(/(?:^|[^\d])(\d{1,2})(?:[.-](\d{1,2}))?(?=$|[^\d])/);
+    if (hit) return Number(hit[1]) + (hit[2] ? Number(hit[2]) / 100 : 0);
+  }
+  return undefined;
+}
+
+export function sortModels<T extends ModelEntry>(models: T[]): T[] {
+  return models
+    .map((m, i) => ({ m, i, pinned: PINNED.test(m.name) || PINNED.test(m.id), v: modelVersion(m) }))
+    .sort((a, b) => {
+      if (a.pinned !== b.pinned) return a.pinned ? -1 : 1;
+      if (a.v !== b.v) return (b.v ?? -1) - (a.v ?? -1);
+      return a.i - b.i;
+    })
+    .map((x) => x.m);
+}

package/src/chat/palette.ts

@@ -37,6 +37,8 @@ export class Palette {
   private rows: TextRenderable[] = [];
   private titleRow: TextRenderable;
   private cursor = 0;
+  /** First visible row: the window scrolls so every item can be reached with the arrows. */
+  private offset = 0;
   private filter: string;
   private matches: PaletteItem[] = [];
   private maxRows: number;
@@ -90,11 +92,16 @@ export class Palette {
 
   render() {
     const { top, width } = this.anchor();
-    const visible = this.matches.slice(0, this.maxRows);
+    // Keep the highlighted row inside the visible window.
+    if (this.cursor < this.offset) this.offset = this.cursor;
+    if (this.cursor >= this.offset + this.maxRows) this.offset = this.cursor - this.maxRows + 1;
+    this.offset = Math.max(0, Math.min(this.offset, this.matches.length - this.maxRows));
+    const visible = this.matches.slice(this.offset, this.offset + this.maxRows);
     const shown = visible.length;
-    const titleLines = this.opts.title ? 1 : 0;
-    this.titleRow.visible = !!this.opts.title;
-    this.titleRow.content = this.opts.title ?? "";
+    const more = this.matches.length > this.maxRows;
+    const titleLines = this.opts.title || more ? 1 : 0;
+    this.titleRow.visible = titleLines > 0;
+    this.titleRow.content = `${this.opts.title ?? ""}${more ? `${this.opts.title ? " · " : ""}${this.cursor + 1}/${this.matches.length} · ↑↓ to scroll` : ""}`;
     this.box.height = shown + titleLines + (shown === 0 ? 1 : 0);
     this.box.top = Math.max(0, top - this.box.height);
     const labelW = Math.min(Math.max(28, Math.floor(width * 0.35)), Math.max(10, ...visible.map((v) => v.label.length + 2)));
@@ -112,7 +119,7 @@ export class Palette {
         return;
       }
       row.visible = true;
-      const sel = i === this.cursor;
+      const sel = this.offset + i === this.cursor;
       const label = pad(it.label, labelW);
       const desc = it.description ?? "";
       const hint = it.hint ? `  ${it.hint}` : "";
@@ -150,7 +157,8 @@ export class Palette {
   }
 
   private move(d: number): boolean {
-    const n = Math.min(this.matches.length, this.maxRows);
+    // Every match is reachable; the window in render() scrolls to follow.
+    const n = this.matches.length;
     if (!n) return true;
     this.cursor = (this.cursor + d + n) % n;
     this.render();

package/src/chat/theme.ts

@@ -1,3 +1,4 @@
+import { fmtTime12 } from "../core/time.ts";
 /**
  * Glyphs and colours. The codemax brand theme: pink is the accent and nothing
  * else, plum is the one dark ink, and warnings, errors and success keep their
@@ -153,6 +154,7 @@ export function fmtDuration(ms: number): string {
   return `${m}m ${s - m * 60}s`;
 }
 
+/** 12-hour, always ("7:25 PM"). */
 export function fmtTime(ts: number): string {
-  return new Date(ts).toLocaleTimeString([], { hour: "numeric", minute: "2-digit" });
+  return fmtTime12(ts);
 }

package/src/chat/transcript.ts

@@ -1,6 +1,7 @@
 import { BoxRenderable, ScrollBoxRenderable, StyledText, TextRenderable, fg, italic, strikethrough, stringToStyledText, type CliRenderer, type TextChunk } from "@opentui/core";
 import { C, G } from "./theme.ts";
 import { styleMarkdown, styleToolOutput } from "./markdown.ts";
+import { fmtTime12 } from "../core/time.ts";
 
 export interface PlanEntry {
   content: string;
@@ -70,7 +71,7 @@ export class Transcript {
   }
 
   /** Startup card: brand mark, what codemax is, the project, and any notes. */
-  header(lines: { title: string; subtitle: string; path: string; notes: string[] }) {
+  header(lines: { title: string; subtitle: string; path: string; notes: string[]; logo?: string[] }) {
     if (this.gone) return;
     const card = new BoxRenderable(this.renderer, {
       id: `header-${++this.n}`,
@@ -82,18 +83,38 @@ export class Transcript {
       paddingX: 1,
       marginTop: 1,
     });
-    const title = new StyledText([fg(C.accent)("✻ "), fg(C.accent)(lines.title)]);
-    card.add(new TextRenderable(this.renderer, { id: `h-t-${this.n}`, content: title, attributes: 1 } as any));
-    card.add(new TextRenderable(this.renderer, { id: `h-s-${this.n}`, content: lines.subtitle, fg: C.dim }));
+    if (lines.logo?.length) {
+      // The wordmark: one line per two rows of the website's halftone grid, never wrapped.
+      for (const [i, l] of lines.logo.entries()) card.add(new TextRenderable(this.renderer, { id: `h-l-${this.n}-${i}`, content: l, fg: C.accent, wrapMode: "none" } as any));
+      card.add(new TextRenderable(this.renderer, { id: `h-s-${this.n}`, content: `${lines.title} · ${lines.subtitle}`, fg: C.dim }));
+    } else {
+      const title = new StyledText([fg(C.accent)("✻ "), fg(C.accent)(lines.title)]);
+      card.add(new TextRenderable(this.renderer, { id: `h-t-${this.n}`, content: title, attributes: 1 } as any));
+      card.add(new TextRenderable(this.renderer, { id: `h-s-${this.n}`, content: lines.subtitle, fg: C.dim }));
+    }
     card.add(new TextRenderable(this.renderer, { id: `h-gap-${this.n}`, content: "", height: 1 }));
     card.add(new TextRenderable(this.renderer, { id: `h-p-${this.n}`, content: `cwd: ${lines.path}`, fg: C.dim, wrapMode: "char" } as any));
     for (const [i, note] of lines.notes.entries()) card.add(new TextRenderable(this.renderer, { id: `h-n-${this.n}-${i}`, content: note, fg: C.dim, wrapMode: "word" } as any));
     this.box.add(card);
   }
 
-  user(text: string) {
+  /** A side agent's note: a bordered card that stands apart from the conversation. */
+  noteCard(title: string, body: string, hint: string) {
+    if (this.gone) return;
+    this.gap();
+    const card = new BoxRenderable(this.renderer, { id: `note-${++this.n}`, width: "100%", flexDirection: "column", border: true, borderStyle: "rounded", borderColor: C.warn, paddingX: 1 });
+    card.add(new TextRenderable(this.renderer, { id: `nt-${this.n}`, content: title, fg: C.warn, attributes: 1 } as any));
+    card.add(new TextRenderable(this.renderer, { id: `nb-${this.n}`, content: styleMarkdown(body), wrapMode: "word", width: "100%" } as any));
+    card.add(new TextRenderable(this.renderer, { id: `nh-${this.n}`, content: hint, fg: C.dim, wrapMode: "word" } as any));
+    this.box.add(card);
+    this.scrollToEnd();
+  }
+
+  /** Your message, with the time it was sent ("· 7:25 PM", 12-hour). */
+  user(text: string, ts = Date.now()) {
     this.gap();
-    this.line(`${G.prompt} `, text, { fg: undefined, glyphFg: C.accent });
+    const node = this.line(`${G.prompt} `, text, { fg: undefined, glyphFg: C.accent });
+    node.content = new StyledText([...stringToStyledText(text).chunks, fg(C.dimmer)(`  · ${fmtTime12(ts)}`)]);
   }
 
   note(text: string, fg_: string = C.dim) {

package/src/cli.ts

@@ -1,4 +1,8 @@
-import { loadConfig, CONFIG_PATH, hotkeyLabel } from "./config.ts";
+import { loadConfig, CONFIG_PATH, hotkeyLabel, saveConfigKey } from "./config.ts";
+import { defaultAwakeDeps, recoverAwake } from "./core/awake.ts";
+import { checkForUpdate, installKind, updatePlan } from "./core/update.ts";
+import { platformArgv } from "./core/spawn.ts";
+import pkg from "../package.json" with { type: "json" };
 import { canonicalCwd } from "./core/paths.ts";
 import { Ledger } from "./core/ledger.ts";
 import { Orchestrator } from "./core/orchestrator.ts";
@@ -14,6 +18,7 @@ import { diagnose } from "./core/doctor.ts";
 import { renderUsageTable, sumCost } from "./core/usage.ts";
 import { fmtUsd, priceFor, priceProvenance, resetPriceCache } from "./core/pricing.ts";
 import { fetchLivePrices, loadLivePrices, LIVE_PRICES_PATH } from "./core/prices-live.ts";
+import { fmtDateTime12 } from "./core/time.ts";
 
 const HELP = `codemax — one terminal for all your coding agents
 
@@ -27,6 +32,8 @@ usage:
   codemax brief [--to <id>]                  print the handoff brief that would be injected
   codemax config                             print config path and values
   codemax keys                               show the raw bytes your terminal sends per keypress (hotkey debugging)
+  codemax update [--check]                    update codemax the way it was installed (--check only reports)
+  codemax awake [on|lid|off|status]          keep the machine awake while codemax runs (lid: also with the lid closed)
   codemax quota [clear [<id>]]               show or clear remembered quota state for this project
   codemax doctor [--fix]                     check agent auth/permission setup (API keys that would be billed, silent modes)
   codemax usage [--all]                      tokens and API-equivalent cost per agent for this project (or every project)
@@ -67,9 +74,9 @@ async function main(argv: string[]) {
         const orch = new Orchestrator(config, ledger, cwd);
         await orch.start(agent, args.includes("--fresh"));
       } else if (args.includes("--tui") || !hasEngine(agent)) {
-        await runApp(config, ledger, cwd, agent, args.includes("--fresh"));
+        await runApp(config, ledger, cwd, agent, args.includes("--fresh"), !!agentFlag);
       } else {
-        await runChat(config, ledger, cwd, agent, args.includes("--fresh"), !agentFlag);
+        await runChat(config, ledger, cwd, agent, args.includes("--fresh"), !agentFlag, !!agentFlag);
       }
       process.exit(0);
     }
@@ -99,7 +106,7 @@ async function main(argv: string[]) {
       const last = events.slice(-5);
       if (last.length) {
         console.log("recent events:");
-        for (const e of last) console.log(`  ${new Date(e.ts).toLocaleString()}  ${e.kind}  ${e.agent ?? ""}${e.to ? ` → ${e.to}` : ""}  ${e.detail ?? ""}`);
+        for (const e of last) console.log(`  ${fmtDateTime12(e.ts)}  ${e.kind}  ${e.agent ?? ""}${e.to ? ` → ${e.to}` : ""}  ${e.detail ?? ""}`);
       }
       return;
     }
@@ -108,7 +115,7 @@ async function main(argv: string[]) {
       const turns = new Ledger(cwd).turns().slice(-n);
       for (const t of turns) {
         const who = t.role === "user" ? "USER" : `${t.agent.toUpperCase()}`;
-        console.log(`\n[${new Date(t.ts).toLocaleTimeString()}] ${who}${t.tools?.length ? ` (tools: ${t.tools.join(", ")})` : ""}\n${t.text.slice(0, 600)}`);
+        console.log(`\n[${fmtDateTime12(t.ts)}] ${who}${t.tools?.length ? ` (tools: ${t.tools.join(", ")})` : ""}\n${t.text.slice(0, 600)}`);
       }
       return;
     }
@@ -164,6 +171,45 @@ async function main(argv: string[]) {
       }
       return;
     }
+    case "update": {
+      const latest = await checkForUpdate(pkg.version, { force: true });
+      console.log(latest ? `codemax ${latest} is available (you have ${pkg.version})` : `codemax ${pkg.version} is the latest`);
+      if (args.includes("--check") || !latest) return;
+      const plan = updatePlan();
+      if (plan.manual) return console.log(plan.manual);
+      console.log(`updating with ${plan.label} (${installKind().kind} install)\n`);
+      for (const cmd of plan.cmd) {
+        const p = Bun.spawn(platformArgv(cmd), { stdin: "inherit", stdout: "inherit", stderr: "inherit", env: { ...process.env, ...(plan.env ?? {}) } });
+        if ((await p.exited) !== 0) {
+          console.error(`\nupdate failed · run it yourself: ${plan.cmd.map((c) => c.join(" ")).join(" && ")}`);
+          process.exit(1);
+        }
+      }
+      console.log("\ncodemax updated.");
+      return;
+    }
+    case "awake": {
+      const v = (args[0] ?? "status").toLowerCase();
+      const support = process.platform === "linux" ? "sleep, lid close and shutdown are blocked (systemd-inhibit)" : process.platform === "darwin" ? "sleep is blocked; lid close needs your admin password once; macOS cannot block shutdown" : process.platform === "win32" ? "sleep is blocked; lid close switches the lid action to 'do nothing' and back; Windows cannot block shutdown" : "not supported on this platform";
+      if (v === "status") {
+        console.log(`awake: ${config.awake ?? "off"} (applies while codemax runs)\n${process.platform}: ${support}`);
+        return;
+      }
+      if (v !== "on" && v !== "lid" && v !== "off") {
+        console.error("usage: codemax awake [on|lid|off|status]");
+        process.exit(2);
+      }
+      if (v === "off") for (const n of await recoverAwake({ ...defaultAwakeDeps(), pid: -1, interactive: (fn) => fn() })) console.log(n);
+      if (v === "lid" && process.platform === "darwin") {
+        console.log("macOS needs your admin password to keep working with the lid closed (pmset disablesleep).");
+        const ok = Bun.spawnSync(["sudo", "-v"], { stdin: "inherit", stdout: "inherit", stderr: "inherit" }).exitCode === 0;
+        if (!ok) console.log("no admin rights: lid-close will not be enabled; the Mac still will not idle-sleep.");
+      }
+      saveConfigKey("awake", v);
+      console.log(v === "off" ? "awake off: the machine sleeps normally" : `awake ${v}: applies whenever codemax is running · ${support}`);
+      if (v === "lid") console.log("With the lid closed, keep the laptop somewhere it can breathe: not in a bag.");
+      return;
+    }
     case "quota": {
       const ledger = new Ledger(cwd);
       if (args[0] === "clear") {
@@ -173,7 +219,7 @@ async function main(argv: string[]) {
       }
       const all = ledger.quota();
       if (!Object.keys(all).length) return console.log("no quota state recorded");
-      for (const q of Object.values(all)) console.log(`${q.agent.padEnd(9)} ${quotaLabel(q) || "ok"}  (${q.source}, ${new Date(q.at).toLocaleString()}${q.detail ? `, ${q.detail}` : ""})`);
+      for (const q of Object.values(all)) console.log(`${q.agent.padEnd(9)} ${quotaLabel(q) || "ok"}  (${q.source}, ${fmtDateTime12(q.at)}${q.detail ? `, ${q.detail}` : ""})`);
       return;
     }
     case "keys": {

package/src/config.ts

@@ -28,6 +28,20 @@ export interface Config {
   checkpoints: boolean;
   /** Refresh the public price list weekly for /usage (set false to stay offline). */
   priceUpdates: boolean;
+  /**
+   * Keep the machine awake while codemax runs: "on" prevents sleep, "lid" also keeps
+   * working with the laptop lid closed. See src/core/awake.ts for each platform.
+   */
+  awake: "off" | "on" | "lid";
+  /**
+   * Side agent: another agent that reviews the main agent's work after each turn and
+   * leaves a note when something needs attention. `forward: "auto"` sends notes to the
+   * main agent by itself; "ask" waits for /forward.
+   */
+  /** `every`: review every Nth working turn (1 = each turn, 0 = only on /review). Each review is a request on the side agent's plan. */
+  sideAgent: { agent: AgentId | null; forward: "ask" | "auto"; model?: string; every?: number };
+  /** Check npm for a newer codemax at most every 12 hours and offer /update. */
+  updateCheck: boolean;
   /** Colour theme: "auto" follows the terminal's background, or force "dark" / "light". */
   theme: "auto" | "dark" | "light";
   /**
@@ -49,6 +63,9 @@ export const DEFAULT_CONFIG: Config = {
   summarizeOnSwitch: true,
   bellAfterSeconds: 20,
   theme: "auto",
+  awake: "off",
+  updateCheck: true,
+  sideAgent: { agent: null, forward: "ask" },
   brief: { turns: 10, maxChars: 8000, turnChars: 1200, resumeChars: 24000 },
 };
 
@@ -71,6 +88,7 @@ export function loadConfig(): Config {
       brief: { ...DEFAULT_CONFIG.brief, ...(raw.brief ?? {}) },
       agentArgs: { ...(raw.agentArgs ?? {}) },
       budgets: { ...(raw.budgets ?? {}) },
+      sideAgent: { ...DEFAULT_CONFIG.sideAgent, ...(raw.sideAgent ?? {}) },
       routes: Array.isArray(raw.routes) ? raw.routes : [],
     };
   } catch {