micro-models-agent 0.63.3 → 1.1.0

package/dist/ui/line-editor.js

@@ -29,6 +29,12 @@ export class LineEditor {
     questionCb = null;
     rawMode = false;
     listeners = {};
+    /** stdin handlers registered in the constructor — removed in close() so
+     *  re-creating the editor never accumulates stale listeners. */
+    dsrDataHandler;
+    keypressHandler;
+    dataHandler;
+    endHandler;
     /** Visual row (within the drawn frame) where the cursor was placed by the
      *  last render — fallback for moving back to the frame's first row before
      *  redrawing when no absolute anchor is known yet. Relative moves break
@@ -46,6 +52,18 @@ export class LineEditor {
     dsrPending = false;
     /** Buffer for partial DSR escape sequences split across data chunks. */
     dsrTail = "";
+    /** Visual row of the cursor at the exact moment the outstanding DSR query
+     *  was sent. The reply is matched against this, not `prevCursorRow`, which
+     *  later renders overwrite while the query is still pending. */
+    dsrQueryRow = 0;
+    /** When false, keystrokes are ignored (except Ctrl+C) while the agent
+     *  streams — the host owns the terminal during that phase. */
+    inputEnabled = true;
+    /** While true the prompt frame is not drawn; the agent owns the screen. */
+    frameSuspended = false;
+    /** Clears `dsrPending` when no DSR reply arrives, falling back to
+     *  relative cursor moves instead of wedging on a broken terminal. */
+    dsrTimer = null;
     constructor(opts) {
         this.input = opts.input;
         this.output = opts.output;
@@ -65,13 +83,19 @@ export class LineEditor {
             // Raw data listener for DSR cursor-position replies. Runs alongside
             // readline's keypress emitter (both receive every chunk); replies may
             // arrive merged with regular keystrokes, hence the global regex.
-            this.input.on("data", (buf) => this.consumeDsrReplies(buf.toString("utf-8")));
+            this.dsrDataHandler = (buf) => this.consumeDsrReplies(buf.toString("utf-8"));
+            this.input.on("data", this.dsrDataHandler);
             readline.emitKeypressEvents(this.input);
-            this.input.on("keypress", (str, key) => this.onKey(str, key));
+            this.keypressHandler = (str, key) => this.onKey(str, key);
+            this.input.on("keypress", this.keypressHandler);
+            // The editor owns stdin now: ensure it is flowing even if a previous
+            // consumer paused it (e.g. the setup wizard).
+            this.input.resume?.();
         }
         else {
-            this.input.on("data", (buf) => this.onData(buf));
-            this.input.on("end", () => {
+            this.dataHandler = (buf) => this.onData(buf);
+            this.input.on("data", this.dataHandler);
+            this.endHandler = () => {
                 const last = this.lines.join("\n");
                 this.lines = [""];
                 this.row = 0;
@@ -79,7 +103,8 @@ export class LineEditor {
                 if (last)
                     this.emitLine(last);
                 this.emitClose();
-            });
+            };
+            this.input.on("end", this.endHandler);
         }
     }
     on(event, listener) {
@@ -103,6 +128,61 @@ export class LineEditor {
     write(s) {
         this.insertText(s);
     }
+    setInputEnabled(enabled) {
+        this.inputEnabled = enabled;
+    }
+    isInputEnabled() {
+        return this.inputEnabled;
+    }
+    isFrameSuspended() {
+        return this.frameSuspended;
+    }
+    /** Clear the prompt frame (the agent takes over the terminal) and stop
+     *  rendering until `resumeFrame()`. */
+    suspendFrame() {
+        if (!this.input.isTTY || this.isDone)
+            return;
+        const out = [];
+        if (this.frameTopAbs !== null)
+            out.push(`\x1b[${this.frameTopAbs};1H`);
+        else if (this.prevCursorRow > 0)
+            out.push(`\x1b[${this.prevCursorRow}A`);
+        out.push("\r\x1b[J");
+        this.output.write(out.join(""));
+        this.invalidateAnchor();
+        this.frameSuspended = true;
+    }
+    /** Restore the frame after streaming. */
+    resumeFrame() {
+        this.frameSuspended = false;
+        this.invalidateAnchor();
+        this.render();
+    }
+    /** Print a block of lines above the current prompt frame without erasing
+     *  the input buffer. When the frame is suspended the block is printed in
+     *  place and the suspension is preserved. */
+    printAbove(text) {
+        if (!this.input.isTTY || this.isDone) {
+            this.output.write(text.endsWith("\n") ? text : `${text}\n`);
+            return;
+        }
+        const wasSuspended = this.frameSuspended;
+        this.frameSuspended = false;
+        const out = [];
+        if (this.frameTopAbs !== null)
+            out.push(`\x1b[${this.frameTopAbs};1H`);
+        else if (this.prevCursorRow > 0)
+            out.push(`\x1b[${this.prevCursorRow}A`);
+        out.push("\r\x1b[J");
+        out.push(text.replace(/\r\n/g, "\n").replace(/\n$/, "").split("\n").join("\r\n"));
+        out.push("\r\n");
+        this.output.write(out.join(""));
+        this.invalidateAnchor();
+        if (wasSuspended)
+            this.frameSuspended = true;
+        else
+            this.render();
+    }
     reset() {
         this.lines = [""];
         this.row = 0;
@@ -128,9 +208,22 @@ export class LineEditor {
             return;
         this.isDone = true;
         this.disableTerminalProtocols();
+        const inp = this.input;
+        if (this.dsrDataHandler)
+            inp.removeListener("data", this.dsrDataHandler);
+        if (this.keypressHandler)
+            inp.removeListener("keypress", this.keypressHandler);
+        if (this.dataHandler)
+            inp.removeListener("data", this.dataHandler);
+        if (this.endHandler)
+            inp.removeListener("end", this.endHandler);
         if (this.rawMode && this.input.setRawMode) {
             this.input.setRawMode(false);
         }
+        if (this.dsrTimer) {
+            clearTimeout(this.dsrTimer);
+            this.dsrTimer = null;
+        }
         this.emitClose();
     }
     // ---- input handling ----
@@ -158,6 +251,20 @@ export class LineEditor {
     onKey(str, key) {
         if (this.isDone)
             return;
+        if (!this.inputEnabled) {
+            // While streaming, only interrupt keys are honored: Ctrl+C aborts the
+            // run, Escape is forwarded so the host can implement double-Esc abort.
+            const k = key;
+            if (k?.ctrl && k.name === "c") {
+                this.ctrlC();
+                return;
+            }
+            if (k?.name === "escape") {
+                this.onKeyInput?.(str, key);
+                return;
+            }
+            return;
+        }
         if (this.onKeyInput && this.onKeyInput(str, key))
             return;
         const k = key;
@@ -170,6 +277,12 @@ export class LineEditor {
             }
             return;
         }
+        // Never treat a cursor-position report (`ESC[row;colR`) as typed input:
+        // on some Windows/ConPTY + Bun combinations the trailing "R" leaks into
+        // the buffer and corrupts the answer (observed as every prompt answering
+        // "R"). Swallow the whole sequence.
+        if (/^\x1b\[\d+;\d+R$/.test(seq))
+            return;
         if (name === "paste-start" || seq === "\x1b[200~") {
             this.isPaste = true;
             this.pasteBuffer = "";
@@ -665,7 +778,18 @@ export class LineEditor {
             return;
         }
         if (matches.length === 1) {
-            const from = line.lastIndexOf(partial);
+            // Complete the partial under the CURSOR, not the last occurrence in
+            // the whole line — with the cursor mid-line, lastIndexOf() inserted
+            // at the line's end instead.
+            const chars = Array.from(line);
+            const beforeCursor = chars.slice(0, this.col).join("");
+            let from = beforeCursor.lastIndexOf(partial);
+            if (from === -1)
+                from = line.lastIndexOf(partial);
+            if (from === -1) {
+                this.output.write("\x07");
+                return;
+            }
             const head = line.slice(0, from);
             const tail = line.slice(from + partial.length);
             this.lines[this.row] = head + matches[0] + tail;
@@ -673,9 +797,13 @@ export class LineEditor {
             this.render();
             return;
         }
-        const lines = matches.map((m) => "  " + m);
-        this.output.write("\r\n" + lines.join("\r\n") + "\r\n");
-        this.output.write(`\x1b[${lines.length + 1}A`);
+        const rows = matches.map((m) => "  " + m);
+        this.output.write("\r\n" + rows.join("\r\n") + "\r\n");
+        // The printed list moved the cursor (rows.length + 1) visual rows down
+        // from its frame position. Account for those rows so the next render
+        // redraws the frame in place — otherwise its relative up-move starts
+        // above the frame and paints garbage over the just-printed list.
+        this.prevCursorRow += rows.length + 1;
         this.render();
     }
     clearScreen() {
@@ -696,6 +824,19 @@ export class LineEditor {
         const r = this.output.rows;
         return typeof r === "number" && r > 3 ? r : null;
     }
+    /**
+     * Whether the cursor-position query (`ESC[6n`) may be sent. It is opt-in on
+     * Windows: ConPTY can mis-decode the `ESC[row;colR` reply as typed input,
+     * which corrupts answers (the setup wizard answered every prompt "R").
+     * `MMA_DSR=1` forces it on, `MMA_DSR=0` off; elsewhere it defaults on.
+     */
+    dsrEnabled() {
+        if (process.env.MMA_DSR === "1")
+            return true;
+        if (process.env.MMA_DSR === "0")
+            return false;
+        return process.platform !== "win32";
+    }
     /** Cap the rendered frame to the visible screen. A frame taller than the
      *  terminal cannot be redrawn in place at all (its top scrolls off), so
      *  only the tail is drawn; the absolute anchor keeps the next render
@@ -717,6 +858,10 @@ export class LineEditor {
         this.dsrPending = false;
         this.dsrTail = "";
         this.prevCursorRow = 0;
+        if (this.dsrTimer) {
+            clearTimeout(this.dsrTimer);
+            this.dsrTimer = null;
+        }
     }
     /** Parse `ESC[row;colR` cursor-position replies. Buffers partial escape
      *  sequences across chunks. Accepts at most one reply (the outstanding
@@ -732,17 +877,20 @@ export class LineEditor {
             return;
         this.dsrPending = false;
         const row = Number(m[1]);
-        const idx = Number(m[2]);
-        // idx is not the layout index — it's the column from the reply; ignore it.
-        // We compute frameTop from the reply row minus the cursor's visual row
-        // at query time.  The visual row was stored in `prevCursorRow` when the
-        // query was sent (right after render).
-        const top = row - this.prevCursorRow;
-        if (top >= 1)
+        if (this.dsrTimer) {
+            clearTimeout(this.dsrTimer);
+            this.dsrTimer = null;
+        }
+        // The frame top is the reply row minus the cursor's visual row at query
+        // time. `dsrQueryRow` — not `prevCursorRow` — because intermediate
+        // renders may have advanced the cursor while the query was pending.
+        const top = row - this.dsrQueryRow;
+        const H = this.screenRows();
+        if (top >= 1 && (H === null || top <= H))
             this.frameTopAbs = top;
     }
     render() {
-        if (!this.input.isTTY || this.isDone)
+        if (!this.input.isTTY || this.isDone || this.frameSuspended)
             return;
         const layout = this.visibleLayout();
         const promptWidth = stringWidth(stripAnsi(this.promptStr));
@@ -780,6 +928,7 @@ export class LineEditor {
         if (ccol > 0)
             out.push(`\x1b[${ccol}C`);
         this.output.write(out.join(""));
+        this.prevCursorRow = idx;
         // Deterministic scroll math: update the anchor for the NEXT render.
         // After writing L rows starting from frameTopAbs, if the frame extends
         // past the screen bottom the terminal scrolls; the new frame top is
@@ -794,16 +943,20 @@ export class LineEditor {
                 // else: no scroll, anchor unchanged
             }
         }
-        else if (!this.dsrPending) {
-            // First render after prompt — send exactly ONE DSR query.
-            // Disabled for now: ConPTY may buffer stdout while processing
-            // the DSR reply, hiding agent responses.  Will revisit once
-            // scroll-proof rendering is solved via deterministic tracking.
-            //
-            // this.dsrPending = true;
-            // this.output.write("\x1b[6n");
+        else if (!this.dsrPending && this.questionCb === null && this.dsrEnabled()) {
+            // One DSR query per frame, then the anchor is maintained by local scroll
+            // math. Never queried in question mode (see dsrEnabled). A timeout clears
+            // dsrPending so a non-responding terminal falls back to relative moves.
+            this.dsrPending = true;
+            this.dsrQueryRow = idx;
+            this.output.write("\x1b[6n");
+            if (this.dsrTimer)
+                clearTimeout(this.dsrTimer);
+            this.dsrTimer = setTimeout(() => {
+                this.dsrPending = false;
+                this.dsrTimer = null;
+            }, 150);
         }
-        this.prevCursorRow = idx;
     }
     enableTerminalProtocols() {
         this.output.write("\x1b[?2004h");

package/dist/ui/line-math.js

@@ -15,19 +15,36 @@ export function wrapLine(line, width, firstRowWidth) {
     const rows = [];
     let start = 0;
     let cells = 0;
+    let lastSpaceIdx = -1;
+    let lastSpaceCells = 0;
     for (let i = 0; i < chars.length; i++) {
         const ch = chars[i];
         if (ch === "\n") {
             rows.push({ text: chars.slice(start, i).join(""), charStart: start });
             start = i + 1;
             cells = 0;
+            lastSpaceIdx = -1;
+            lastSpaceCells = 0;
             continue;
         }
         const cw = stringWidth(ch);
+        if (ch === " ") {
+            lastSpaceIdx = i;
+            lastSpaceCells = cells;
+        }
         if (cells + cw > limit && cells > 0) {
-            rows.push({ text: chars.slice(start, i).join(""), charStart: start });
-            start = i;
-            cells = cw;
+            if (lastSpaceIdx > start) {
+                rows.push({ text: chars.slice(start, lastSpaceIdx).join(""), charStart: start });
+                start = lastSpaceIdx + 1;
+                cells = Math.max(0, cells - lastSpaceCells - 1);
+            }
+            else {
+                rows.push({ text: chars.slice(start, i).join(""), charStart: start });
+                start = i;
+                cells = cw;
+            }
+            lastSpaceIdx = -1;
+            lastSpaceCells = 0;
             limit = w;
         }
         else {

package/dist/ui/md-formatter.js

@@ -1,4 +1,5 @@
 import { pc } from "./colors";
+import stringWidth from "string-width";
 import { t } from "../i18n/index";
 import { formatTable, getTerminalWidth } from "./table";
 const KW = /\b(import|export|from|const|let|var|function|return|if|else|for|while|do|switch|case|break|continue|new|class|extends|implements|interface|type|enum|namespace|module|declare|abstract|async|await|yield|throw|try|catch|finally|typeof|instanceof|in|of|as|is|keyof|readonly|static|private|public|protected|get|set|constructor|this|super|void|never|any|unknown|boolean|string|number|symbol|object|true|false|null|undefined|default)\b/g;
@@ -52,10 +53,25 @@ export class FormattingStream {
     codeLines = [];
     tableBuffer = [];
     onWrite;
+    onRawWrite;
     width;
-    constructor(onWrite, width) {
+    /** Display columns of the raw partial currently shown on the terminal. */
+    partialWritten = 0;
+    /** How many chars of the pending line have already been streamed raw. */
+    streamedChars = 0;
+    /** Columns reserved on the left (caller prefix) so a partial never wraps. */
+    reservedCols;
+    /**
+     * Stream the current (not-yet-newline-terminated) line raw for live
+     * feedback. Off by default — offline callers use `formatMarkdown`.
+     */
+    streamPartials;
+    constructor(onWrite, width, onRawWrite, opts = {}) {
         this.onWrite = onWrite;
+        this.onRawWrite = onRawWrite ?? onWrite;
         this.width = width ?? getTerminalWidth();
+        this.reservedCols = opts.reservedCols ?? 0;
+        this.streamPartials = opts.streamPartials ?? false;
     }
     write(chunk) {
         this.buffer += chunk;
@@ -63,27 +79,101 @@ export class FormattingStream {
         while ((idx = this.buffer.indexOf("\n")) !== -1) {
             const line = this.buffer.slice(0, idx);
             this.buffer = this.buffer.slice(idx + 1);
+            this.emitPartialRewind();
             this.processLine(line);
         }
+        if (this.buffer.length > 0 && !this.inCodeBlock) {
+            this.streamPartial();
+        }
     }
-    flush() {
-        if (this.inCodeBlock && this.codeLines.length > 0) {
-            this.emitCodeBlock();
+    /**
+     * Stream the pending line raw for real-time feedback; the formatted line
+     * replaces it once the newline arrives.
+     *
+     * The replacement uses a RELATIVE cursor move (`\x1b[<cols>D`), which is only
+     * correct while the streamed text stays on the single visual line it started
+     * on. If the partial would exceed the terminal width it wraps and every
+     * relative move lands in the wrong place — the garbled output observed after
+     * the 1.0.0 output refactor (missing/swapped characters, leaked markers,
+     * broken tables). So streaming freezes at the last chunk that fits and the
+     * line is rendered when it completes.
+     */
+    streamPartial() {
+        if (!this.streamPartials)
+            return;
+        const available = Math.max(1, this.width - this.reservedCols);
+        if (stringWidth(this.buffer) > available)
+            return;
+        const delta = this.buffer.slice(this.streamedChars);
+        if (!delta)
+            return;
+        this.onRawWrite(delta);
+        this.streamedChars = this.buffer.length;
+        this.partialWritten = stringWidth(this.buffer);
+    }
+    emitPartialRewind() {
+        if (this.partialWritten > 0) {
+            // Move back over the streamed partial and erase any tail left by a
+            // shorter formatted replacement before the caller renders the line.
+            this.onRawWrite(`\x1b[${this.partialWritten}D\x1b[K`);
+            this.partialWritten = 0;
+        }
+        this.streamedChars = 0;
+    }
+    /** True when there is displayed partial output or unprocessed buffered text. @internal */
+    hasPartial() {
+        return this.partialWritten > 0 || this.buffer.length > 0 || this.tableBuffer.length > 0;
+    }
+    /**
+     * Finalize a displayed raw partial so the next write starts on a fresh line.
+     * Only the already-streamed partial is terminated (with a single newline via
+     * `onRawWrite`); any pending table buffer is flushed. An open code block is
+     * intentionally left untouched — closing it here would make the real closing
+     * fence look like a new opening fence and corrupt all following prose. The
+     * code block is emitted by the final `flush()`. Idempotent.
+     */
+    flushPartialNow() {
+        if (this.partialWritten > 0) {
+            // The line is already on screen raw; terminate it as-is (it may be
+            // interrupted mid-markdown) and drop it so it is not rendered twice.
+            this.onRawWrite("\n");
+            this.partialWritten = 0;
+            this.streamedChars = 0;
+            this.buffer = "";
+        }
+        else if (this.buffer.length > 0 && !this.inCodeBlock) {
+            // Never streamed (plain mode) — render the pending line now.
+            const line = this.buffer;
+            this.buffer = "";
+            this.streamedChars = 0;
+            this.onWrite(this.formatLine(line));
         }
         if (this.tableBuffer.length > 0) {
             this.flushTable();
         }
+    }
+    flush() {
+        if (this.tableBuffer.length > 0) {
+            this.flushTable();
+        }
+        if (this.inCodeBlock) {
+            if (this.buffer.length > 0) {
+                this.codeLines.push(this.buffer);
+                this.buffer = "";
+            }
+            if (this.codeLines.length > 0) {
+                this.emitCodeBlock();
+            }
+            this.streamedChars = 0;
+            return;
+        }
         if (this.buffer.length > 0) {
             const line = this.buffer;
             this.buffer = "";
-            if (line.trim() === "```" || line.trim().startsWith("```")) {
-                if (this.codeLines.length > 0) {
-                    this.emitCodeBlock();
-                }
-                return;
-            }
+            this.emitPartialRewind();
             this.onWrite(this.formatLine(line));
         }
+        this.streamedChars = 0;
     }
     processLine(line) {
         if (line.trim() === "```" || line.trim().startsWith("```")) {

package/dist/ui/output.js

@@ -1,13 +1,14 @@
+import { getDefaultChannel } from "../output";
 import { formatMarkdown, formatError, formatSuccess, formatWarning } from "./md-formatter";
 export function writeOutput(text) {
-    process.stdout.write(formatMarkdown(text) + "\n");
+    getDefaultChannel().writeRaw(formatMarkdown(text) + "\n");
 }
 export function writeError(text) {
-    process.stderr.write(formatError(text) + "\n");
+    getDefaultChannel().writeRaw(formatError(text) + "\n", "stderr");
 }
 export function writeSuccess(text) {
-    process.stdout.write(formatSuccess(text) + "\n");
+    getDefaultChannel().writeRaw(formatSuccess(text) + "\n");
 }
 export function writeWarning(text) {
-    process.stdout.write(formatWarning(text) + "\n");
+    getDefaultChannel().writeLine(formatWarning(text));
 }

package/dist/ui/plan-view.js

@@ -28,8 +28,7 @@ export function readActivePlan(baseDir) {
     }
 }
 export function currentStepIndex(plan) {
-    const idx = plan.steps.findIndex((s) => s.status !== "done" && s.status !== "skipped");
-    return idx === -1 ? 0 : idx;
+    return plan.steps.findIndex((s) => s.status !== "done" && s.status !== "skipped");
 }
 function stepMark(step) {
     switch (step.status) {
@@ -95,9 +94,5 @@ export function stepContextForTool(plan, tool, args) {
             }
         }
     }
-    const cur = currentStepIndex(plan);
-    const step = plan.steps[cur];
-    if (!step)
-        return null;
-    return t("ui.step_context", { id: step.id, desc: truncate(step.description) });
+    return null;
 }