@orbit-intelligence/orbit-agent 0.3.12

package/dist/src/tui/app.js

@@ -0,0 +1,768 @@
+import React from 'react';
+import { render } from 'ink';
+import { providerNames } from '../config/config-schema.js';
+import { makeTheme, THEME_NAMES } from './themes/index.js';
+import { AppStore, ASK_OPTIONS } from './store.js';
+import { InkApp } from './InkApp.js';
+export class TuiApp {
+    store = new AppStore();
+    theme;
+    onSubmit;
+    onCommand;
+    version;
+    config;
+    bus;
+    models;
+    instance = null;
+    done = false;
+    /** Last dispatched key (sig + timestamp) for de-duping keyboard repeats. */
+    lastKey = null;
+    /** Paces the streaming reveal cursor so output reads word-to-word. */
+    revealTimer = null;
+    constructor(opts) {
+        this.config = opts.config;
+        this.bus = opts.bus;
+        this.onSubmit = opts.onSubmit;
+        this.onCommand = opts.onCommand ?? (async () => null);
+        this.version = opts.version;
+        this.models = opts.models ?? [];
+        this.theme = makeTheme(opts.config.theme);
+        this.store.version = opts.version;
+        this.store.cwd = process.cwd();
+        this.store.theme = this.theme;
+        this.store.models = [...this.models];
+        this.store.thinkingDefaultOpen = opts.config.ui.showThinking ?? true;
+        this.store.yolo = opts.config.permissions.mode === 'allow';
+        this.subscribeBus();
+    }
+    run() {
+        const ctrl = {
+            store: this.store,
+            handleKey: (input, key) => this.handleKey(input, key),
+            refresh: () => this.store.refresh(),
+        };
+        this.instance = render(React.createElement(InkApp, { controller: ctrl }), {
+            // Alternate screen (like opencode/OpenTUI): swaps in a clean frame on
+            // start and restores the user's shell content on exit. Native scrollback
+            // would require committing rows via <Static>; kept as a future option.
+            alternateScreen: true,
+            exitOnCtrlC: false,
+            patchConsole: false,
+        });
+        // Word-pacing tick: advance the reveal cursor while a turn is streaming
+        // and redraw only when the visible content moved.
+        this.revealTimer = setInterval(() => {
+            if (this.store.advanceReveal())
+                this.store.refresh();
+        }, 120);
+    }
+    destroy() {
+        if (this.revealTimer != null) {
+            clearInterval(this.revealTimer);
+            this.revealTimer = null;
+        }
+        if (this.done)
+            return;
+        this.done = true;
+        this.instance?.unmount();
+        this.instance = null;
+    }
+    exit(code) {
+        this.destroy();
+        setImmediate(() => process.exit(code));
+    }
+    pushMessage(msg) {
+        this.store.messages.push(msg);
+        this.store.scrollOffset = 0;
+        this.store.refresh();
+    }
+    getMessages() {
+        return this.store.messages;
+    }
+    ask(prompt) {
+        return new Promise((resolve) => {
+            this.store.pendingAsk = { prompt, index: 0, resolve };
+            this.store.input.clear();
+            this.store.refresh();
+        });
+    }
+    // ------------------------------------------------------------------
+    // Event bus subscription
+    // ------------------------------------------------------------------
+    subscribeBus() {
+        this.bus.on('onAssistantStart', (msg) => {
+            this.store.streaming = true;
+            this.store.cancelArmed = false;
+            this.store.beginStream();
+            if (this.store.planningTurn && this.store.plan) {
+                msg.isPlan = true;
+            }
+            this.pushMessage(msg);
+        });
+        this.bus.on('onToken', (text) => {
+            this.store.outputTokens += 1;
+            // The agent loop already streams into the same ChatMessage object that
+            // lives in this.store.messages — appending again here would double every
+            // token. Only mark it live and re-render.
+            const msg = this.store.findStreaming();
+            if (msg) {
+                msg.streaming = true;
+            }
+            void text;
+            this.store.refresh();
+        });
+        this.bus.on('onThinking', (text) => {
+            // Same shared-object semantics as onToken: the loop appends to
+            // msg.reasoning directly; we just re-render.
+            void text;
+            this.store.refresh();
+        });
+        this.bus.on('onToolStart', (call) => {
+            const msg = this.store.findStreaming();
+            if (msg) {
+                msg.toolCalls = [...(msg.toolCalls ?? []), call];
+            }
+            this.store.refresh();
+        });
+        this.bus.on('onToolUpdate', (call) => this.applyToolState(call));
+        this.bus.on('onToolEnd', (call) => this.applyToolState(call));
+        this.bus.on('onAssistantEnd', (msg) => {
+            this.store.streaming = false;
+            this.store.cancelArmed = false;
+            this.store.revealAll();
+            const idx = this.store.messages.findIndex((m) => m.id === msg.id);
+            if (idx >= 0)
+                this.store.messages[idx] = msg;
+            // Capture a finished plan proposal so /run can execute it.
+            if (this.store.planningTurn && this.store.plan) {
+                this.store.plan.text = msg.content;
+                this.store.plan.status = 'proposed';
+                this.store.planningTurn = false;
+                this.bus.emit('onPlanProposed', { text: msg.content, task: this.store.plan.task });
+            }
+            this.store.refresh();
+        });
+        this.bus.on('onRoute', (status) => {
+            this.store.route = status;
+            if (!this.store.greeted) {
+                this.store.greeted = true;
+                this.pushMessage({
+                    id: 'greeting',
+                    role: 'system',
+                    content: `orbit-agent v${this.version} · route ${status.provider}/${status.model} · ${status.strategy}. Type /help for commands.`,
+                    createdAt: Date.now(),
+                });
+            }
+            this.store.refresh();
+        });
+        this.bus.on('onError', (err) => {
+            this.store.streaming = false;
+            this.store.cancelArmed = false;
+            this.store.revealAll();
+            this.pushMessage({
+                id: `err-${Date.now()}`,
+                role: 'assistant',
+                content: `**Error:** ${err.message}`,
+                error: err.message,
+                createdAt: Date.now(),
+            });
+        });
+        // Diff review: attach captured file diffs to the in-flight assistant turn.
+        this.bus.on('onFileDiff', (d) => {
+            const msg = this.store.findStreaming() ?? this.lastAssistant();
+            if (msg) {
+                msg.diffs = [...(msg.diffs ?? []), d];
+            }
+            this.store.refresh();
+        });
+        // Plan mode lifecycle.
+        this.bus.on('onPlanProposed', ({ text }) => {
+            const plan = this.store.plan;
+            if (plan) {
+                plan.text = text;
+                plan.status = 'proposed';
+                this.store.planningTurn = false;
+            }
+            this.store.refresh();
+        });
+        this.bus.on('onUserMessage', (msg) => {
+            // The plan-mode/execute wrappers are scaffolding for the model — show the
+            // user a clean version of their turn instead.
+            if (msg.content.startsWith('[PLAN MODE]') || msg.content.startsWith('[EXECUTE]')) {
+                const taskMatch = msg.content.match(/Task:\s*([^\n]+)/);
+                if (taskMatch)
+                    msg.content = taskMatch[1];
+            }
+            this.pushMessage(msg);
+        });
+        // Orchestration events → agent dock state
+        this.bus.on('onAgentStart', (detail) => {
+            this.store.agents.set(detail.role, { id: detail.role, name: detail.role, status: 'thinking', task: detail.task });
+            this.store.refresh();
+        });
+        this.bus.on('onAgentStatus', (s) => {
+            this.store.agents.set(s.id, { id: s.id, name: s.name, status: s.status });
+            this.store.refresh();
+        });
+        this.bus.on('onAgentEnd', (detail) => {
+            this.store.agents.set(detail.role, { id: detail.role, name: detail.role, status: 'done', task: detail.summary });
+            this.store.refresh();
+        });
+    }
+    applyToolState(call) {
+        const msg = this.store.findStreaming();
+        if (msg && msg.toolCalls) {
+            const idx = msg.toolCalls.findIndex((c) => c.id === call.id);
+            if (idx >= 0)
+                msg.toolCalls[idx] = call;
+            else
+                msg.toolCalls = [...msg.toolCalls, call];
+        }
+        this.store.refresh();
+    }
+    lastAssistant() {
+        for (let i = this.store.messages.length - 1; i >= 0; i--) {
+            const m = this.store.messages[i];
+            if (m?.role === 'assistant')
+                return m;
+        }
+        return undefined;
+    }
+    /** Toggle the inline diff view on the most recent message with diffs. */
+    toggleDiffs() {
+        for (let i = this.store.messages.length - 1; i >= 0; i--) {
+            const m = this.store.messages[i];
+            if (m && m.diffs && m.diffs.length > 0) {
+                m.diffsOpen = !m.diffsOpen;
+                this.store.refresh();
+                return;
+            }
+        }
+        this.note('No file diffs captured yet in this session.');
+    }
+    // ------------------------------------------------------------------
+    // Keyboard (ink input key handler)
+    // ------------------------------------------------------------------
+    handleKey = (input, key) => {
+        if (this.done)
+            return;
+        // Android/Termux keyboards occasionally deliver the same key twice in a
+        // burst (no keyup). Treat an identical repeat within one debounce window
+        // as a single press so text does not double up and typing feels smooth.
+        if (this.isKeyRepeat(input, key))
+            return;
+        const store = this.store;
+        // Model picker intercepts all keys while open
+        if (store.modelPicker.open) {
+            this.handleModelPickerKey(input, key);
+            return;
+        }
+        // Ctrl-C: cancel stream then exit
+        if (key.ctrl && input === 'c') {
+            if (store.streaming) {
+                if (store.cancelArmed)
+                    this.exit(130);
+                store.cancelArmed = true;
+                this.requestCancel();
+            }
+            else if (store.pendingAsk) {
+                const { resolve } = store.pendingAsk;
+                store.pendingAsk = null;
+                resolve(false);
+                store.refresh();
+            }
+            else {
+                this.exit(130);
+            }
+            return;
+        }
+        // Escape: cancel / deny ask / clear
+        if (key.escape) {
+            if (store.streaming) {
+                store.cancelArmed = true;
+                this.requestCancel();
+            }
+            else if (store.pendingAsk) {
+                const { resolve } = store.pendingAsk;
+                store.pendingAsk = null;
+                resolve(false);
+                store.refresh();
+            }
+            else if (store.input.currentBuffer() !== '') {
+                store.input.clear();
+                store.refresh();
+            }
+            return;
+        }
+        // Permission overlay: navigate with arrows, confirm with Enter / y / n.
+        if (store.pendingAsk) {
+            const ask = store.pendingAsk;
+            if (key.upArrow || key.leftArrow || key.downArrow || key.rightArrow) {
+                const dir = key.upArrow || key.leftArrow ? -1 : 1;
+                ask.index = (ask.index + dir + ASK_OPTIONS.length) % ASK_OPTIONS.length;
+                store.refresh();
+            }
+            else if (key.return) {
+                const ok = ask.index === 0;
+                store.pendingAsk = null;
+                ask.resolve(ok);
+                store.refresh();
+            }
+            else if (input === 'y' || input === 'Y') {
+                store.pendingAsk = null;
+                ask.resolve(true);
+                store.refresh();
+            }
+            else if (input === 'n' || input === 'N') {
+                store.pendingAsk = null;
+                ask.resolve(false);
+                store.refresh();
+            }
+            return;
+        }
+        // Scrolling even while streaming
+        if (key.pageUp) {
+            this.scrollUp();
+            return;
+        }
+        if (key.pageDown) {
+            this.scrollDown();
+            return;
+        }
+        // Toggle thinking block (Ctrl-T so bare letters stay typeable)
+        if (key.ctrl && input === 't') {
+            const msg = store.findStreaming() ?? store.messages[store.messages.length - 1];
+            if (msg) {
+                msg.reasoningOpen = !msg.reasoningOpen;
+                store.refresh();
+            }
+            return;
+        }
+        // Toggle diff view (Ctrl-D; only when not streaming)
+        if (key.ctrl && input === 'd' && !store.streaming) {
+            this.toggleDiffs();
+            return;
+        }
+        // Ctrl-O toggle agent dock (moved off Ctrl-T to free it for thinking)
+        if (key.ctrl && input === 'o') {
+            store.dockOpen = !store.dockOpen;
+            store.refresh();
+            return;
+        }
+        // While streaming or pending ask: no editing
+        if (store.streaming || store.pendingAsk)
+            return;
+        // Paste (multi-char input)
+        if (input.length > 1 && !key.ctrl && !key.meta) {
+            store.input.insertChar(input);
+            store.refresh();
+            return;
+        }
+        // Enter / Shift-Enter
+        if (key.return) {
+            if (key.shift) {
+                store.input.insertNewline();
+                store.refresh();
+                return;
+            }
+            this.handleEnter();
+            return;
+        }
+        // Tab slash autocomplete
+        if (key.tab && !key.shift && store.input.currentBuffer().startsWith('/')) {
+            this.handleTabAutocomplete();
+            return;
+        }
+        // Control keys
+        if (key.ctrl && input) {
+            switch (input) {
+                case 'a':
+                    store.input.moveToStart();
+                    break;
+                case 'e':
+                    store.input.moveToEnd();
+                    break;
+                case 'k':
+                    store.input.deleteToEnd();
+                    break;
+                case 'u':
+                    store.input.deleteToStart();
+                    break;
+                case 'w':
+                    store.input.deleteWordBack();
+                    break;
+            }
+            store.refresh();
+            return;
+        }
+        // Shift-Tab: delete word back (legacy)
+        if (key.tab && key.shift) {
+            store.input.deleteWordBack();
+            store.refresh();
+            return;
+        }
+        if (key.backspace) {
+            store.input.backspace();
+            store.refresh();
+            return;
+        }
+        if (key.delete) {
+            store.input.delete();
+            store.refresh();
+            return;
+        }
+        if (key.leftArrow) {
+            store.input.moveLeft();
+            store.refresh();
+            return;
+        }
+        if (key.rightArrow) {
+            store.input.moveRight();
+            store.refresh();
+            return;
+        }
+        if (key.upArrow) {
+            store.input.moveUp();
+            store.refresh();
+            return;
+        }
+        if (key.downArrow) {
+            store.input.moveDown();
+            store.refresh();
+            return;
+        }
+        if (key.home) {
+            store.input.moveToStart();
+            store.refresh();
+            return;
+        }
+        if (key.end) {
+            store.input.moveToEnd();
+            store.refresh();
+            return;
+        }
+        // Printable characters
+        if (input && !key.ctrl && !key.meta) {
+            store.input.insertChar(input);
+            store.refresh();
+        }
+    };
+    isKeyRepeat(input, key) {
+        if (key.eventType === 'repeat')
+            return true;
+        const flags = [
+            'upArrow', 'downArrow', 'leftArrow', 'rightArrow',
+            'pageUp', 'pageDown', 'home', 'end', 'return', 'escape',
+            'tab', 'backspace', 'delete',
+        ]
+            .filter((f) => key[f])
+            .join('|');
+        const sig = flags ? `${flags}|${input}` : input;
+        if (!sig)
+            return false;
+        const now = Date.now();
+        if (this.lastKey && this.lastKey.sig === sig && now - this.lastKey.at < 45) {
+            return true;
+        }
+        this.lastKey = { sig, at: now };
+        return false;
+    }
+    handleModelPickerKey(input, key) {
+        const store = this.store;
+        const list = store.models;
+        if (list.length === 0) {
+            store.modelPicker.open = false;
+            store.refresh();
+            return;
+        }
+        if (key.escape) {
+            store.modelPicker.open = false;
+            store.refresh();
+            return;
+        }
+        if (key.upArrow || (key.tab && key.shift)) {
+            store.modelPicker.index = (store.modelPicker.index - 1 + list.length) % list.length;
+            store.refresh();
+            return;
+        }
+        if (key.downArrow || key.tab) {
+            store.modelPicker.index = (store.modelPicker.index + 1) % list.length;
+            store.refresh();
+            return;
+        }
+        if (key.return) {
+            const chosen = list[store.modelPicker.index];
+            store.modelPicker.open = false;
+            store.refresh();
+            if (chosen)
+                void this.switchModel(chosen);
+            return;
+        }
+        if (input && !key.ctrl && !key.meta)
+            store.refresh();
+    }
+    handleTabAutocomplete() {
+        const buf = this.store.input.currentBuffer();
+        const token = buf.split(/\s+/)[0] ?? '';
+        const matches = this.store.slashMatches();
+        if (matches.length === 0)
+            return;
+        const common = longestCommonPrefix(matches.map((m) => m.cmd));
+        if (common.length > token.length) {
+            const argPart = buf.slice(token.length);
+            this.store.input.clear();
+            this.store.input.insertChar(common + argPart);
+            this.store.refresh();
+        }
+    }
+    requestCancel() {
+        this.bus.emit('onAbortRequest');
+        this.store.streaming = false;
+        this.store.revealAll();
+    }
+    handleEnter() {
+        const store = this.store;
+        if (store.pendingAsk) {
+            const answer = store.input.submitBuffer().trim().toLowerCase();
+            const ok = store.pendingAsk.index === 0 ? true : /^(y|yes|true|allow|sure)$/i.test(answer);
+            const { resolve } = store.pendingAsk;
+            store.pendingAsk = null;
+            resolve(ok);
+            store.refresh();
+            return;
+        }
+        const text = store.input.submitBuffer().trim();
+        if (text.length === 0) {
+            store.refresh();
+            return;
+        }
+        if (text.startsWith('/')) {
+            void this.handleSlash(text);
+            return;
+        }
+        this.onSubmit(text);
+        store.refresh();
+    }
+    // ------------------------------------------------------------------
+    // Slash commands
+    // ------------------------------------------------------------------
+    async handleSlash(raw) {
+        const [cmd, ...rest] = raw.slice(1).split(/\s+/);
+        const arg = rest.join(' ').trim();
+        const store = this.store;
+        switch (cmd) {
+            case 'exit':
+            case 'quit':
+                this.exit(0);
+                return;
+            case 'clear':
+                if (store.streaming)
+                    this.requestCancel();
+                store.messages = [];
+                store.scrollOffset = 0;
+                store.refresh();
+                return;
+            case 'help':
+                this.pushMessage({
+                    id: `help-${Date.now()}`,
+                    role: 'system',
+                    content: [
+                        `/exit /quit      leave orbit`,
+                        `/clear           clear the conversation`,
+                        `/help            show this help`,
+                        `/model [id]      pick a model (bare: interactive selector)`,
+                        `/provider <id>   switch provider (orbitx · groq · gemini · openrouter)`,
+                        `/plan <task>     plan first: propose a plan, approve with /run`,
+                        `/run             execute the proposed plan`,
+                        `/reject          discard the proposed plan`,
+                        `/diff            toggle unified diff view (or press d)`,
+                        `/skills          list project skills (AGENTS.md / .orbit/skills)`,
+                        `/theme <name>    change theme (${THEME_NAMES.join(' · ')})`,
+                        `/yolo            auto-approve tools`,
+                        `/yes             answer a permission prompt`,
+                        `/agents          toggle agent dock (orchestrate mode)`,
+                        ``,
+                        `Esc cancels the current stream. Ctrl-C cancels, then exits.`,
+                        `Ctrl-T toggles the thinking block; Ctrl-D toggles diff review;`,
+                        `Ctrl-O toggles the agent dock (orchestrate mode).`,
+                    ].join('\n'),
+                    createdAt: Date.now(),
+                });
+                return;
+            case 'plan': {
+                if (!arg) {
+                    this.note('Usage: /plan <task> — propose an implementation plan before executing.');
+                    return;
+                }
+                if (store.streaming) {
+                    this.note('Wait for the current turn to finish.');
+                    return;
+                }
+                // Switch to plan-then-approve mode. The wrapped prompt forces the
+                // model to investigate read-only and return a plan instead of acting.
+                store.plan = { task: arg, text: '', status: 'planning' };
+                store.planningTurn = true;
+                this.onSubmit(`[PLAN MODE] Task: ${arg}\n\nDo NOT modify any files or run any commands yet. Research the codebase (read_file, glob, grep, list_dir are allowed), then propose a concise, numbered implementation plan. End your plan with nothing else — say "Plan approved. Run /run to execute."`);
+                this.note(`Planning “${truncateForNote(arg)}”. Type /run to execute the plan, /reject to cancel.`);
+                return;
+            }
+            case 'run': {
+                const plan = store.plan;
+                if (!plan || plan.status === 'planning' || plan.status === 'rejected') {
+                    this.note('No approved plan pending. Start with /plan <task>.');
+                    return;
+                }
+                if (store.streaming) {
+                    this.note('Wait for the current turn to finish.');
+                    return;
+                }
+                plan.status = 'approved';
+                const task = plan.task;
+                store.planningTurn = false;
+                this.bus.emit('onPlanApproved', task);
+                this.onSubmit(`[EXECUTE] The plan you proposed for “${task}” is approved. Implement it now, using tools, and verify your work.`);
+                this.note(`Executing plan for “${truncateForNote(task)}”.`);
+                return;
+            }
+            case 'reject': {
+                if (!store.plan || store.plan.status === 'rejected') {
+                    this.note('No pending plan to reject.');
+                    return;
+                }
+                store.plan.status = 'rejected';
+                store.planningTurn = false;
+                this.bus.emit('onPlanRejected', store.plan.task);
+                this.note('Plan rejected. Nothing was executed.');
+                return;
+            }
+            case 'diff':
+                this.toggleDiffs();
+                return;
+            case 'skills': {
+                const list = store.skills;
+                if (list.length === 0) {
+                    this.note('No project skills found. Drop markdown files into .orbit/skills/ (or AGENTS.md) to teach orbit your conventions.');
+                }
+                else {
+                    this.note(`Project skills:${list.map((s) => `\n  ${s.name} — ${s.summary}`).join('')}`);
+                }
+                return;
+            }
+            case 'theme': {
+                const name = arg.toLowerCase().replace(/[ _]/g, '-');
+                if (!THEME_NAMES.includes(name)) {
+                    this.note(`Unknown theme "${arg}". Try: ${THEME_NAMES.join(', ')}`);
+                    return;
+                }
+                this.theme = makeTheme(name);
+                store.theme = this.theme;
+                this.config.theme = name;
+                void this.onCommand({ type: 'theme', value: name });
+                this.note(`Theme → ${name}`);
+                return;
+            }
+            case 'model':
+                if (!arg) {
+                    this.store.modelPicker.open = true;
+                    this.store.modelPicker.index = Math.max(0, this.models.findIndex((m) => m === this.store.route?.model || m.endsWith(`/${this.config.model.primary}`)));
+                    this.store.refresh();
+                    return;
+                }
+                await this.switchModel(arg);
+                return;
+            case 'provider':
+                await this.switchProvider(arg);
+                return;
+            case 'yolo':
+                await this.onCommand({ type: 'yolo' });
+                store.yolo = true;
+                this.note('Permission mode → allow (yolo).');
+                return;
+            case 'yes':
+                if (store.pendingAsk) {
+                    const { resolve } = store.pendingAsk;
+                    store.pendingAsk = null;
+                    resolve(true);
+                    store.refresh();
+                }
+                else {
+                    this.note('No pending prompt to confirm.');
+                }
+                return;
+            case 'agents':
+                store.dockOpen = !store.dockOpen;
+                this.note(store.dockOpen ? 'Agent dock opened.' : 'Agent dock closed.');
+                return;
+            default:
+                this.note(`Unknown command /${cmd}. Type /help.`);
+                return;
+        }
+    }
+    async switchModel(arg) {
+        if (!arg) {
+            const hint = this.models.slice(0, 8).join('  ');
+            this.note(`Usage: /model <id>${this.models.length > 0 ? `\nAvailable: ${hint}${this.models.length > 8 ? ' …' : ''}` : ''}`);
+            return;
+        }
+        const id = this.resolveModelId(arg);
+        if (!id) {
+            this.note(`No model matches "${arg}". Available: ${this.models.join(', ') || '(none)'}`);
+            return;
+        }
+        const result = await this.onCommand({ type: 'model', value: id });
+        if (result === null)
+            this.note(`Model → ${id}`);
+    }
+    resolveModelId(arg) {
+        if (this.models.includes(arg))
+            return arg;
+        const bare = arg.split('/').pop();
+        return this.models.find((x) => x === arg || x.split('/').pop() === bare || x.includes(arg)) ?? null;
+    }
+    async switchProvider(arg) {
+        const p = arg.toLowerCase();
+        if (!providerNames.includes(p)) {
+            this.note(`Unknown provider "${arg}". Try: ${providerNames.join(', ')}`);
+            return;
+        }
+        const result = await this.onCommand({ type: 'provider', value: p });
+        this.note(result ?? `Provider → ${p}`);
+    }
+    note(text) {
+        this.pushMessage({
+            id: `note-${Date.now()}`,
+            role: 'system',
+            content: text,
+            createdAt: Date.now(),
+        });
+    }
+    scrollUp() {
+        const vis = Math.max(10, this.store.messages.length); // viewport unknown here, rough estimate
+        this.store.scrollOffset = Math.min(this.store.scrollOffset + Math.max(3, Math.floor(vis / 2)), 5000);
+        this.store.refresh();
+    }
+    scrollDown() {
+        this.store.scrollOffset = Math.max(0, this.store.scrollOffset - Math.max(3, Math.floor(Math.max(10, this.store.messages.length) / 2)));
+        this.store.refresh();
+    }
+}
+function longestCommonPrefix(strings) {
+    if (strings.length === 0)
+        return '';
+    if (strings.length === 1)
+        return strings[0];
+    let prefix = '';
+    const first = strings[0];
+    for (let i = 0; i < first.length; i++) {
+        const ch = first[i];
+        if (strings.every((s) => s[i] === ch))
+            prefix += ch;
+        else
+            break;
+    }
+    return prefix;
+}
+function truncateForNote(text, max = 60) {
+    const t = text.replace(/\s+/g, ' ').trim();
+    return t.length <= max ? t : `${t.slice(0, max)}…`;
+}