koneck 2.128.35 → 2.128.37

package/dist/ink-chat.js

@@ -4,7 +4,7 @@ import { Box, Static, Text, render, useApp, useInput, useStdin } from 'ink';
 import { execa } from 'execa';
 import chalk from 'chalk';
 import { resolveAgentConcurrency, toolsUnsupportedNotice } from './engine-facts.js';
-import { withSynchronizedFrames, probeSynchronizedOutput } from './frame-sync.js';
+import { withSynchronizedFrames, withUsableSize, probeSynchronizedOutput } from './frame-sync.js';
 import { pacedInterval, startingInterval, floorFor, shouldDrawFrame } from './frame-pace.js';
 import { estimateCost, formatCost, rateText } from './pricing.js';
 import { generateSessionId, saveSession, listSessions, loadSession, relativeAge, renameSession, forkSession, archiveSession, findSession, } from './session.js';
@@ -2751,7 +2751,7 @@ export function App({ config: initialConfig, clearFrame, synchronizedFrames = fa
                  * a keystroke.
                  */
                 if (prev !== cols)
-                    redrawScreenRef.current?.();
+                    redrawScreenRef.current?.({ keepScrollback: true });
                 return cols;
             });
         };
@@ -3209,7 +3209,17 @@ export function App({ config: initialConfig, clearFrame, synchronizedFrames = fa
      * lives in the session rather than in the terminal's memory of it.
      */
     redrawScreenRef.current = redrawScreen;
-    function redrawScreen() {
+    /**
+     * Repaint the terminal from scratch.
+     *
+     * `keepScrollback` is the difference between the two callers. Ctrl+L is somebody asking for a
+     * clean slate after something has gone wrong on screen, and a stranded frame that has scrolled
+     * out of view is still in the buffer waiting to come back — so that one takes the scrollback
+     * with it. A resize is not a request for anything: it re-flows the conversation because the
+     * width changed, and throwing away everything the person had scrolled past would be a far
+     * larger thing than they asked for.
+     */
+    function redrawScreen(opts = {}) {
         if (!process.stdout.isTTY)
             return;
         // Ink's own clear first. It erases the frame using its own count of it and then resets that
@@ -3219,7 +3229,7 @@ export function App({ config: initialConfig, clearFrame, synchronizedFrames = fa
         // Then the screen, and the scrollback with it — a stranded frame that has scrolled out of view
         // is still in the buffer, and leaving it there means it comes back on the next scroll — and
         // home the cursor, which is where Ink will now draw.
-        process.stdout.write('\u001b[2J\u001b[3J\u001b[H');
+        process.stdout.write(opts.keepScrollback ? '\u001b[2J\u001b[H' : '\u001b[2J\u001b[3J\u001b[H');
         // The transcript has just been erased along with everything else, so it has to be written
         // again — and writing it again is also what re-flows it to the current width.
         setStaticEpoch(n => n + 1);
@@ -7253,7 +7263,34 @@ export async function runInkChatMode(config) {
      * frame is a visible blink of the whole screen. 150ms at worst, once, on startup.
      */
     const synchronizedFrames = await probeSynchronizedOutput().catch(() => false);
-    const app = render(_jsx(App, { config: config, synchronizedFrames: synchronizedFrames, clearFrame: () => inkClear?.() }), { stdout: withSynchronizedFrames(process.stdout),
+    /*
+     * A clean screen to start on.
+     *
+     * KONECK opened wherever the shell had got to, so a session begun after an `npm install` sat
+     * under a wall of its output with the banner halfway down the screen — it read as another
+     * command that had printed something, rather than as a program that had taken over. Reported
+     * exactly that way: "it fails to take over the terminal and not appear as if it's a command".
+     *
+     * `ESC[2J ESC[H` and nothing more. Deliberately not `ESC[3J`, which empties the scrollback too:
+     * whatever was on screen a moment ago is still there to scroll back to, which is the difference
+     * between clearing the screen and throwing away somebody's last command. Same sequence `clear`
+     * uses, for the same reason.
+     *
+     * Written before Ink starts, so its idea of what it has drawn begins at zero and matches the
+     * screen. Doing this after the first frame is what once left a dead copy of the interface
+     * pinned below a working one.
+     *
+     * Not on the alternate screen, which arrives blank by definition, and not when the output is
+     * not a terminal at all.
+     */
+    if (config.clearOnStart !== false && process.stdout.isTTY
+        && initialAltScreen(config, synchronizedFrames) === false) {
+        process.stdout.write('\u001b[2J\u001b[H');
+    }
+    const app = render(_jsx(App, { config: config, synchronizedFrames: synchronizedFrames, clearFrame: () => inkClear?.() }), 
+    // Sized first, then bracketed: Ink must never be handed a stream that
+    // says it is zero rows tall. See withUsableSize.
+    { stdout: withSynchronizedFrames(withUsableSize(process.stdout)),
         exitOnCtrlC: false, patchConsole: false });
     inkClear = app.clear;
     // The engine is imported on demand so the banner and the prompt are not waiting on the OpenAI