@hackerrank/astra-cli 0.1.0 → 0.1.1

package/src/repl.js

@@ -15,7 +15,8 @@ import path from "node:path";
 import { execFileSync } from "node:child_process";
 import readline from "node:readline";
 import { fileURLToPath } from "node:url";
-import { ask } from "./config.js";
+import { ask, saveAgentPrefs } from "./config.js";
+import { AVAILABLE_MODELS, REASONING_LEVELS } from "./models.js";
 
 const C = {
   dim: (s) => `\x1b[2m${s}\x1b[0m`,
@@ -55,9 +56,9 @@ function pkgVersion() {
 // ASCII wordmark (figlet "standard" style) shown when a new chat starts.
 const BANNER = [
   "              _                 ",
-  "  __ _  ___  | |_   __ __    __ _ ",
-  " / _` |/ __| | __| |__ __|  / _`  |",
-  "| (_| |\\__ \\ | |_  | |   | (_|  |",
+  "  __ _  ___  | |_   _ __   __ _ ",
+  " / _` |/ __| | __| | '__| / _` |",
+  "| (_| |\\__ \\ | |_  | |   | (_| |",
   " \\__,_||___/  \\__| |_|    \\__,_|",
 ];
 
@@ -131,13 +132,14 @@ function turnSummary({ turn, upTok, downTok, costUsd, costKind, seconds }) {
  * and cumulative token/context/cost usage. Returned as an array so the sticky
  * screen can pin them to the bottom rows.
  */
-function footerLines(agent, model, yolo) {
+function footerLines(agent, model, yolo, mode = "agent") {
   const cols = process.stdout.columns || 100;
   const rule = "─".repeat(cols);
 
-  const reasoning = model.modelKwargs?.reasoning_effort || model.modelKwargs?.reasoning?.effort;
+  const reasoning = model.modelKwargs?.reasoning_effort || model.modelKwargs?.reasoning?.effort || "off";
+  const modeTag = mode === "bench" ? C.yellow("◆ bench") : C.cyan("◆ agent");
   const modelBits = [`model: ${model.model}`];
-  if (reasoning) modelBits.push(`reasoning: ${reasoning}`);
+  modelBits.push(`reasoning: ${reasoning}`);
   modelBits.push(yolo ? "auto-run" : "approve");
 
   const up = model.totalPromptTokens;
@@ -152,7 +154,7 @@ function footerLines(agent, model, yolo) {
 
   return [
     C.dim(rule),
-    C.cyan(repoLabel()) + "    " + C.dim(modelBits.join("  ")),
+    modeTag + "  " + C.cyan(repoLabel()) + "    " + C.dim(modelBits.join("  ")) + "    " + C.dim("opt+←→ model · opt+↑↓ reason · tab: mode"),
     C.dim(usage),
   ];
 }
@@ -162,6 +164,57 @@ const PROMPT_PREFIX = C.green("› ");        // live input row (minimal)
 const HISTORY_PREFIX = C.green("you › ");   // echoed into transcript/history
 const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 
+/**
+ * Recognize an Option/Alt + arrow key from a terminal input string.
+ * Returns "up" | "down" | "left" | "right" | null.
+ *
+ * Terminals encode these differently:
+ *   - xterm modifier form: ESC[1;3A/B/C/D  (3 = Alt/Option)
+ *   - meta word-move (iTerm2 default): ESC b (left word) / ESC f (right word)
+ *   - some send ESC ESC[A.. (double-ESC) for Alt+arrow
+ * When `latched` is true the leading ESC may already have been consumed, so we
+ * also accept the tails without the leading ESC.
+ */
+function matchOptionArrow(s, latched = false) {
+  const arrows = { A: "up", B: "down", C: "right", D: "left" };
+  // xterm modifier form with Alt (mod code 3) or Meta (mod code 9).
+  let m = s.match(/^\x1b\[1;(?:3|9)([ABCD])$/);
+  if (m) return arrows[m[1]];
+  // Double-ESC form: ESC ESC [ A..
+  m = s.match(/^\x1b\x1b\[([ABCD])$/);
+  if (m) return arrows[m[1]];
+  // Meta word-move: ESC b / ESC f -> treat as left/right (model cycling).
+  if (s === "\x1bb") return "left";
+  if (s === "\x1bf") return "right";
+  if (latched) {
+    // Leading ESC already latched; match the tail we reconstructed as ESC+tail.
+    m = s.match(/^\x1b\[1;(?:3|9)([ABCD])$/); // (handled above, kept for clarity)
+    if (m) return arrows[m[1]];
+    if (s === "\x1bb") return "left";
+    if (s === "\x1bf") return "right";
+  }
+  return null;
+}
+
+/** Read the model's current reasoning-effort level ("off" when unset). */
+function currentReasoning(model) {
+  const eff = model.modelKwargs?.reasoning_effort || model.modelKwargs?.reasoning?.effort;
+  return eff || "off";
+}
+
+/** Apply a reasoning-effort level to the live model's request kwargs. */
+function setReasoning(model, level) {
+  model.modelKwargs = { ...(model.modelKwargs || {}) };
+  const l = String(level || "").toLowerCase();
+  if (!l || l === "off" || l === "none" || l === "disabled") {
+    delete model.modelKwargs.reasoning_effort;
+    delete model.modelKwargs.reasoning;
+  } else {
+    model.modelKwargs.reasoning_effort = l;
+    delete model.modelKwargs.reasoning;
+  }
+}
+
 /**
  * A bottom-anchored screen: conversation output scrolls in the top region
  * (bounded by a DECSTBM scroll margin) while the footer + input prompt stay
@@ -189,8 +242,7 @@ class Screen {
     this._onResize = this._onResize.bind(this);
   }
 
-  get rows() { return this.out.rows || 24; }
-  // Footer block (4 rows) pinned to the bottom: divider, prompt, repo/model, usage.
+  get rows() { return this.out.rows || 24; }  // Footer block (4 rows) pinned to the bottom: divider, prompt, repo/model, usage.
   get reserved() { return FOOTER_LINES + 1; } // +1 for the prompt row
   get scrollBottom() { return Math.max(1, this.rows - this.reserved); } // last scrollable row
   get footerTop() { return this.scrollBottom + 1; } // divider row
@@ -216,6 +268,12 @@ class Screen {
     this.out.write(`\x1b[${this.rows};1H\n`);    // move below footer
   }
 
+  /** Cancel any pending lone-ESC latch/timer. */
+  _clearEscLatch() {
+    this._pendingEsc = false;
+    clearTimeout(this._escTimer);
+  }
+
   /** Write a block of text into the scrolling region (may contain newlines). */
   log(text) {
     this.out.write(`\x1b[${this.scrollBottom};1H`); // park at bottom of scroll area
@@ -312,6 +370,86 @@ class Screen {
   }
 
   _onData(chunk) {
+    const s = chunk.toString();
+    // Optional key debug: set ASTRA_KEYDEBUG=1 to print the raw bytes of every
+    // keypress into the transcript. Use it to discover what your terminal
+    // actually sends for Option/Alt+Tab, then report it.
+    if (process.env.ASTRA_KEYDEBUG && this.log) {
+      const bytes = Array.from(chunk).map((b) => "0x" + b.toString(16).padStart(2, "0")).join(" ");
+      this.log(`\x1b[35m[keydebug] ${bytes}\x1b[0m`);
+    }
+    // --- Key sequences: mode toggle, model/reasoning cycling, Esc-to-clear ---
+    //
+    // Mode toggle: Alt/Option+Tab is delivered as ESC+Tab ("\x1b\t"); Shift+Tab
+    // ("\x1b[Z") is a reliable fallback. Model/reasoning cycling uses Option +
+    // arrow keys. A bare Esc (nothing following it) clears the input line.
+    //
+    // Because some terminals split escape sequences across reads (a lone ESC,
+    // then the rest), we latch a lone ESC briefly. If a Tab follows -> toggle;
+    // if nothing follows within the window -> treat it as bare Esc (clear).
+
+    // Whole-chunk fast paths first.
+    if (this.onToggleMode && (s === "\x1b\t" || s === "\x1b[Z")) {
+      this._clearEscLatch();
+      this.onToggleMode();
+      return;
+    }
+    {
+      const opt = matchOptionArrow(s, false);
+      if (opt) {
+        this._clearEscLatch();
+        if ((opt === "left" || opt === "right") && this.onCycleModel) {
+          this.onCycleModel(opt === "right" ? 1 : -1);
+          return;
+        }
+        if ((opt === "up" || opt === "down") && this.onCycleReasoning) {
+          this.onCycleReasoning(opt === "up" ? 1 : -1);
+          return;
+        }
+        return; // recognized an option-arrow we don't act on; swallow it
+      }
+    }
+
+    // A Tab following a latched ESC -> mode toggle (split Alt+Tab delivery).
+    if (this._pendingEsc && s === "\t" && this.onToggleMode) {
+      this._clearEscLatch();
+      this.onToggleMode();
+      return;
+    }
+    // A latched ESC followed by an arrow tail (e.g. "[C", "b", "f") -> option-arrow.
+    if (this._pendingEsc) {
+      const opt = matchOptionArrow("\x1b" + s, true);
+      if (opt) {
+        this._clearEscLatch();
+        if ((opt === "left" || opt === "right") && this.onCycleModel) {
+          this.onCycleModel(opt === "right" ? 1 : -1);
+          return;
+        }
+        if ((opt === "up" || opt === "down") && this.onCycleReasoning) {
+          this.onCycleReasoning(opt === "up" ? 1 : -1);
+          return;
+        }
+        return;
+      }
+      // Any other input right after a latched ESC cancels the latch and is
+      // processed normally below.
+      this._clearEscLatch();
+    }
+
+    // A lone ESC: latch briefly to disambiguate from split escape sequences.
+    // If nothing arrives, the timer treats it as a bare Esc and clears input.
+    if (s === "\x1b") {
+      this._pendingEsc = true;
+      clearTimeout(this._escTimer);
+      this._escTimer = setTimeout(() => {
+        this._pendingEsc = false;
+        if (this.onClearInput) this.onClearInput();
+        this.buf = "";
+        this.drawPrompt();
+      }, 60);
+      return;
+    }
+
     for (const ch of chunk) {
       if (ch === "\r" || ch === "\n") {
         // Collapse a CRLF pair into one Enter: ignore a \n right after a \r.
@@ -370,24 +508,32 @@ Interactive commands:
   /history         print the message history
   /tokens          show token usage so far
   /yolo            toggle auto-run of commands (no confirmation)
+
+Keyboard shortcuts:
+  alt/opt+tab      switch agent / bench mode (shift+tab also works)
+  opt+left/right   cycle the model
+  opt+up/down      cycle reasoning effort (off/low/medium/high)
+  esc              clear the input line
 `;
 
 /**
  * Run the interactive loop against a prepared Agent.
  * @param {Agent} agent  a started (or restored) agent in interactive mode
- * @param {object} opts  { model, autoRun }
+ * @param {object} opts  { model, autoRun, fresh, reasoning, runBench }
+ *   runBench(taskText, log) => Promise  optional; invoked when the user submits
+ *     a message while the REPL is toggled to bench mode. Should run the task in
+ *     an isolated bench workspace and record metrics.
  */
-export async function runRepl(agent, { model, autoRun = false, fresh = true } = {}) {
+export async function runRepl(agent, { model, autoRun = false, fresh = true, reasoning = "", runBench = null } = {}) {
   let yolo = autoRun;
   const tty = !!process.stdout.isTTY && !!process.stdin.isTTY;
 
   const intro = fresh
     ? bannerLines({ session: agent.sessionId })
     : [C.dim(`[astra] resumed session ${agent.sessionId} · model=${model.model}`)];
-  intro.push(C.dim(`Type a request, or /help. Commands ${yolo ? "auto-run" : "need approval"}.`));
 
   if (tty) {
-    await runStickyRepl(agent, model, yolo, intro);
+    await runStickyRepl(agent, model, yolo, intro, { runBench });
   } else {
     for (const line of intro) console.error(line);
     await runPlainRepl(agent, model, yolo);
@@ -395,10 +541,40 @@ export async function runRepl(agent, { model, autoRun = false, fresh = true } =
 }
 
 /** Sticky bottom-anchored REPL (real terminals). */
-async function runStickyRepl(agent, model, yolo, intro = []) {
+async function runStickyRepl(agent, model, yolo, intro = [], { runBench = null } = {}) {
   const screen = new Screen();
   const log = (text) => screen.log(text);
-  const refresh = () => screen.refresh(footerLines(agent, model, yolo));
+  let mode = "agent"; // "agent" | "bench"
+  const refresh = () => screen.refresh(footerLines(agent, model, yolo, mode));
+
+  // Alt/Option+Tab (or Shift+Tab) toggles between agent and bench mode.
+  screen.onToggleMode = () => {
+    mode = mode === "agent" ? "bench" : "agent";
+    refresh();
+  };
+
+  // Option+Left/Right cycles the model; Option+Up/Down cycles reasoning effort.
+  // Changes apply to the live model and are cached as the preferred agent
+  // prefs so the next `astra` launch reuses them.
+  screen.onCycleModel = (dir) => {
+    const list = AVAILABLE_MODELS;
+    const cur = list.indexOf(model.model);
+    const next = ((cur === -1 ? 0 : cur) + dir + list.length) % list.length;
+    model.model = list[next];
+    saveAgentPrefs({ model: model.model });
+    refresh();
+  };
+  screen.onCycleReasoning = (dir) => {
+    const list = REASONING_LEVELS;
+    const cur = list.indexOf(currentReasoning(model));
+    const next = ((cur === -1 ? 0 : cur) + dir + list.length) % list.length;
+    setReasoning(model, list[next]);
+    saveAgentPrefs({ reasoning: list[next] });
+    refresh();
+  };
+  // Bare Esc clears the current input line (handled by the screen; nothing
+  // extra needed here, but expose a hook for symmetry / future use).
+  screen.onClearInput = () => {};
 
   // Approval gate: show the command, then ask for y/n/a on the prompt row.
   agent.confirm = async (command) => {
@@ -436,6 +612,27 @@ async function runStickyRepl(agent, model, yolo, intro = []) {
 
       const before = usageSnapshot(model);
       const t0 = Date.now();
+
+      // Bench mode: run the message as an autonomous task in an isolated
+      // workspace, record metrics, then drop back to agent mode.
+      if (mode === "bench") {
+        if (!runBench) {
+          log(C.red("[astra] bench runner unavailable in this session."));
+          mode = "agent"; refresh(); continue;
+        }
+        screen.startBusy("benching");
+        try {
+          await runBench(line, log);
+        } catch (err) {
+          log(C.red(`[astra] bench failed: ${err?.message || err}`));
+        } finally {
+          screen.stopBusy();
+        }
+        mode = "agent";
+        refresh();
+        continue;
+      }
+
       agent.addUserMessage(line);
       screen.startBusy("working");
       try {