@ouro.bot/cli 0.1.0-alpha.28 → 0.1.0-alpha.280

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] }));
+}