@hackerrank/astra-cli 0.1.25 → 0.1.27

package/README.md

@@ -82,6 +82,8 @@ astra -m claude-sonnet-5 -y         # auto-run commands (no prompts)
 
 In-REPL commands: `/help /plan <task> /exit /clear /history /tokens /yolo`.
 
+Keyboard shortcuts: `Shift+Return` (or `Opt+Return`) for multi-line input, `Alt/Opt+Tab` to toggle bench mode, `Opt+Left/Right` to cycle models, `Opt+Up/Down` to cycle reasoning effort, `Esc` to clear input.
+
 ### Autonomous task run
 
 When you pass a task with `-t`/`-f`, astra appends the autonomous rules and runs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hackerrank/astra-cli",
-  "version": "0.1.25",
+  "version": "0.1.27",
   "description": "Minimal zero-dependency AI coding agent for the HackerRank AI Gateway.",
   "type": "module",
   "bin": {

package/src/repl.js

@@ -159,7 +159,7 @@ function footerLines(agent, model, yolo, mode = "agent") {
     C.dim(rule),
     modeTag + "  " + C.cyan(repoLabel()) + "    " + C.dim(modelBits.join("  ")),
     C.dim(usage),
-    C.dim("opt+left/right: model  ·  opt+up/down: reasoning  ·  shift+tab: mode"),
+    C.dim("shift+return: newline  ·  opt+left/right: model  ·  opt+up/down: reasoning  ·  shift+tab: mode"),
   ];
 }
 
@@ -219,19 +219,76 @@ function setReasoning(model, level) {
   }
 }
 
+/** Strip ANSI color/style escape codes to calculate visual string lengths. */
+export function stripAnsi(str) {
+  return String(str || "").replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+}
+
+/**
+ * Break an input buffer (with potential newlines and line wraps) into
+ * visual lines suitable for terminal display.
+ */
+export function computeVisualLines(buf, promptPrefix, cols = 80) {
+  const logicalLines = String(buf || "").split("\n");
+  const visualLines = [];
+  const prefixVisible = stripAnsi(promptPrefix);
+  const contPrefix = "  ";
+  const contPrefixVisible = "  ";
+
+  for (let i = 0; i < logicalLines.length; i++) {
+    const p = i === 0 ? promptPrefix : contPrefix;
+    const pVis = i === 0 ? prefixVisible : contPrefixVisible;
+    const line = logicalLines[i];
+    const full = p + line;
+    const fullVis = pVis + line;
+
+    if (fullVis.length <= cols || cols <= 0) {
+      visualLines.push({ text: full, visibleLength: fullVis.length });
+    } else {
+      let remaining = line;
+      let first = true;
+      while (remaining.length > 0 || first) {
+        const currentP = first ? p : contPrefix;
+        const currentPVis = first ? pVis : contPrefixVisible;
+        const availableWidth = Math.max(1, cols - currentPVis.length);
+        const take = remaining.slice(0, availableWidth);
+        remaining = remaining.slice(availableWidth);
+        visualLines.push({ text: currentP + take, visibleLength: currentPVis.length + take.length });
+        first = false;
+        if (remaining.length === 0) break;
+      }
+    }
+  }
+  return visualLines.length > 0 ? visualLines : [{ text: promptPrefix, visibleLength: prefixVisible.length }];
+}
+
+/** Check if an escape sequence or key code is a newline-insertion shortcut (Shift+Enter, Option+Enter, etc.). */
+export function isNewlineKey(s, pendingEsc = false) {
+  if (!s || typeof s !== "string") return false;
+  if (/^\x1b\[(?:13|10);[2-8]u$/.test(s)) return true;
+  if (/^\x1b\[27;[2-8];(?:13|10)~$/.test(s)) return true;
+  if (/^\x1b\[(?:13|10);[2-8]~$/.test(s)) return true;
+  if (s === "\x1bOM") return true;
+  if (s === "\x1b\r" || s === "\x1b\n" || s === "\x1b\x0d") return true;
+  if (pendingEsc && (s === "\r" || s === "\n" || s === "\x0d" || s === "\x0a")) return true;
+  if (s === "\x0a" || s === "\n") return true;
+  return false;
+}
+
 /**
  * A bottom-anchored screen: conversation output scrolls in the top region
  * (bounded by a DECSTBM scroll margin) while the footer + input prompt stay
  * glued to the terminal's bottom rows. Input is read via raw keypresses (not
- * readline) so nothing fights the scroll margin. Requires a TTY; callers use
- * the readline fallback otherwise.
+ * readline) so nothing fights the scroll margin. Multi-line input and wrapped
+ * typing adjust the scroll margin dynamically to prevent overwriting status
+ * lines or history. Requires a TTY; callers use the readline fallback otherwise.
  */
-class Screen {
+export class Screen {
   constructor(out = process.stdout, inp = process.stdin) {
     this.out = out;
     this.inp = inp;
     this.footer = [];
-    this.buf = "";       // current input line
+    this.buf = "";       // current input buffer (can contain newlines)
     this.resolve = null;  // pending readLine() resolver
     this._lastWasCR = false;
     this._guardEnterUntil = 0;  // ignore stray Enter until this timestamp
@@ -241,21 +298,39 @@ class Screen {
     this._busyFrame = 0;
     this._busyLabel = "working";
     this._busyResume = false;
+    this._prevScrollBottom = 0;
+    this._prevFooterTop = 0;
+    this._inPaste = false;
     this.promptLabel = PROMPT_PREFIX;
     this._onData = this._onData.bind(this);
     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 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
-  get promptRow() { return this.footerTop + 1; }    // input row: right under the divider
+  get cols() { return this.out.columns || 80; }
+  get rows() { return this.out.rows || 24; }
+
+  get promptLines() {
+    if (this._busy) return 1;
+    const visual = computeVisualLines(this.buf, this.promptLabel || PROMPT_PREFIX, this.cols);
+    const maxLines = Math.max(1, Math.floor((this.rows - FOOTER_LINES) / 2));
+    return Math.min(visual.length, maxLines);
+  }
+
+  get reserved() { return FOOTER_LINES + this.promptLines; }
+  get scrollBottom() { return Math.max(1, this.rows - this.reserved); }
+  get footerTop() { return this.scrollBottom + 1; }
+  get promptRow() { return this.footerTop + 1; }
+  get statusStartRow() { return this.promptRow + this.promptLines; }
 
   /** Enter sticky mode: set scroll margin, park cursor, start listening. */
   enter() {
+    this._prevScrollBottom = this.scrollBottom;
+    this._prevFooterTop = this.footerTop;
     this.out.write(`\x1b[1;${this.scrollBottom}r`);     // scroll region = top area
     this.out.write(`\x1b[${this.scrollBottom};1H`);      // cursor at bottom of scroll area
+    this.out.write("\x1b[?2004h"); // enable bracketed paste mode
+    this.out.write("\x1b[>4;2m");  // enable modifyOtherKeys
+    this.out.write("\x1b[=1u");   // enable kitty keyboard protocol
     if (this.inp.isTTY) this.inp.setRawMode(true);
     this.inp.resume();
     this.inp.setEncoding("utf8");
@@ -268,6 +343,9 @@ class Screen {
     this.inp.off("data", this._onData);
     this.out.off("resize", this._onResize);
     if (this.inp.isTTY) this.inp.setRawMode(false);
+    this.out.write("\x1b[>4;0m");  // disable modifyOtherKeys
+    this.out.write("\x1b[=0u");   // disable kitty keyboard protocol
+    this.out.write("\x1b[?2004l"); // disable bracketed paste mode
     this.out.write("\x1b[r");                    // reset scroll region
     this.out.write(`\x1b[${this.rows};1H\n`);    // move below footer
   }
@@ -281,41 +359,78 @@ class Screen {
   /** 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
-    this.out.write(String(text) + "\n");            // trailing \n scrolls the region
-    this.drawFooter();
-    this.drawPrompt();
+    const formatted = String(text).replace(/\r?\n/g, "\r\n") + "\r\n";
+    this.out.write(formatted);
+    this.redraw();
   }
 
   /** Redraw the pinned footer + prompt (e.g. when usage changes). */
   refresh(footer) {
     if (footer) this.footer = footer;
-    this.drawFooter();
-    this.drawPrompt();
+    this.redraw();
   }
 
-  drawFooter() {
+  /** Unified redraw of footer divider, multi-line prompt, and status lines without overwriting. */
+  redraw() {
+    if (this._prevScrollBottom !== this.scrollBottom) {
+      this.out.write(`\x1b[1;${this.scrollBottom}r`);
+      this._prevScrollBottom = this.scrollBottom;
+    }
+
     this.out.write("\x1b[s"); // save cursor
-    // footer[0] = divider (row footerTop), footer[1..] = status lines that go
-    // BELOW the prompt row (footerTop+1). So skip the prompt row when placing
-    // the status lines.
-    this.out.write(`\x1b[${this.footerTop};1H\x1b[2K`);
-    this.out.write(this.footer[0] || "");           // divider
-    for (let i = 1; i < FOOTER_LINES; i++) {
-      const row = this.promptRow + i;               // status lines under the prompt
-      this.out.write(`\x1b[${row};1H\x1b[2K`);
-      this.out.write(this.footer[i] || "");
+
+    // Clear only from footerTop down to terminal bottom
+    for (let r = this.footerTop; r <= this.rows; r++) {
+      this.out.write(`\x1b[${r};1H\x1b[2K`);
     }
-    this.out.write("\x1b[u"); // restore cursor
-  }
 
-  drawPrompt() {
-    this.out.write(`\x1b[${this.promptRow};1H\x1b[2K`);
+    // Draw top divider rule at footerTop
+    this.out.write(`\x1b[${this.footerTop};1H`);
+    this.out.write(this.footer[0] || "");
+
+    // Draw prompt (or busy spinner)
     if (this._busy) {
+      this.out.write(`\x1b[${this.promptRow};1H`);
       const frame = SPINNER_FRAMES[this._busyFrame % SPINNER_FRAMES.length];
       this.out.write(C.cyan(frame + " ") + C.dim(this._busyLabel + "…"));
-      return;
+    } else {
+      const visual = computeVisualLines(this.buf, this.promptLabel || PROMPT_PREFIX, this.cols);
+      const visibleLines = visual.slice(-this.promptLines);
+      for (let i = 0; i < visibleLines.length; i++) {
+        const row = this.promptRow + i;
+        this.out.write(`\x1b[${row};1H`);
+        this.out.write(visibleLines[i].text);
+      }
     }
-    this.out.write((this.promptLabel || PROMPT_PREFIX) + this.buf);
+
+    // Draw status lines below the prompt
+    for (let i = 1; i < FOOTER_LINES; i++) {
+      const row = this.statusStartRow + i - 1;
+      if (row <= this.rows) {
+        this.out.write(`\x1b[${row};1H`);
+        this.out.write(this.footer[i] || "");
+      }
+    }
+
+    // Place cursor at the end of input
+    if (!this._busy) {
+      const visual = computeVisualLines(this.buf, this.promptLabel || PROMPT_PREFIX, this.cols);
+      const visibleLines = visual.slice(-this.promptLines);
+      const lastLine = visibleLines[visibleLines.length - 1] || { visibleLength: 0 };
+      const cursorRow = this.promptRow + (visibleLines.length - 1);
+      const cursorCol = Math.min(this.cols, lastLine.visibleLength + 1);
+      this.out.write(`\x1b[${cursorRow};${cursorCol}H`);
+    } else {
+      this.out.write("\x1b[u"); // restore cursor
+    }
+  }
+
+  drawFooter() {
+    this.redraw();
+  }
+
+  drawPrompt() {
+    this.redraw();
   }
 
   /** Start the minimal loading state on the prompt row. */
@@ -323,11 +438,11 @@ class Screen {
     this._busy = true;
     this._busyLabel = label;
     this._busyFrame = 0;
-    this.drawPrompt();
+    this.redraw();
     if (this._busyTimer) clearInterval(this._busyTimer);
     this._busyTimer = setInterval(() => {
       this._busyFrame++;
-      this.drawPrompt();
+      this.redraw();
     }, 90);
     if (this._busyTimer.unref) this._busyTimer.unref();
   }
@@ -337,7 +452,7 @@ class Screen {
     if (this._busyTimer) { clearInterval(this._busyTimer); this._busyTimer = null; }
     this._busy = false;
     this._busyResume = false;
-    this.drawPrompt();
+    this.redraw();
   }
 
   /** True while the agent is working (a turn is in progress). */
@@ -349,16 +464,9 @@ class Screen {
    * Resolve with the next full line the user types. An optional prompt label
    * replaces the default "you › " (used by the approval gate so the question
    * is shown right where the user is typing).
-   *
-   * `opts.guardEnter` ignores a bare Enter that lands within a short window of
-   * the prompt appearing. This prevents a stray newline still in the input
-   * buffer (from the previous line, a CRLF pair, or a paste) from instantly
-   * "answering" a confirmation prompt the user never actually saw.
    */
   readLine(promptLabel, opts = {}) {
     return new Promise((res) => {
-      // A prompt (main input or approval) takes over the row; pause the spinner
-      // timer but remember whether we were busy so we can resume after.
       this._busyResume = this._busy;
       if (this._busyTimer) { clearInterval(this._busyTimer); this._busyTimer = null; }
       this._busy = false;
@@ -367,37 +475,50 @@ class Screen {
       this.resolve = res;
       this._guardEnterUntil = opts.guardEnter ? Date.now() + 250 : 0;
       this._echoOnCommit = opts.echo !== false;
-      this.drawPrompt();
+      this.redraw();
     });
   }
 
   _onResize() {
-    this.out.write(`\x1b[1;${this.scrollBottom}r`);
-    this.footer = this.footer; // caller refreshes content separately
-    this.drawFooter();
-    this.drawPrompt();
+    this.redraw();
   }
 
   _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.
+
+    // Bracketed paste handling (pasting multi-line blocks into the input)
+    let str = s;
+    if (str.includes("\x1b[200~") || this._inPaste) {
+      if (str.includes("\x1b[200~")) {
+        this._inPaste = true;
+        str = str.slice(str.indexOf("\x1b[200~") + 6);
+      }
+      if (str.includes("\x1b[201~")) {
+        const end = str.indexOf("\x1b[201~");
+        const pasted = str.slice(0, end);
+        this.buf += pasted.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+        this._inPaste = false;
+        this.redraw();
+        return;
+      }
+      this.buf += str.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+      this.redraw();
+      return;
+    }
+
+    // Newline insertion shortcut (Shift+Enter, Option+Enter, Alt+Enter, Ctrl+Enter, Esc+Enter)
+    if (isNewlineKey(s, this._pendingEsc)) {
+      this._clearEscLatch();
+      this.buf += "\n";
+      this.redraw();
+      return;
+    }
+
+    // Mode toggle: Alt/Option+Tab or Shift+Tab
     if (this.onToggleMode && (s === "\x1b\t" || s === "\x1b[Z")) {
       this._clearEscLatch();
       this.onToggleMode();
@@ -415,17 +536,17 @@ class Screen {
           this.onCycleReasoning(opt === "up" ? 1 : -1);
           return;
         }
-        return; // recognized an option-arrow we don't act on; swallow it
+        return;
       }
     }
 
-    // A Tab following a latched ESC -> mode toggle (split Alt+Tab delivery).
+    // A Tab following a latched ESC -> mode toggle
     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.
+    // A latched ESC followed by an arrow tail -> option-arrow
     if (this._pendingEsc) {
       const opt = matchOptionArrow("\x1b" + s, true);
       if (opt) {
@@ -440,13 +561,10 @@ class Screen {
         }
         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.
+    // A lone ESC: latch briefly to disambiguate from split escape sequences
     if (s === "\x1b") {
       this._pendingEsc = true;
       clearTimeout(this._escTimer);
@@ -454,19 +572,15 @@ class Screen {
         this._pendingEsc = false;
         if (this.onClearInput) this.onClearInput();
         this.buf = "";
-        this.drawPrompt();
+        this.redraw();
       }, 60);
       return;
     }
 
-    for (const ch of chunk) {
+    for (const ch of s) {
       if (ch === "\r" || ch === "\n") {
-        // Collapse a CRLF pair into one Enter: ignore a \n right after a \r.
         if (ch === "\n" && this._lastWasCR) { this._lastWasCR = false; continue; }
         this._lastWasCR = ch === "\r";
-        // Guard: ignore a bare Enter (empty buffer) that arrives immediately
-        // after a guarded prompt was shown. This stops a leftover newline from
-        // auto-resolving a confirmation the user never got to answer.
         if (
           this.buf === "" &&
           this._guardEnterUntil &&
@@ -474,30 +588,25 @@ class Screen {
         ) {
           continue;
         }
-        const line = this.buf;
+        const text = this.buf;
         this.buf = "";
-        // Echo the committed line into the scroll area for a transcript.
-        // User input is echoed with the "you › " history prefix; approval
-        // prompts pass echo:false so their Q&A stays out of the transcript.
-        // Empty input is skipped so a bare Enter doesn't stack blank lines.
-        if (this._echoOnCommit && line.trim() !== "") {
+        if (this._echoOnCommit && text.trim() !== "") {
           const isUserPrompt = (this.promptLabel || PROMPT_PREFIX) === PROMPT_PREFIX;
-          this.log((isUserPrompt ? HISTORY_PREFIX : this.promptLabel) + line);
+          const prefix = isUserPrompt ? HISTORY_PREFIX : this.promptLabel;
+          const lines = text.split("\n");
+          for (let i = 0; i < lines.length; i++) {
+            this.log((i === 0 ? prefix : "      ") + lines[i]);
+          }
         }
         this.promptLabel = PROMPT_PREFIX;
         this._echoOnCommit = true;
-        // Resume the loading state if a turn is still in progress (e.g. after
-        // an approval prompt hands control back to the running agent).
         if (this._busyResume) { this._busyResume = false; this.startBusy(this._busyLabel); }
         const r = this.resolve; this.resolve = null;
-        if (r) r(line);
+        if (r) r(text);
       } else if (ch === "\x7f" || ch === "\b") {  // backspace
         this.buf = this.buf.slice(0, -1);
-        this.drawPrompt();
+        this.redraw();
       } else if (ch === "\x03") {                  // Ctrl+C
-        // If a prompt is pending (idle), resolve it so the loop can react.
-        // Also always notify the interrupt hook so a *running* agent turn can
-        // be aborted even when no readLine is pending.
         const r = this.resolve; this.resolve = null;
         if (r) r("__SIGINT__");
         if (this.onInterrupt) this.onInterrupt();
@@ -507,7 +616,7 @@ class Screen {
       } else if (ch >= " ") {                       // printable
         this._lastWasCR = false;
         this.buf += ch;
-        this.drawPrompt();
+        this.redraw();
       }
     }
   }
@@ -524,6 +633,7 @@ Interactive commands:
   /yolo            toggle auto-run of commands (no confirmation)
 
 Keyboard shortcuts:
+  shift+return     insert a newline for multi-line input (alt/opt+enter also works)
   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)