@ouro.bot/cli 0.1.0-alpha.55 → 0.1.0-alpha.550

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