@ouro.bot/cli 0.1.0-alpha.175 → 0.1.0-alpha.176

package/dist/senses/cli/tui-store.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TuiStore = void 0;
+exports.createTuiCallbacks = createTuiCallbacks;
+/**
+ * TUI Store — mutable external state for the OuroTui component.
+ *
+ * Tracks two buckets:
+ *   1. completedMessages — fed to Ink's <Static>, rendered once
+ *   2. live — current turn state, re-renders on change
+ *
+ * ZERO business logic. Just state + notify.
+ */
+const phrases_1 = require("../../mind/phrases");
+const format_1 = require("../../mind/format");
+const runtime_1 = require("../../nerves/runtime");
+class TuiStore {
+    _completed = [];
+    _live = {
+        streamingText: "",
+        loading: false,
+        spinnerPhrase: "",
+        spinnerPhrasePool: [],
+        activeTool: null,
+        errorMessage: null,
+        kickMessage: null,
+        inputSuppressed: false,
+    };
+    _spinnerStart = 0;
+    _hadTool = false;
+    _turnId = 0;
+    _listeners = new Set();
+    _headerShown = false;
+    _inputHistory = [];
+    get completedMessages() { return this._completed; }
+    get live() { return this._live; }
+    get headerShown() { return this._headerShown; }
+    get inputHistory() { return this._inputHistory; }
+    /** Elapsed seconds since spinner started — computed on demand, not stored */
+    getElapsed() {
+        if (this._live.loading && this._spinnerStart > 0) {
+            return Math.floor((Date.now() - this._spinnerStart) / 1000);
+        }
+        return 0;
+    }
+    subscribe(fn) {
+        this._listeners.add(fn);
+        return () => { this._listeners.delete(fn); };
+    }
+    notify() {
+        for (const fn of this._listeners)
+            fn();
+    }
+    // ─── Called by business logic (via callbacks) ───
+    modelStart() {
+        const phrases = (0, phrases_1.getPhrases)();
+        const pool = this._hadTool ? phrases.followup : phrases.thinking;
+        this._live = {
+            ...this._live,
+            loading: true,
+            spinnerPhrase: (0, phrases_1.pickPhrase)(pool),
+            spinnerPhrasePool: pool,
+            streamingText: "",
+            activeTool: null,
+            errorMessage: null,
+            kickMessage: null,
+        };
+        this._spinnerStart = Date.now();
+        this._turnId++;
+        this.notify();
+    }
+    appendText(text) {
+        this._live = {
+            ...this._live,
+            loading: false,
+            streamingText: this._live.streamingText + text,
+        };
+        this.notify();
+    }
+    clearText() {
+        this._live = { ...this._live, streamingText: "" };
+        this.notify();
+    }
+    toolStart(name, args) {
+        this._hadTool = true;
+        // Before showing tool in-progress, commit any buffered streaming text
+        // so it doesn't disappear when the live area switches to tool display
+        if (this._live.streamingText.trim()) {
+            this._completed = [...this._completed, {
+                    id: `asst-${this._turnId}-${Date.now()}`,
+                    role: "assistant",
+                    content: this._live.streamingText.trim(),
+                }];
+        }
+        this._live = {
+            ...this._live,
+            loading: true,
+            streamingText: "",
+            activeTool: { name, args },
+            spinnerPhrase: (0, phrases_1.pickPhrase)((0, phrases_1.getPhrases)().tool),
+            spinnerPhrasePool: (0, phrases_1.getPhrases)().tool,
+        };
+        this._spinnerStart = Date.now();
+        this.notify();
+    }
+    toolEnd(name, argSummary, success) {
+        // Move tool result to completed messages (so it renders via Static)
+        this._completed = [...this._completed, {
+                id: `tool-${this._turnId}-${Date.now()}`,
+                role: "tool",
+                content: "",
+                toolCalls: [{ name, argSummary, success }],
+            }];
+        this._live = {
+            ...this._live,
+            loading: false,
+            activeTool: null,
+        };
+        this.notify();
+    }
+    setError(msg) {
+        this._live = { ...this._live, loading: false, errorMessage: msg };
+        this.notify();
+    }
+    setKick() {
+        this._live = { ...this._live, loading: false, kickMessage: (0, format_1.formatKick)() };
+        this.notify();
+    }
+    suppressInput() {
+        this._live = { ...this._live, inputSuppressed: true };
+        this.notify();
+    }
+    restoreInput() {
+        this._live = { ...this._live, inputSuppressed: false };
+        this.notify();
+    }
+    /** Commit current streaming text as a completed assistant message */
+    commitAssistantMessage() {
+        if (this._live.streamingText.trim()) {
+            this._completed = [...this._completed, {
+                    id: `asst-${this._turnId}-${Date.now()}`,
+                    role: "assistant",
+                    content: this._live.streamingText.trim(),
+                }];
+        }
+        // Clear streaming text immediately — prevents double display
+        this._live = {
+            ...this._live,
+            loading: false,
+            streamingText: "",
+            activeTool: null,
+            errorMessage: null,
+            kickMessage: null,
+        };
+        this.notify();
+    }
+    /** Add a user message to completed (for display) AND input history */
+    addUserMessage(text) {
+        if (this._completed.length === 0) {
+            this._headerShown = false;
+        }
+        this._completed = [...this._completed, {
+                id: `user-${Date.now()}`,
+                role: "user",
+                content: text,
+            }];
+        this._inputHistory.push(text);
+        this.notify();
+    }
+    /** Seed input history from previous session messages (display only, no rendering) */
+    seedHistory(texts) {
+        this._inputHistory.push(...texts);
+    }
+}
+exports.TuiStore = TuiStore;
+// ─── Callbacks factory ──────────────────────────────────────────────
+function createTuiCallbacks(store) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.tui_callbacks_created",
+        message: "TUI callbacks created",
+        meta: {},
+    });
+    return {
+        onModelStart: () => { store.modelStart(); },
+        onModelStreamStart: () => { },
+        onClearText: () => { store.clearText(); },
+        onTextChunk: (text) => { store.appendText(text); },
+        onReasoningChunk: () => { },
+        onToolStart: (name, args) => { store.toolStart(name, args); },
+        onToolEnd: (name, argSummary, success) => { store.toolEnd(name, argSummary, success); },
+        onError: (error, severity) => {
+            store.setError(severity === "terminal" ? (0, format_1.formatError)(error) : error.message);
+        },
+        onKick: () => { store.setKick(); },
+        flushMarkdown: () => { store.commitAssistantMessage(); },
+    };
+}

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

@@ -0,0 +1,68 @@
+"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.VirtualList = VirtualList;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = __importStar(require("react"));
+const ink_1 = require("ink");
+function VirtualList({ items, viewportHeight, scrollOffset, renderItem, }) {
+    const { startIndex, visibleItems } = (0, react_1.useMemo)(() => {
+        if (items.length === 0) {
+            return { startIndex: 0, visibleItems: [] };
+        }
+        // Determine the start index for the visible window
+        let start;
+        if (scrollOffset !== undefined) {
+            // Scroll-locked: show items starting at the given offset
+            start = Math.max(0, Math.min(scrollOffset, items.length - 1));
+        }
+        else {
+            // Auto-scroll: pin to bottom, show last viewportHeight items
+            start = Math.max(0, items.length - viewportHeight);
+        }
+        const end = Math.min(start + viewportHeight, items.length);
+        return {
+            startIndex: start,
+            visibleItems: items.slice(start, end),
+        };
+    }, [items, viewportHeight, scrollOffset]);
+    if (visibleItems.length === 0) {
+        return (0, jsx_runtime_1.jsx)(ink_1.Box, { children: (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" }) });
+    }
+    return ((0, jsx_runtime_1.jsx)(ink_1.Box, { flexDirection: "column", children: visibleItems.map((item, i) => {
+            const globalIndex = startIndex + i;
+            return ((0, jsx_runtime_1.jsx)(ink_1.Box, { children: (0, jsx_runtime_1.jsx)(ink_1.Text, { children: renderItem(item, globalIndex) }) }, globalIndex));
+        }) }));
+}