klyro 0.1.44 → 0.1.46

package/dist/tui/app.test.js

@@ -201,6 +201,54 @@ describe('App', () => {
         const frame = lastFrame() ?? '';
         expect(frame).toMatch(/LATE-1-tag/);
     });
+    it('↑ recalls the previous prompt (input history, §8.3)', async () => {
+        const onPrompt = vi.fn(async () => { });
+        const { stdin, lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: onPrompt, onSlash: async () => { } }));
+        stdin.write('first recallable prompt');
+        await new Promise((r) => setTimeout(r, 20));
+        stdin.write('\x0d');
+        await new Promise((r) => setTimeout(r, 50));
+        expect(onPrompt).toHaveBeenCalledWith('first recallable prompt');
+        // Input cleared after submit; ↑ should restore it from history.
+        stdin.write('\x1b[A');
+        await new Promise((r) => setTimeout(r, 30));
+        expect(lastFrame() ?? '').toContain('first recallable prompt');
+    });
+    it('↑ on empty input scrolls one line instead of history', 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));
+        stdin.write(KEY_HOME);
+        await new Promise((r) => setTimeout(r, 30));
+        // Empty input + plain ↑ → line up (stays near top, MSG-00 visible).
+        stdin.write('\x1b[A');
+        await new Promise((r) => setTimeout(r, 30));
+        expect(lastFrame() ?? '').toMatch(/MSG-00-tag/);
+    });
+    it('/c shows top-6 suggestions and Tab completes', async () => {
+        const { stdin, lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: async () => { }, onSlash: async () => { } }));
+        stdin.write('/c');
+        await new Promise((r) => setTimeout(r, 30));
+        const withSuggest = lastFrame() ?? '';
+        expect(withSuggest).toMatch(/\/clear/);
+        expect(withSuggest).toMatch(/tab to complete/i);
+        stdin.write('\t');
+        await new Promise((r) => setTimeout(r, 30));
+        expect(lastFrame() ?? '').toContain('/clear ');
+    });
+    it('Enter on empty input while pinned jumps back to bottom (§7.2)', 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, 100));
+        stdin.write(KEY_HOME);
+        await new Promise((r) => setTimeout(r, 100));
+        const g = globalThis;
+        g.__klyroAppAppend({ id: 'late-1', kind: 'text', text: 'LATE-1-tag', role: 'assistant' });
+        await new Promise((r) => setTimeout(r, 200));
+        expect(lastFrame() ?? '').not.toMatch(/LATE-1-tag/);
+        // Empty input + Enter → dismiss badge, follow tail.
+        stdin.write('\x0d');
+        await new Promise((r) => setTimeout(r, 100));
+        expect(lastFrame() ?? '').toMatch(/LATE-1-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/measure.d.ts

@@ -0,0 +1,85 @@
+/**
+ * scroll.md §4 — Measurement layer (item → display lines).
+ *
+ * Pure functions only: no hooks, no side effects. The App measures each
+ * transcript block into wrapped display-line heights, caches by
+ * (key, width, content-signature), and builds a cumulative line index so
+ * scrolling is O(1) per frame and only the streaming tail is re-measured.
+ *
+ * Heights mirror the render structure in app.tsx:
+ *   user text      = wrapped lines + 1 (marginBottom)
+ *   assistant text = 1 (guide+Klyro header) + wrapped + 1
+ *   group collapsed= 1 + 1 margin; expanded = 1 + min(n,12) + overflow?1 + 1
+ *   error          = wrapped + 1 margin
+ *   policy         = 0 (renders null)
+ *   file_changed   = 1 + 1 margin
+ *   diff           = 1 summary + Σ(1 path + wrapped hunk lines) + 1 margin
+ *   plan block     = 1 + min(8, steps) + 1 margin
+ *   thinking/queue = content lines + 1 margin
+ */
+/** Display width per scroll.md §12: never `.length` (CJK=2, emoji=2, combining=0). */
+export declare function displayWidth(s: string): number;
+/** Wrapped display-line count for already-newline-split text at `width`. */
+export declare function wrapCount(text: string, width: number): number;
+/** Content width inside the transcript column (guide prefix + padding). */
+export declare function contentWidth(termWidth: number): number;
+export type BlockDesc = {
+    kind: 'user';
+    text: string;
+} | {
+    kind: 'assistant';
+    text: string;
+} | {
+    kind: 'group';
+    count: number;
+    expanded: boolean;
+} | {
+    kind: 'error';
+    message: string;
+} | {
+    kind: 'policy';
+} | {
+    kind: 'file';
+    path: string;
+} | {
+    kind: 'diff';
+    hunks: Array<{
+        path: string;
+        lines: string[];
+    }>;
+} | {
+    kind: 'plan';
+    done: number;
+    total: number;
+} | {
+    kind: 'thinking';
+} | {
+    kind: 'queued';
+    count: number;
+};
+export declare const EXPANDED_DETAIL_CAP = 12;
+export declare function blockHeight(b: BlockDesc, termWidth: number): number;
+/** Content fingerprint: changes whenever the block's rendered lines could change. */
+export declare function blockSig(b: BlockDesc): string;
+/** Cache: key → height. Only the streaming tail changes sig per tick (I6 → O(1)). */
+export declare class MeasureCache {
+    private map;
+    private maxEntries;
+    constructor(maxEntries?: number);
+    heightFor(key: string, block: BlockDesc, termWidth: number): number;
+    /** Resize (width change) invalidates everything — scroll.md §12. */
+    invalidateWidth(): void;
+    get size(): number;
+}
+export interface LineIndex {
+    offsets: number[];
+    total: number;
+}
+/** Cumulative first-row offsets; dirtyFrom allows incremental rebuild (only tail dirtied). */
+export declare function buildIndex(heights: number[], prev?: {
+    offsets: number[];
+    dirtyFrom: number;
+}): LineIndex;
+/** Binary search: display row → block index (upperBound(offsets, row) - 1). */
+export declare function itemAtRow(offsets: number[], row: number): number;
+export declare function clamp(n: number, lo: number, hi: number): number;

package/dist/tui/measure.js

@@ -0,0 +1,186 @@
+/**
+ * scroll.md §4 — Measurement layer (item → display lines).
+ *
+ * Pure functions only: no hooks, no side effects. The App measures each
+ * transcript block into wrapped display-line heights, caches by
+ * (key, width, content-signature), and builds a cumulative line index so
+ * scrolling is O(1) per frame and only the streaming tail is re-measured.
+ *
+ * Heights mirror the render structure in app.tsx:
+ *   user text      = wrapped lines + 1 (marginBottom)
+ *   assistant text = 1 (guide+Klyro header) + wrapped + 1
+ *   group collapsed= 1 + 1 margin; expanded = 1 + min(n,12) + overflow?1 + 1
+ *   error          = wrapped + 1 margin
+ *   policy         = 0 (renders null)
+ *   file_changed   = 1 + 1 margin
+ *   diff           = 1 summary + Σ(1 path + wrapped hunk lines) + 1 margin
+ *   plan block     = 1 + min(8, steps) + 1 margin
+ *   thinking/queue = content lines + 1 margin
+ */
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+function isWide(cp) {
+    return ((cp >= 0x1100 && cp <= 0x115f) ||
+        (cp >= 0x2e80 && cp <= 0xa4cf) ||
+        (cp >= 0xac00 && cp <= 0xd7a3) ||
+        (cp >= 0xf900 && cp <= 0xfaff) ||
+        (cp >= 0xfe30 && cp <= 0xfe4f) ||
+        (cp >= 0xff00 && cp <= 0xff60) ||
+        (cp >= 0xffe0 && cp <= 0xffe6) ||
+        (cp >= 0x1f300 && cp <= 0x1faff) ||
+        (cp >= 0x2600 && cp <= 0x27bf) ||
+        (cp >= 0x2b00 && cp <= 0x2bff));
+}
+function isZeroWidth(cp) {
+    return ((cp >= 0x0300 && cp <= 0x036f) ||
+        (cp >= 0x200b && cp <= 0x200f) ||
+        (cp >= 0xfe00 && cp <= 0xfe0f) ||
+        cp === 0x00ad);
+}
+/** Display width per scroll.md §12: never `.length` (CJK=2, emoji=2, combining=0). */
+export function displayWidth(s) {
+    const clean = s.replace(ANSI_RE, '').replace(/\t/g, '        ');
+    let w = 0;
+    for (const ch of clean) {
+        const cp = ch.codePointAt(0) ?? 0;
+        if (isZeroWidth(cp))
+            continue;
+        w += isWide(cp) ? 2 : 1;
+    }
+    return w;
+}
+/** Wrapped display-line count for already-newline-split text at `width`. */
+export function wrapCount(text, width) {
+    const w = Math.max(1, width);
+    let n = 0;
+    for (const line of text.split('\n')) {
+        const dw = displayWidth(line);
+        n += dw === 0 ? 1 : Math.max(1, Math.ceil(dw / w));
+    }
+    return Math.max(1, n);
+}
+/** Content width inside the transcript column (guide prefix + padding). */
+export function contentWidth(termWidth) {
+    return Math.max(20, termWidth - 10);
+}
+export const EXPANDED_DETAIL_CAP = 12; // scroll.md §9.3
+export function blockHeight(b, termWidth) {
+    const cw = contentWidth(termWidth);
+    switch (b.kind) {
+        case 'user':
+            return wrapCount(b.text, termWidth) + 1;
+        case 'assistant':
+            return 1 + wrapCount(b.text, cw) + 1;
+        case 'group':
+            if (!b.expanded)
+                return 1 + 1;
+            return 1 + Math.min(b.count, EXPANDED_DETAIL_CAP) + (b.count > EXPANDED_DETAIL_CAP ? 1 : 0) + 1;
+        case 'error':
+            return wrapCount(b.message, termWidth) + 1;
+        case 'policy':
+            return 0;
+        case 'file':
+            return 1 + 1;
+        case 'diff': {
+            let n = 1; // summary
+            for (const h of b.hunks)
+                n += 1 + h.lines.reduce((s, l) => s + wrapCount(l, cw), 0);
+            return n + 1;
+        }
+        case 'plan':
+            return 1 + Math.min(8, b.total) + 1;
+        case 'thinking':
+            return 1 + 1;
+        case 'queued':
+            return b.count + 1;
+    }
+}
+/** Content fingerprint: changes whenever the block's rendered lines could change. */
+export function blockSig(b) {
+    switch (b.kind) {
+        case 'user':
+            return `u:${b.text.length}:${b.text.slice(0, 16)}:${b.text.slice(-16)}`;
+        case 'assistant':
+            return `a:${b.text.length}:${b.text.slice(0, 16)}:${b.text.slice(-16)}`;
+        case 'group':
+            return `g:${b.count}:${b.expanded ? 1 : 0}`;
+        case 'error':
+            return `e:${b.message.length}:${b.message.slice(-32)}`;
+        case 'policy':
+            return 'p';
+        case 'file':
+            return `f:${b.path}`;
+        case 'diff':
+            return `d:${b.hunks.length}:${b.hunks.reduce((s, h) => s + h.lines.length, 0)}`;
+        case 'plan':
+            return `pl:${b.done}/${b.total}`;
+        case 'thinking':
+            return 't';
+        case 'queued':
+            return `q:${b.count}`;
+    }
+}
+/** Cache: key → height. Only the streaming tail changes sig per tick (I6 → O(1)). */
+export class MeasureCache {
+    map = new Map();
+    maxEntries;
+    constructor(maxEntries = 2000) {
+        this.maxEntries = maxEntries;
+    }
+    heightFor(key, block, termWidth) {
+        const sig = blockSig(block);
+        const hit = this.map.get(key);
+        if (hit && hit.width === termWidth && hit.sig === sig)
+            return hit.height;
+        const height = blockHeight(block, termWidth);
+        if (this.map.size >= this.maxEntries) {
+            const oldest = this.map.keys().next();
+            if (!oldest.done)
+                this.map.delete(oldest.value);
+        }
+        this.map.set(key, { width: termWidth, sig, height });
+        return height;
+    }
+    /** Resize (width change) invalidates everything — scroll.md §12. */
+    invalidateWidth() {
+        this.map.clear();
+    }
+    get size() {
+        return this.map.size;
+    }
+}
+/** Cumulative first-row offsets; dirtyFrom allows incremental rebuild (only tail dirtied). */
+export function buildIndex(heights, prev) {
+    const offsets = prev ? [...prev.offsets] : [];
+    const from = prev ? Math.min(prev.dirtyFrom, heights.length) : 0;
+    for (let i = Math.max(0, from); i < heights.length; i++) {
+        offsets[i] = i === 0 ? 0 : offsets[i - 1] + heights[i - 1];
+    }
+    offsets.length = heights.length;
+    const last = heights.length - 1;
+    const total = last < 0 ? 0 : offsets[last] + heights[last];
+    return { offsets, total };
+}
+/** Binary search: display row → block index (upperBound(offsets, row) - 1). */
+export function itemAtRow(offsets, row) {
+    if (offsets.length === 0)
+        return -1;
+    if (row <= 0)
+        return 0;
+    let lo = 0;
+    let hi = offsets.length - 1;
+    let ans = 0;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        if (offsets[mid] <= row) {
+            ans = mid;
+            lo = mid + 1;
+        }
+        else {
+            hi = mid - 1;
+        }
+    }
+    return ans;
+}
+export function clamp(n, lo, hi) {
+    return Math.max(lo, Math.min(hi, n));
+}

package/dist/tui/scroll-model.d.ts

@@ -0,0 +1,67 @@
+/**
+ * scroll.md §5 — Anchor-based scroll model (pure, no React).
+ *
+ * Position is an Anchor ({itemId, lineInItem}), never a raw row index (I4),
+ * so resizes, group expand/collapse, and compaction never make the view jump.
+ * While anchored to 'bottom', new output follows; the instant the user scrolls
+ * up the anchor pins to an item and freezes, accumulating newSinceUnstick
+ * display lines for the `↓ N new` badge (§7).
+ */
+export type Anchor = {
+    mode: 'bottom';
+} | {
+    mode: 'pinned';
+    itemId: string;
+    lineInItem: number;
+};
+export interface ScrollState {
+    anchor: Anchor;
+    userScrolled: boolean;
+    /** display lines appended since the user unstuck (badge count, §7) */
+    newSinceUnstick: number;
+}
+export declare const FOLLOW_EPSILON = 1;
+export declare const initialScroll: ScrollState;
+export type ScrollAction = {
+    type: 'BY_LINES';
+    delta: number;
+} | {
+    type: 'BY_PAGE';
+    dir: -1 | 1;
+} | {
+    type: 'BY_HALF_PAGE';
+    dir: -1 | 1;
+} | {
+    type: 'TO_TOP';
+} | {
+    type: 'TO_BOTTOM';
+} | {
+    type: 'CONTENT_GREW';
+    lines: number;
+} | {
+    type: 'REFLOW';
+};
+/** Index abstraction over measured display lines (§4.3). */
+export interface ScrollCtx {
+    /** number of blocks */
+    count: number;
+    /** display-line offset of block i */
+    offsetOf: (i: number) => number;
+    /** key of block i (stable across regroups) */
+    keyOf: (i: number) => string;
+    /** block index containing display row */
+    indexAt: (row: number) => number;
+    /** total measured display lines */
+    total: number;
+    viewportH: number;
+}
+export declare function maxTopFor(ctx: ScrollCtx): number;
+export declare function scrollReducer(s: ScrollState, a: ScrollAction, ctx: ScrollCtx): ScrollState;
+export interface Resolved {
+    topRow: number;
+    atBottom: boolean;
+}
+/** Anchor → topRow, run once per frame after the line index rebuild (§5.3). */
+export declare function resolveTopRow(s: ScrollState, ctx: ScrollCtx): Resolved;
+/** Badge label per §7.2. Empty string = hidden. */
+export declare function badgeLabel(atBottom: boolean, newSinceUnstick: number, idle: boolean): string;

package/dist/tui/scroll-model.js

@@ -0,0 +1,96 @@
+/**
+ * scroll.md §5 — Anchor-based scroll model (pure, no React).
+ *
+ * Position is an Anchor ({itemId, lineInItem}), never a raw row index (I4),
+ * so resizes, group expand/collapse, and compaction never make the view jump.
+ * While anchored to 'bottom', new output follows; the instant the user scrolls
+ * up the anchor pins to an item and freezes, accumulating newSinceUnstick
+ * display lines for the `↓ N new` badge (§7).
+ */
+export const FOLLOW_EPSILON = 1; // within 1 line of bottom counts as "at bottom" (§13)
+export const initialScroll = {
+    anchor: { mode: 'bottom' },
+    userScrolled: false,
+    newSinceUnstick: 0,
+};
+function clampN(n, lo, hi) {
+    return Math.max(lo, Math.min(hi, n));
+}
+export function maxTopFor(ctx) {
+    return Math.max(0, ctx.total - ctx.viewportH);
+}
+function stickBottom() {
+    return { anchor: { mode: 'bottom' }, userScrolled: false, newSinceUnstick: 0 };
+}
+function pinAt(s, ctx, row) {
+    const maxTop = maxTopFor(ctx);
+    const top = clampN(row, 0, maxTop);
+    if (top >= maxTop - FOLLOW_EPSILON)
+        return stickBottom();
+    if (ctx.count === 0)
+        return stickBottom();
+    const i = clampN(ctx.indexAt(top), 0, ctx.count - 1);
+    return {
+        anchor: { mode: 'pinned', itemId: ctx.keyOf(i), lineInItem: top - ctx.offsetOf(i) },
+        userScrolled: true,
+        newSinceUnstick: s.newSinceUnstick,
+    };
+}
+export function scrollReducer(s, a, ctx) {
+    const maxTop = maxTopFor(ctx);
+    // current resolved top (anchor may predate this frame's measurements)
+    const cur = resolveTopRow(s, ctx).topRow;
+    switch (a.type) {
+        case 'BY_LINES':
+            return pinAt(s, ctx, cur + a.delta);
+        case 'BY_PAGE':
+            return pinAt(s, ctx, cur + a.dir * (ctx.viewportH - 1)); // 1-line overlap
+        case 'BY_HALF_PAGE':
+            return pinAt(s, ctx, cur + a.dir * Math.floor(ctx.viewportH / 2));
+        case 'TO_TOP':
+            return pinAt(s, ctx, 0);
+        case 'TO_BOTTOM':
+            return stickBottom();
+        case 'CONTENT_GREW':
+            if (a.lines <= 0) {
+                // tail shrank/rewrote (§12): keep anchor, recompute, don't count
+                return { ...s };
+            }
+            if (s.anchor.mode === 'bottom') {
+                // follow — keep the counter clean; topRow derives from maxTop
+                return { ...s, newSinceUnstick: 0 };
+            }
+            void maxTop;
+            return { ...s, newSinceUnstick: s.newSinceUnstick + a.lines };
+        case 'REFLOW':
+            return { ...s };
+    }
+}
+/** Anchor → topRow, run once per frame after the line index rebuild (§5.3). */
+export function resolveTopRow(s, ctx) {
+    const maxTop = maxTopFor(ctx);
+    if (s.anchor.mode === 'bottom')
+        return { topRow: maxTop, atBottom: true };
+    let i = -1;
+    for (let k = 0; k < ctx.count; k++) {
+        if (ctx.keyOf(k) === s.anchor.itemId) {
+            i = k;
+            break;
+        }
+    }
+    if (i === -1)
+        return { topRow: maxTop, atBottom: true }; // pruned → re-stick (§12)
+    const raw = ctx.offsetOf(i) + Math.max(0, s.anchor.lineInItem);
+    const topRow = clampN(raw, 0, maxTop);
+    return { topRow, atBottom: topRow >= maxTop - FOLLOW_EPSILON };
+}
+/** Badge label per §7.2. Empty string = hidden. */
+export function badgeLabel(atBottom, newSinceUnstick, idle) {
+    if (atBottom || newSinceUnstick <= 0)
+        return '';
+    if (idle)
+        return '↓ jump to end';
+    if (newSinceUnstick >= 1000)
+        return '↓ 999+ new';
+    return `↓ ${newSinceUnstick} new`;
+}

package/package.json

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