klyro 0.1.46 → 0.1.47

package/dist/cli/repl.js

@@ -19,6 +19,7 @@ import { TuiApprovalBridge } from '../tui/approval.js';
 import { parseUnifiedDiff } from '../tui/diff-parser.js';
 import { parse } from './slash/parser.js';
 import { resolveProvider, providerHelp } from '../providers.js';
+import { MouseFilter, MOUSE_ENABLE, MOUSE_DISABLE } from '../tui/mouse.js';
 import { inferProviderFromBaseURL } from '../agent/registry.js';
 import { getDefaultSessionStore } from '../persistence/session.js';
 import { buildSystemPrompt, parseImageInput } from '../context/system-prompt.js';
@@ -139,6 +140,7 @@ export async function startRepl(opts = {}) {
         try {
             process.stdout.write('\x1b[?1049h\x1b[?25l'); // alt screen + hide cursor
             process.stdout.write('\x1b[H\x1b[2J'); // home + clear
+            process.stdout.write(MOUSE_ENABLE); // wheel events (SGR), see tui/mouse.ts
         }
         catch { /* ignore */ }
     };
@@ -146,10 +148,45 @@ export async function startRepl(opts = {}) {
         if (!isAltScreen)
             return;
         try {
+            process.stdout.write(MOUSE_DISABLE);
             process.stdout.write('\x1b[?25h\x1b[?1049l'); // show cursor + leave alt
         }
         catch { /* ignore */ }
     };
+    // OpenCode-style wheel scrolling (§8.5, S8): Ink owns stdin and cannot see
+    // mouse events, so tap stdin.emit — wheel deltas drive the App's scroll
+    // hooks, everything else passes through to Ink untouched.
+    const mouseFilter = new MouseFilter();
+    const origStdinEmit = process.stdin.emit.bind(process.stdin);
+    let mouseTapInstalled = false;
+    function installMouseTap() {
+        if (!isAltScreen || mouseTapInstalled)
+            return;
+        mouseTapInstalled = true;
+        process.stdin.emit = (...a) => {
+            if (a[0] === 'data' && Buffer.isBuffer(a[1])) {
+                const split = mouseFilter.push(a[1]);
+                for (const w of split.wheels) {
+                    try {
+                        if (isMounted && directHooks)
+                            directHooks.scrollLines(w);
+                    }
+                    catch { /* ignore */ }
+                }
+                if (split.kept.length === 0)
+                    return false;
+                a[1] = split.kept;
+            }
+            return origStdinEmit(...a);
+        };
+    }
+    function removeMouseTap() {
+        if (!mouseTapInstalled)
+            return;
+        mouseTapInstalled = false;
+        mouseFilter.reset();
+        process.stdin.emit = origStdinEmit;
+    }
     // Declare app before handler to avoid TDZ; handler added after render
     let app;
     let sigintHandler;
@@ -201,6 +238,7 @@ export async function startRepl(opts = {}) {
         console.debug = origConsoleFns.debug;
     }
     patchConsole();
+    installMouseTap();
     const EFFORT_STEPS = { low: 10, medium: 30, high: 50, max: 100 };
     // P1 session/permission state (commands.md Priority 1)
     let sessionLabel = '';
@@ -2159,6 +2197,7 @@ export async function startRepl(opts = {}) {
                 process.removeListener('SIGTERM', sigintHandler);
             }
             restoreConsole();
+            removeMouseTap();
             leaveAlt();
             // §1.2 exit behavior: replay a plain-text transcript into the main
             // buffer so the session survives in native scrollback.

package/dist/tui/app.d.ts

@@ -22,6 +22,8 @@ export interface AppProps {
         updateStatus: (s: Partial<StatusSnapshot>) => void;
         updatePlan: (p: PlanStep[]) => void;
         clearTranscript: () => void;
+        scrollLines: (delta: number) => void;
+        scrollToBottom: () => void;
     }) => void;
     version?: string;
     isFullscreen?: boolean;

package/dist/tui/app.js

@@ -201,6 +201,8 @@ export function App(props) {
         setHistory((prev) => (prev[prev.length - 1] === v ? prev : [...prev.slice(-99), v]));
         setHistIdx(null);
     }, []);
+    // Live scroll control for external drivers (mouse-wheel tap in repl.ts).
+    const scrollCmdsRef = useRef({ line: (_d) => { }, bottom: () => { } });
     const width = stdout?.columns ?? 100;
     const height = stdout?.rows ?? 30;
     const isFullscreen = props.isFullscreen ?? false;
@@ -318,6 +320,19 @@ export function App(props) {
         }
     }
     const visibleGrouped = isFullscreen && !tiny ? grouped.slice(gi0, gi1 + 1) : grouped;
+    // Publish live scroll control for the mouse-wheel tap (stable callbacks, latest ctx).
+    scrollCmdsRef.current = {
+        line: (d) => {
+            const n = Math.abs(Math.round(d));
+            for (let i = 0; i < n; i++) {
+                if (d < 0)
+                    commands.lineUp();
+                else
+                    commands.lineDown();
+            }
+        },
+        bottom: () => commands.jumpBottom(),
+    };
     useEffect(() => bridge.subscribe((p) => setAwaitingApproval(p !== null)), [bridge]);
     useEffect(() => {
         if (queuedInputs.length > 0 && status.status !== 'running' && !awaitingApproval) {
@@ -354,9 +369,13 @@ export function App(props) {
     const updateStatus = useCallback((s) => setStatus((p) => ({ ...p, ...s })), []);
     const updatePlan = useCallback((p) => setPlan(p), []);
     const clearTranscript = useCallback(() => { streamingIdRef.current = null; setTranscript([]); setPlan([]); }, []);
+    // Scroll control for external drivers (mouse-wheel tap in repl.ts, §8.4).
+    // Stored in refs so the callbacks stay stable while acting on latest state.
+    const scrollLines = useCallback((delta) => { scrollCmdsRef.current.line(delta); }, []);
+    const scrollToBottom = useCallback(() => { scrollCmdsRef.current.bottom(); }, []);
     const onMountedRef = useRef(props.onMounted);
     useEffect(() => { onMountedRef.current = props.onMounted; }, [props.onMounted]);
-    useEffect(() => { onMountedRef.current?.({ append, appendDelta, updateStatus, updatePlan, clearTranscript }); globalThis.__klyroAppAppend = append; globalThis.__klyroAppendDelta = appendDelta; globalThis.__klyroAppStatus = updateStatus; globalThis.__klyroAppPlan = updatePlan; return () => { delete globalThis.__klyroAppAppend; delete globalThis.__klyroAppendDelta; delete globalThis.__klyroAppStatus; delete globalThis.__klyroAppPlan; }; }, [append, appendDelta, updateStatus, updatePlan, clearTranscript]);
+    useEffect(() => { onMountedRef.current?.({ append, appendDelta, updateStatus, updatePlan, clearTranscript, scrollLines, scrollToBottom }); globalThis.__klyroAppAppend = append; globalThis.__klyroAppendDelta = appendDelta; globalThis.__klyroAppStatus = updateStatus; globalThis.__klyroAppPlan = updatePlan; return () => { delete globalThis.__klyroAppAppend; delete globalThis.__klyroAppendDelta; delete globalThis.__klyroAppStatus; delete globalThis.__klyroAppPlan; }; }, [append, appendDelta, updateStatus, updatePlan, clearTranscript, scrollLines, scrollToBottom]);
     const toggleGroup = (id) => setExpandedGroups((prev) => { const n = new Set(prev); if (n.has(id))
         n.delete(id);
     else
@@ -390,11 +409,11 @@ export function App(props) {
                 commands.jumpBottom();
                 return;
             } // Ctrl+G → bottom (§8.4)
-            if (key.pageUp || (key.ctrl && inputStr === 'u')) {
+            if (key.pageUp || (key.ctrl && inputStr === 'u') || (key.ctrl && inputStr === 'b')) {
                 commands.pageUp();
                 return;
             }
-            if (key.pageDown || (key.ctrl && inputStr === 'd')) {
+            if (key.pageDown || (key.ctrl && inputStr === 'd') || (key.ctrl && inputStr === 'f')) {
                 commands.pageDown();
                 return;
             }

package/dist/tui/app.test.js

@@ -249,6 +249,25 @@ describe('App', () => {
         await new Promise((r) => setTimeout(r, 100));
         expect(lastFrame() ?? '').toMatch(/LATE-1-tag/);
     });
+    it('onMounted scrollLines/scrollToBottom drive the viewport (wheel path)', async () => {
+        let captured = null;
+        const { lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: async () => { }, onSlash: async () => { }, isFullscreen: true, initialTranscript: makeInitialTranscript(25), onMounted: (h) => {
+                captured = { scrollLines: h.scrollLines, scrollToBottom: h.scrollToBottom };
+            } }));
+        await new Promise((r) => setTimeout(r, 50));
+        expect(captured).not.toBeNull();
+        // Wheel up ×12 (3 lines each = 36 > maxTop 32) → pinned at top.
+        for (let i = 0; i < 12; i++)
+            captured.scrollLines(-3);
+        await new Promise((r) => setTimeout(r, 50));
+        const top = lastFrame() ?? '';
+        expect(top).toMatch(/MSG-00-tag/);
+        expect(top).not.toMatch(/MSG-24-tag/);
+        // scrollToBottom → tail visible again.
+        captured.scrollToBottom();
+        await new Promise((r) => setTimeout(r, 50));
+        expect(lastFrame() ?? '').toMatch(/MSG-24-tag/);
+    });
     it('Shift+Up / Shift+Down scroll by one line', async () => {
         const { stdin, lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: async () => { }, onSlash: async () => { }, isFullscreen: true, initialTranscript: makeInitialTranscript(25) }));
         await new Promise((r) => setTimeout(r, 50));

package/dist/tui/mouse.d.ts

@@ -0,0 +1,36 @@
+/**
+ * scroll.md §8.5 (S8) — mouse wheel capture for OpenCode-style scrolling.
+ *
+ * Ink owns stdin via useInput and cannot see mouse events, so the REPL wraps
+ * `process.stdin.emit` with this stateful splitter: SGR/X10 mouse sequences
+ * are swallowed (wheel → scroll deltas, clicks/motion → dropped), everything
+ * else passes through to Ink untouched.
+ *
+ * Only the wheel is acted on. Clicks are swallowed (not forwarded) because a
+ * mouse-reporting terminal would otherwise deliver them to readline as typed
+ * garbage; Shift+drag still selects natively in most terminals.
+ *
+ * Sequences handled:
+ *   SGR: `\x1b[<Cb;x;yM` / `...m`  (1006, requested via `CSI ? 1006 h`)
+ *   X10: `\x1b[M Cb Cx Cy`         (fallback for terminals ignoring 1006)
+ * Wheel bit is 64 in both; direction bit is 1 (down) — modifiers OR into Cb.
+ */
+export declare const WHEEL_LINES = 3;
+export interface MouseSplit {
+    /** bytes Ink is still allowed to see */
+    kept: Buffer;
+    /** wheel deltas: negative = up (older), positive = down (newer) */
+    wheels: number[];
+}
+export declare class MouseFilter {
+    private pending;
+    /**
+     * Split one stdin chunk. Holds an unambiguous trailing partial mouse
+     * sequence for the next chunk; a lone trailing ESC passes through
+     * immediately so the Esc key (queued-drop) never lags.
+     */
+    push(chunk: Buffer): MouseSplit;
+    reset(): void;
+}
+export declare const MOUSE_ENABLE = "\u001B[?1000h\u001B[?1006h";
+export declare const MOUSE_DISABLE = "\u001B[?1000l\u001B[?1006l";

package/dist/tui/mouse.js

@@ -0,0 +1,94 @@
+/**
+ * scroll.md §8.5 (S8) — mouse wheel capture for OpenCode-style scrolling.
+ *
+ * Ink owns stdin via useInput and cannot see mouse events, so the REPL wraps
+ * `process.stdin.emit` with this stateful splitter: SGR/X10 mouse sequences
+ * are swallowed (wheel → scroll deltas, clicks/motion → dropped), everything
+ * else passes through to Ink untouched.
+ *
+ * Only the wheel is acted on. Clicks are swallowed (not forwarded) because a
+ * mouse-reporting terminal would otherwise deliver them to readline as typed
+ * garbage; Shift+drag still selects natively in most terminals.
+ *
+ * Sequences handled:
+ *   SGR: `\x1b[<Cb;x;yM` / `...m`  (1006, requested via `CSI ? 1006 h`)
+ *   X10: `\x1b[M Cb Cx Cy`         (fallback for terminals ignoring 1006)
+ * Wheel bit is 64 in both; direction bit is 1 (down) — modifiers OR into Cb.
+ */
+export const WHEEL_LINES = 3; // scroll.md §8.4: wheel = ±3 lines
+function isDigit(b) {
+    return b >= 0x30 && b <= 0x39;
+}
+export class MouseFilter {
+    pending = Buffer.alloc(0);
+    /**
+     * Split one stdin chunk. Holds an unambiguous trailing partial mouse
+     * sequence for the next chunk; a lone trailing ESC passes through
+     * immediately so the Esc key (queued-drop) never lags.
+     */
+    push(chunk) {
+        const buf = Buffer.concat([this.pending, chunk]);
+        this.pending = Buffer.alloc(0);
+        const kept = [];
+        const wheels = [];
+        let i = 0;
+        const n = buf.length;
+        while (i < n) {
+            // SGR mouse: ESC [ < Cb ; x ; y (M|m)
+            if (buf[i] === 0x1b && i + 2 < n && buf[i + 1] === 0x5b && buf[i + 2] === 0x3c) {
+                let j = i + 3;
+                while (j < n && (isDigit(buf[j]) || buf[j] === 0x3b))
+                    j++;
+                if (j >= n) {
+                    // split across chunks — hold for more data
+                    this.pending = buf.subarray(i);
+                    break;
+                }
+                const term = buf[j];
+                if (term === 0x4d || term === 0x6d) {
+                    const cb = parseInt(buf.subarray(i + 3, j).toString().split(';')[0] ?? 'NaN', 10);
+                    if (!Number.isNaN(cb) && (cb & 64) !== 0) {
+                        wheels.push((cb & 1) === 0 ? -WHEEL_LINES : WHEEL_LINES);
+                    }
+                    i = j + 1; // swallow (wheel or click/motion)
+                    continue;
+                }
+                // ESC [ < not followed by digits→M/m: not a mouse seq, pass ESC through
+                kept.push(buf.subarray(i, i + 1));
+                i++;
+                continue;
+            }
+            // X10 mouse: ESC [ M Cb Cx Cy
+            if (buf[i] === 0x1b && i + 2 < n && buf[i + 1] === 0x5b && buf[i + 2] === 0x4d) {
+                if (i + 5 >= n) {
+                    this.pending = buf.subarray(i); // split across chunks
+                    break;
+                }
+                const cb = buf[i + 3] - 32;
+                if ((cb & 64) !== 0) {
+                    wheels.push((cb & 1) === 0 ? -WHEEL_LINES : WHEEL_LINES);
+                }
+                i += 6; // swallow
+                continue;
+            }
+            // Trailing partial that could ONLY be a split SGR/X10 start: hold it.
+            // A lone trailing ESC passes through (Esc key must not lag).
+            const tail = n - i;
+            if (tail <= 5) {
+                const rest = buf.subarray(i).toString('latin1');
+                if (/^\x1b\[<$/.test(rest) || /^\x1b\[<[\d;]+$/.test(rest) || /^\x1b\[M.{0,2}$/.test(rest)) {
+                    this.pending = buf.subarray(i);
+                    break;
+                }
+            }
+            kept.push(buf.subarray(i, i + 1));
+            i++;
+        }
+        return { kept: Buffer.concat(kept), wheels };
+    }
+    reset() {
+        this.pending = Buffer.alloc(0);
+    }
+}
+export const MOUSE_ENABLE = '\x1b[?1000h\x1b[?1006h'; // button events + SGR coords
+export const MOUSE_DISABLE = '\x1b[?1000l\x1b[?1006l';

package/dist/tui/scroll-flow.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tui/scroll-flow.test.js

@@ -0,0 +1,94 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * scroll.md diagnostic: realistic session flow — seed history, stream a long
+ * answer in chunks (like provider deltas), scroll mid-stream, stream more.
+ * Asserts the chat-flow invariants the user actually sees:
+ *   - follow-tail: latest streamed text visible while at bottom
+ *   - freeze: pinned viewport doesn't move while streaming
+ *   - badge counts new lines
+ *   - frame never exceeds terminal rows (I1)
+ */
+import { describe, it, expect } from 'vitest';
+import { render } from 'ink-testing-library';
+import { App } from './app.js';
+const PROPS = {
+    initialModel: 'm',
+    maxSteps: 10,
+    cwd: '/test',
+    onPrompt: async () => { },
+    onSlash: async () => { },
+};
+const g = globalThis;
+const tick = (ms = 30) => new Promise((r) => setTimeout(r, ms));
+const rowsOf = (frame) => frame.split('\n').length;
+function seed(n) {
+    return Array.from({ length: n }, (_, i) => ({
+        id: `seed-${i}`,
+        kind: 'text',
+        text: `MSG-${i.toString().padStart(2, '0')}-tag`,
+        role: 'user',
+    }));
+}
+describe('scroll flow diagnostics', () => {
+    it('reports terminal geometry (debug aid)', async () => {
+        const { lastFrame } = render(_jsx(App, { ...PROPS, isFullscreen: true }));
+        await tick(50);
+        const frame = lastFrame() ?? '';
+        // eslint-disable-next-line no-console
+        console.log(`[diag] frame rows=${rowsOf(frame)} cols~${(frame.split('\n')[0] ?? '').length}`);
+        expect(rowsOf(frame)).toBeLessThanOrEqual(32);
+    });
+    it('follow-tail: streamed long answer stays visible, frame stays bounded', async () => {
+        const { lastFrame } = render(_jsx(App, { ...PROPS, isFullscreen: true, initialTranscript: seed(5) }));
+        await tick(50);
+        g.__klyroAppStatus({ status: 'running' });
+        const chunk = 'STREAMCHUNK lorem ipsum dolor sit amet. ';
+        for (let i = 0; i < 12; i++) {
+            g.__klyroAppendDelta(`${chunk}#${i} `);
+            await tick(40);
+            const frame = lastFrame() ?? '';
+            expect(rowsOf(frame)).toBeLessThanOrEqual(32);
+            // latest streamed chunk must be visible (follow-tail)
+            expect(frame).toContain(`#${i}`);
+        }
+    });
+    it('freeze: pinned top survives streaming, badge counts, End restores', async () => {
+        const { stdin, lastFrame } = render(_jsx(App, { ...PROPS, isFullscreen: true, initialTranscript: seed(40) }));
+        await tick(100);
+        stdin.write('\x1b[H'); // Home → top
+        await tick(50);
+        const top = lastFrame() ?? '';
+        expect(top).toContain('MSG-00-tag');
+        g.__klyroAppStatus({ status: 'running' });
+        for (let i = 0; i < 5; i++) {
+            g.__klyroAppendDelta(`late chunk number ${i} with filler words here. `);
+            await tick(40);
+        }
+        const frozen = lastFrame() ?? '';
+        expect(frozen).toContain('MSG-00-tag'); // viewport did not yank down
+        expect(frozen).toMatch(/↓ \d+ new/); // badge visible
+        expect(rowsOf(frozen)).toBeLessThanOrEqual(32);
+        stdin.write('\x1b[F'); // End → follow
+        await tick(50);
+        expect(lastFrame() ?? '').toContain('number 4');
+    });
+    it('wrapped long item: pin mid-item, stream, same first line stays', async () => {
+        const long = Array.from({ length: 10 }, (_, i) => `WRAPLINE-${i} ` + 'x'.repeat(180)).join('\n');
+        const items = [
+            { id: 'w1', kind: 'text', text: long, role: 'assistant' },
+            ...seed(30),
+        ];
+        const { stdin, lastFrame } = render(_jsx(App, { ...PROPS, isFullscreen: true, initialTranscript: items }));
+        await tick(100);
+        stdin.write('\x1b[H');
+        await tick(50);
+        const before = (lastFrame() ?? '').split('\n').slice(0, 3).join('\n');
+        g.__klyroAppStatus({ status: 'running' });
+        for (let i = 0; i < 5; i++) {
+            g.__klyroAppendDelta(`more streamed text ${i} ` + 'y'.repeat(120));
+            await tick(40);
+        }
+        const after = (lastFrame() ?? '').split('\n').slice(0, 3).join('\n');
+        expect(after).toBe(before); // anchor stability at line granularity
+    });
+});

package/dist/tui/scroll-model.js

@@ -22,10 +22,13 @@ export function maxTopFor(ctx) {
 function stickBottom() {
     return { anchor: { mode: 'bottom' }, userScrolled: false, newSinceUnstick: 0 };
 }
-function pinAt(s, ctx, row) {
+// FOLLOW_EPSILON is directional: scrolling DOWN into the last line re-sticks
+// to bottom, but scrolling UP must always escape — otherwise single-line /
+// wheel scrolling from the bottom could never leave it (dead scroll trap).
+function pinAt(s, ctx, row, from) {
     const maxTop = maxTopFor(ctx);
     const top = clampN(row, 0, maxTop);
-    if (top >= maxTop - FOLLOW_EPSILON)
+    if (top >= maxTop - FOLLOW_EPSILON && top >= from)
         return stickBottom();
     if (ctx.count === 0)
         return stickBottom();
@@ -42,13 +45,13 @@ export function scrollReducer(s, a, ctx) {
     const cur = resolveTopRow(s, ctx).topRow;
     switch (a.type) {
         case 'BY_LINES':
-            return pinAt(s, ctx, cur + a.delta);
+            return pinAt(s, ctx, cur + a.delta, cur);
         case 'BY_PAGE':
-            return pinAt(s, ctx, cur + a.dir * (ctx.viewportH - 1)); // 1-line overlap
+            return pinAt(s, ctx, cur + a.dir * (ctx.viewportH - 1), cur); // 1-line overlap
         case 'BY_HALF_PAGE':
-            return pinAt(s, ctx, cur + a.dir * Math.floor(ctx.viewportH / 2));
+            return pinAt(s, ctx, cur + a.dir * Math.floor(ctx.viewportH / 2), cur);
         case 'TO_TOP':
-            return pinAt(s, ctx, 0);
+            return pinAt(s, ctx, 0, cur);
         case 'TO_BOTTOM':
             return stickBottom();
         case 'CONTENT_GREW':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "klyro",
-  "version": "0.1.46",
+  "version": "0.1.47",
   "description": "Klyro \u2014 autonomous coding harness CLI that streams from any OpenAI-compatible or Anthropic LLM endpoint.",
   "type": "module",
   "main": "dist/index.js",