@ouro.bot/cli 0.1.0-alpha.60 → 0.1.0-alpha.601

package/dist/senses/cli/ink-app.js

@@ -0,0 +1,156 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InkApp = InkApp;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = __importStar(require("react"));
+const ink_1 = require("ink");
+const streaming_markdown_1 = require("./streaming-markdown");
+/**
+ * Ouroboros CLI TUI — Ink application shell.
+ *
+ * Replaces the imperative readline-based CLI with a React/Ink component tree.
+ * Provides: message list, input area, spinner, tool result display.
+ *
+ * Design: Ouroboros-themed (green serpent), NOT Claude/Anthropic design language.
+ * Copy-paste integrity: no padding characters. Visual hierarchy via color/bold/dim only.
+ */
+// Ouroboros brand palette
+const OURO_GREEN = "#2ecc40";
+const OURO_TEAL = "#4ec9b0";
+const OURO_DIM = true;
+// Snake-themed spinner frames: serpent eating its own tail
+const SNAKE_FRAMES = [
+    "\u{1F40D}\u2003", // snake emoji
+    "\u25E0\u2003", // upper half circle
+    "\u25D4\u2003", // circle with upper right quadrant
+    "\u25D1\u2003", // circle with right half
+    "\u25D5\u2003", // circle with all but upper left quadrant
+    "\u25E1\u2003", // lower half circle
+    "\u{1F40D}\u2003", // snake emoji again
+    "\u25CB\u2003", // white circle (tail eaten)
+];
+function UserMessage({ content }) {
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { children: [(0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO_TEAL, bold: true, children: ") " }), (0, jsx_runtime_1.jsx)(ink_1.Text, { children: content })] }));
+}
+function AssistantMessage({ content }) {
+    return ((0, jsx_runtime_1.jsx)(ink_1.Box, { children: (0, jsx_runtime_1.jsx)(streaming_markdown_1.StreamingMarkdown, { text: content }) }));
+}
+function ToolCallDisplay({ toolCall }) {
+    let argSummary = "";
+    try {
+        const args = JSON.parse(toolCall.function.arguments);
+        const first = Object.values(args)[0];
+        if (typeof first === "string")
+            argSummary = first.length > 60 ? first.slice(0, 57) + "..." : first;
+    }
+    catch {
+        argSummary = toolCall.function.arguments.slice(0, 60);
+    }
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { children: [(0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO_GREEN, bold: true, children: toolCall.function.name }), argSummary ? (0, jsx_runtime_1.jsxs)(ink_1.Text, { dimColor: true, children: [" ", argSummary] }) : null] }));
+}
+function ToolResultDisplay({ result }) {
+    const color = result.success ? OURO_GREEN : "#e74c3c";
+    const icon = result.success ? "\u2713" : "\u2717";
+    const summary = result.result.length > 120
+        ? result.result.slice(0, 117) + "..."
+        : result.result;
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { children: [(0, jsx_runtime_1.jsxs)(ink_1.Text, { color: color, children: [icon, " ", result.name] }), (0, jsx_runtime_1.jsxs)(ink_1.Text, { dimColor: true, children: [" ", summary.replace(/\n/g, " ")] })] }));
+}
+function SpinnerComponent({ text, frame }) {
+    const char = SNAKE_FRAMES[frame % SNAKE_FRAMES.length];
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { children: [(0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO_GREEN, children: char }), (0, jsx_runtime_1.jsxs)(ink_1.Text, { dimColor: OURO_DIM, children: [text, "..."] })] }));
+}
+function InputArea({ onSubmit, }) {
+    const [input, setInput] = (0, react_1.useState)("");
+    // Ref tracks the latest input value so useInput callback always sees current state
+    const inputRef = (0, react_1.useRef)("");
+    (0, ink_1.useInput)((inputChar, key) => {
+        if (key.return) {
+            if (inputRef.current.trim() && onSubmit) {
+                onSubmit(inputRef.current);
+            }
+            inputRef.current = "";
+            setInput("");
+            return;
+        }
+        if (key.backspace || key.delete) {
+            inputRef.current = inputRef.current.slice(0, -1);
+            setInput(inputRef.current);
+            return;
+        }
+        if (!key.ctrl && !key.meta && inputChar) {
+            inputRef.current += inputChar;
+            setInput(inputRef.current);
+        }
+    });
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { children: [(0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO_TEAL, bold: true, children: ") " }), (0, jsx_runtime_1.jsx)(ink_1.Text, { children: input })] }));
+}
+function MessageList({ messages, toolResults, }) {
+    const toolResultMap = new Map();
+    if (toolResults) {
+        for (const tr of toolResults) {
+            toolResultMap.set(tr.toolCallId, tr);
+        }
+    }
+    return ((0, jsx_runtime_1.jsx)(ink_1.Box, { flexDirection: "column", children: messages.map((msg, i) => {
+            if (msg.role === "user" && msg.content) {
+                return (0, jsx_runtime_1.jsx)(UserMessage, { content: msg.content }, i);
+            }
+            if (msg.role === "assistant") {
+                return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", children: [msg.content ? (0, jsx_runtime_1.jsx)(AssistantMessage, { content: msg.content }) : null, msg.tool_calls?.map(tc => {
+                            const tr = toolResultMap.get(tc.id);
+                            return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", children: [(0, jsx_runtime_1.jsx)(ToolCallDisplay, { toolCall: tc }), tr ? (0, jsx_runtime_1.jsx)(ToolResultDisplay, { result: tr }) : null] }, tc.id));
+                        })] }, i));
+            }
+            return null;
+        }) }));
+}
+function InkApp({ messages, onSubmit, loading, spinnerText, toolResults, }) {
+    const [spinnerFrame, setSpinnerFrame] = (0, react_1.useState)(0);
+    // Animate spinner
+    react_1.default.useEffect(() => {
+        if (!loading)
+            return;
+        const iv = setInterval(() => {
+            setSpinnerFrame(f => (f + 1) % SNAKE_FRAMES.length);
+        }, 120);
+        return () => clearInterval(iv);
+    }, [loading]);
+    const handleSubmit = (0, react_1.useCallback)((text) => {
+        onSubmit?.(text);
+    }, [onSubmit]);
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", children: [(0, jsx_runtime_1.jsx)(MessageList, { messages: messages, toolResults: toolResults }), loading && spinnerText ? ((0, jsx_runtime_1.jsx)(SpinnerComponent, { text: spinnerText, frame: spinnerFrame })) : null, (0, jsx_runtime_1.jsx)(InputArea, { onSubmit: handleSubmit })] }));
+}

package/dist/senses/cli/inline-diff.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InlineDiff = InlineDiff;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const ink_1 = require("ink");
+// Ouroboros brand colors
+const OURO_GREEN = "#2ecc40"; // added lines -- serpent green
+const OURO_RED = "#e74c3c"; // removed lines
+const OURO_HEADER = "#4ec9b0"; // file header -- teal
+const OURO_LINE_NUM = "gray"; // line numbers -- subtle
+/**
+ * Simple line-level diff algorithm (Myers-like via LCS).
+ * Produces a sequence of add/remove/context lines.
+ */
+function computeDiff(before, after) {
+    const oldLines = before ? before.split("\n") : [];
+    const newLines = after ? after.split("\n") : [];
+    // LCS-based diff
+    const m = oldLines.length;
+    const n = newLines.length;
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            if (oldLines[i - 1] === newLines[j - 1]) {
+                dp[i][j] = dp[i - 1][j - 1] + 1;
+            }
+            else {
+                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+            }
+        }
+    }
+    // Backtrack to build diff
+    const result = [];
+    let i = m;
+    let j = n;
+    while (i > 0 || j > 0) {
+        if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
+            result.unshift({ type: "context", content: oldLines[i - 1], oldNum: i, newNum: j });
+            i--;
+            j--;
+        }
+        else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+            result.unshift({ type: "add", content: newLines[j - 1], newNum: j });
+            j--;
+        }
+        else {
+            result.unshift({ type: "remove", content: oldLines[i - 1], oldNum: i });
+            i--;
+        }
+    }
+    return result;
+}
+function DiffLineComponent({ line }) {
+    const num = line.type === "remove" ? line.oldNum : line.newNum;
+    /* v8 ignore next -- defensive fallback; line numbers always present @preserve */
+    const lineNum = num !== undefined ? String(num) : "";
+    const prefix = line.type === "add" ? "+" : line.type === "remove" ? "-" : " ";
+    const color = line.type === "add" ? OURO_GREEN : line.type === "remove" ? OURO_RED : undefined;
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Text, { children: [(0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO_LINE_NUM, children: lineNum.padStart(4) }), (0, jsx_runtime_1.jsx)(ink_1.Text, { color: color, children: ` ${prefix} ${line.content}` })] }));
+}
+function InlineDiff({ before, after, filePath }) {
+    const diffLines = computeDiff(before, after);
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", children: [(0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO_HEADER, bold: true, children: filePath }), diffLines.map((line, i) => ((0, jsx_runtime_1.jsx)(DiffLineComponent, { line: line }, i)))] }));
+}

package/dist/senses/cli/input-keys.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleKillToEnd = handleKillToEnd;
+exports.handleKillToStart = handleKillToStart;
+exports.handleKillWordBack = handleKillWordBack;
+exports.handleYank = handleYank;
+exports.handleCursorLeft = handleCursorLeft;
+exports.handleCursorRight = handleCursorRight;
+exports.handleBackspace = handleBackspace;
+exports.handleForwardDelete = handleForwardDelete;
+exports.handleHome = handleHome;
+exports.handleEnd = handleEnd;
+exports.classifyEscapeSequence = classifyEscapeSequence;
+exports.handleYankPop = handleYankPop;
+exports.handleEmptyPaste = handleEmptyPaste;
+const runtime_1 = require("../../nerves/runtime");
+/**
+ * Ctrl+K: kill from cursor to end of line.
+ * Pushes killed text to ring with "append" direction.
+ */
+function handleKillToEnd(text, cursorPos, ring) {
+    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.input_kill", message: "kill to end", meta: { direction: "end" } });
+    if (cursorPos >= text.length) {
+        return { text, cursorPos };
+    }
+    const killed = text.slice(cursorPos);
+    ring.push(killed, "append");
+    return { text: text.slice(0, cursorPos), cursorPos };
+}
+/**
+ * Ctrl+U: kill from start of line to cursor.
+ * Pushes killed text to ring with "prepend" direction.
+ */
+function handleKillToStart(text, cursorPos, ring) {
+    if (cursorPos === 0) {
+        return { text, cursorPos };
+    }
+    const killed = text.slice(0, cursorPos);
+    ring.push(killed, "prepend");
+    return { text: text.slice(cursorPos), cursorPos: 0 };
+}
+/**
+ * Ctrl+W / Meta+Backspace: kill word before cursor.
+ * Pushes killed word to ring with "prepend" direction.
+ */
+function handleKillWordBack(text, cursorPos, ring) {
+    if (cursorPos === 0) {
+        return { text, cursorPos };
+    }
+    const before = text.slice(0, cursorPos);
+    const after = text.slice(cursorPos);
+    const wordStart = before.replace(/\s*\S+\s*$/, "");
+    const killed = before.slice(wordStart.length);
+    ring.push(killed, "prepend");
+    return { text: wordStart + after, cursorPos: wordStart.length };
+}
+/**
+ * Ctrl+Y: yank (paste) from kill ring at cursor.
+ * Returns null if ring is empty.
+ */
+function handleYank(text, cursorPos, ring) {
+    const yanked = ring.yank();
+    if (yanked === undefined)
+        return null;
+    const before = text.slice(0, cursorPos);
+    const after = text.slice(cursorPos);
+    return { text: before + yanked + after, cursorPos: cursorPos + yanked.length };
+}
+// ─── Emacs Cursor Navigation ─────────────────────────────────────
+/** Ctrl+B: move cursor left by 1. Returns new cursor position. */
+function handleCursorLeft(_text, cursorPos) {
+    return Math.max(0, cursorPos - 1);
+}
+/** Ctrl+F: move cursor right by 1. Returns new cursor position. */
+function handleCursorRight(text, cursorPos) {
+    return Math.min(text.length, cursorPos + 1);
+}
+/** Ctrl+H: backspace (delete char before cursor). */
+function handleBackspace(text, cursorPos) {
+    if (cursorPos === 0)
+        return { text, cursorPos };
+    const before = text.slice(0, cursorPos - 1);
+    const after = text.slice(cursorPos);
+    return { text: before + after, cursorPos: cursorPos - 1 };
+}
+/** Forward delete: delete char at cursor position. */
+function handleForwardDelete(text, cursorPos) {
+    if (cursorPos >= text.length)
+        return { text, cursorPos };
+    const before = text.slice(0, cursorPos);
+    const after = text.slice(cursorPos + 1);
+    return { text: before + after, cursorPos };
+}
+// ─── Home / End ──────────────────────────────────────────────────
+/** Home key: move cursor to position 0. Returns new cursor position. */
+function handleHome(_text, _cursorPos) {
+    return 0;
+}
+/** End key: move cursor to end of text. Returns new cursor position. */
+function handleEnd(text, _cursorPos) {
+    return text.length;
+}
+// ─── Escape Sequence Classification ──────────────────────────────
+/**
+ * Classify raw escape sequences that Ink passes through as regular characters.
+ * Returns:
+ *   "home"   — Home key sequences
+ *   "end"    — End key sequences
+ *   "ignore" — PageUp, PageDown, mouse wheel (should be suppressed)
+ *   null     — not a recognized escape sequence
+ */
+function classifyEscapeSequence(inputChar) {
+    if (!inputChar.startsWith("\x1b["))
+        return null;
+    const seq = inputChar.slice(2); // after \x1b[
+    // Home: \x1b[H or \x1b[1~
+    if (seq === "H" || seq === "1~")
+        return "home";
+    // End: \x1b[F or \x1b[4~
+    if (seq === "F" || seq === "4~")
+        return "end";
+    // Option+Left: \x1b[1;3D (CSI modified arrow with Alt modifier)
+    if (seq === "1;3D")
+        return "word-left";
+    // Option+Right: \x1b[1;3C
+    if (seq === "1;3C")
+        return "word-right";
+    // PageUp: \x1b[5~, PageDown: \x1b[6~
+    if (seq === "5~" || seq === "6~")
+        return "ignore";
+    // SGR mouse wheel: \x1b[<64;... or \x1b[<65;...
+    if (seq.startsWith("<64;") || seq.startsWith("<65;"))
+        return "ignore";
+    return null;
+}
+/**
+ * Alt+Y: yank-pop -- replace previously yanked text with next ring entry.
+ * Returns null if not in yanking state or ring is empty.
+ */
+function handleYankPop(text, cursorPos, ring) {
+    const lastYanked = ring.lastYankedText;
+    if (!ring.isYanking || lastYanked === undefined)
+        return null;
+    const popped = ring.yankPop();
+    if (popped === undefined)
+        return null;
+    // Find where the last yanked text ends (at current cursor position)
+    // and starts (cursorPos - lastYanked.length)
+    const yankStart = cursorPos - lastYanked.length;
+    const before = text.slice(0, yankStart);
+    const after = text.slice(cursorPos);
+    return { text: before + popped + after, cursorPos: yankStart + popped.length };
+}
+/**
+ * Handle an empty paste event by checking clipboard for images (macOS only).
+ * Returns null if no image found, not on macOS, or clipboard empty.
+ */
+async function handleEmptyPaste(text, cursorPos, currentImageCount, platform, clipboardReader) {
+    if (platform !== "darwin")
+        return null;
+    const imageData = await clipboardReader();
+    if (!imageData)
+        return null;
+    const refNum = currentImageCount + 1;
+    const ref = `[Image #${refNum}]`;
+    const before = text.slice(0, cursorPos);
+    const after = text.slice(cursorPos);
+    return {
+        text: before + ref + after,
+        cursorPos: cursorPos + ref.length,
+        imageRef: refNum,
+        imageData,
+    };
+}

package/dist/senses/cli/kill-ring.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KillRing = void 0;
+/**
+ * Kill ring — emacs-style cut buffer with accumulation and yank-pop cycling.
+ *
+ * Stores up to MAX_SIZE killed text entries. Consecutive kills in the same
+ * direction accumulate into a single entry. Yank retrieves the most recent
+ * entry; yank-pop cycles backward through the ring.
+ */
+const runtime_1 = require("../../nerves/runtime");
+const MAX_SIZE = 10;
+class KillRing {
+    entries = [];
+    accumulating = false;
+    yankIndex = -1;
+    _isYanking = false;
+    _lastYankedText = undefined;
+    /** Whether the ring is currently in yank-cycling mode. */
+    get isYanking() {
+        return this._isYanking;
+    }
+    /** The text that was last returned by yank() or yankPop(). */
+    get lastYankedText() {
+        return this._lastYankedText;
+    }
+    /**
+     * Push killed text onto the ring.
+     *
+     * If accumulating (consecutive kills without a reset), the text is merged
+     * with the top entry: "append" concatenates to the end, "prepend" prepends
+     * to the start. Otherwise a new entry is created, evicting the oldest if
+     * the ring is full.
+     */
+    push(text, direction) {
+        (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.kill_ring_push", message: "killed text to ring", meta: { direction, length: text.length } });
+        if (this.accumulating && this.entries.length > 0) {
+            const top = this.entries[this.entries.length - 1];
+            this.entries[this.entries.length - 1] =
+                direction === "append" ? top + text : text + top;
+        }
+        else {
+            if (this.entries.length >= MAX_SIZE) {
+                this.entries.shift();
+            }
+            this.entries.push(text);
+        }
+        this.accumulating = true;
+    }
+    /**
+     * Return the most recent kill ring entry and enter yanking mode.
+     * Returns undefined if the ring is empty.
+     */
+    yank() {
+        if (this.entries.length === 0)
+            return undefined;
+        this.yankIndex = this.entries.length - 1;
+        this._isYanking = true;
+        this._lastYankedText = this.entries[this.yankIndex];
+        return this._lastYankedText;
+    }
+    /**
+     * Cycle to the next older entry in the ring (wrapping around).
+     * Must be called after yank(). Returns undefined if ring is empty
+     * or not in yanking state.
+     */
+    yankPop() {
+        if (!this._isYanking || this.entries.length === 0)
+            return undefined;
+        this.yankIndex =
+            (this.yankIndex - 1 + this.entries.length) % this.entries.length;
+        this._lastYankedText = this.entries[this.yankIndex];
+        return this._lastYankedText;
+    }
+    /** Stop consecutive-kill accumulation (called on non-kill keystrokes). */
+    resetAccumulation() {
+        this.accumulating = false;
+    }
+    /** Exit yank-cycling mode (called on non-yank keystrokes). */
+    resetYankState() {
+        this._isYanking = false;
+        this._lastYankedText = undefined;
+        this.yankIndex = -1;
+    }
+}
+exports.KillRing = KillRing;

package/dist/senses/cli/message-list.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScrollableMessageList = ScrollableMessageList;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const ink_1 = require("ink");
+const streaming_markdown_1 = require("./streaming-markdown");
+/**
+ * Scrollable message list with virtual rendering.
+ *
+ * Only renders messages within the viewport window. Supports:
+ * - Auto-scroll to bottom (pinned mode, default)
+ * - Scroll lock at a specific offset
+ * - "N below" indicator when scrolled up
+ *
+ * Ouroboros-themed: green serpent palette, no padding decoration.
+ */
+// Ouroboros brand palette
+const OURO_TEAL = "#4ec9b0";
+const OURO_INDICATOR = "#2ecc40";
+function MessageItem({ message }) {
+    if (message.role === "user" && message.content) {
+        return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { children: [(0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO_TEAL, bold: true, children: ") " }), (0, jsx_runtime_1.jsx)(ink_1.Text, { children: message.content })] }));
+    }
+    if (message.role === "assistant" && message.content) {
+        return (0, jsx_runtime_1.jsx)(streaming_markdown_1.StreamingMarkdown, { text: message.content });
+    }
+    // system or empty messages render nothing visible
+    return (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" });
+}
+function ScrollableMessageList({ messages, viewportHeight, scrollOffset, }) {
+    const { visibleMessages, belowCount } = (0, react_1.useMemo)(() => {
+        if (messages.length === 0) {
+            return { visibleMessages: [], belowCount: 0 };
+        }
+        let start;
+        if (scrollOffset !== undefined) {
+            start = Math.max(0, Math.min(scrollOffset, messages.length - 1));
+        }
+        else {
+            // Auto-scroll: pin to bottom
+            start = Math.max(0, messages.length - viewportHeight);
+        }
+        const end = Math.min(start + viewportHeight, messages.length);
+        return {
+            visibleMessages: messages.slice(start, end),
+            belowCount: messages.length - end,
+        };
+    }, [messages, viewportHeight, scrollOffset]);
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", children: [visibleMessages.map((msg, i) => ((0, jsx_runtime_1.jsx)(MessageItem, { message: msg }, i))), belowCount > 0 ? ((0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO_INDICATOR, dimColor: true, children: `${belowCount} below` })) : null] }));
+}