@zhive/cli 0.5.0

package/dist/commands/start/services/backtest/runner.js

@@ -0,0 +1,103 @@
+import { processMegathreadRound } from '../../../../shared/agent/analysis.js';
+import { initializeAgentRuntime } from '../../../../shared/agent/agent-runtime.js';
+/**
+ * Run a backtest against an agent configuration.
+ */
+export async function runBacktest(backtest, config, callbacks) {
+    const runtime = await initializeAgentRuntime(config.agentPath);
+    const threads = backtest.threads;
+    const results = [];
+    for (let i = 0; i < threads.length; i++) {
+        const thread = threads[i];
+        callbacks?.onThreadStart?.(i, threads.length, thread);
+        // Run megathread analysis
+        const defaultDurationMs = 3 * 60 * 60 * 1000; // 3h default backtest window
+        const analysisResult = await processMegathreadRound({
+            projectId: thread.project_id,
+            durationMs: defaultDurationMs,
+            recentComments: [],
+            agentRuntime: runtime,
+            priceAtStart: thread.price_on_fetch,
+            currentPrice: thread.price_on_eval,
+        });
+        // Calculate actual price change
+        const actualPriceChangePercent = calculatePriceChange(thread.price_on_fetch, thread.price_on_eval);
+        // Build result
+        const result = buildThreadResult(i, thread, analysisResult, actualPriceChangePercent);
+        results.push(result);
+        callbacks?.onThreadComplete?.(i, result);
+    }
+    // Calculate summary statistics
+    const runResult = buildRunResult(backtest.metadata.id, runtime.config.name, results);
+    return runResult;
+}
+/**
+ * Calculate percentage price change.
+ */
+function calculatePriceChange(priceOnFetch, priceOnEval) {
+    const change = ((priceOnEval - priceOnFetch) / priceOnFetch) * 100;
+    return change;
+}
+/**
+ * Build a thread result from analysis output.
+ */
+function buildThreadResult(index, thread, analysis, actualPriceChangePercent) {
+    if (analysis.skip) {
+        return {
+            thread_index: index,
+            project_id: thread.project_id,
+            project_name: thread.project_name,
+            thread_text: thread.text,
+            predicted_conviction: 0,
+            predicted_summary: '',
+            skipped: true,
+            actual_price_change_percent: actualPriceChangePercent,
+            direction_correct: null,
+            absolute_error: null,
+        };
+    }
+    // Determine direction correctness
+    const predictedDirection = Math.sign(analysis.conviction);
+    const actualDirection = Math.sign(actualPriceChangePercent);
+    const directionCorrect = predictedDirection === actualDirection;
+    // Calculate absolute error
+    const absoluteError = Math.abs(analysis.conviction - actualPriceChangePercent);
+    return {
+        thread_index: index,
+        project_id: thread.project_id,
+        project_name: thread.project_name,
+        thread_text: thread.text,
+        predicted_conviction: analysis.conviction,
+        predicted_summary: analysis.summary,
+        skipped: false,
+        actual_price_change_percent: actualPriceChangePercent,
+        direction_correct: directionCorrect,
+        absolute_error: absoluteError,
+    };
+}
+/**
+ * Build the final run result with summary statistics.
+ */
+function buildRunResult(backtestId, agentName, results) {
+    const totalThreads = results.length;
+    const predictedResults = results.filter((r) => !r.skipped);
+    const threadsPredicted = predictedResults.length;
+    const threadsSkipped = totalThreads - threadsPredicted;
+    // Calculate direction accuracy
+    const correctDirections = predictedResults.filter((r) => r.direction_correct === true).length;
+    const directionAccuracy = threadsPredicted > 0 ? (correctDirections / threadsPredicted) * 100 : 0;
+    // Calculate mean absolute error
+    const totalError = predictedResults.reduce((sum, r) => sum + (r.absolute_error ?? 0), 0);
+    const meanAbsoluteError = threadsPredicted > 0 ? totalError / threadsPredicted : 0;
+    return {
+        backtest_id: backtestId,
+        agent_name: agentName,
+        run_at: new Date().toISOString(),
+        thread_results: results,
+        total_threads: totalThreads,
+        threads_predicted: threadsPredicted,
+        threads_skipped: threadsSkipped,
+        direction_accuracy: directionAccuracy,
+        mean_absolute_error: meanAbsoluteError,
+    };
+}

package/dist/commands/start/services/backtest/storage.js

@@ -0,0 +1,11 @@
+import { DEFAULT_BACKTEST_DATA } from './default-backtest-data.js';
+/**
+ * ID for the bundled default backtest dataset.
+ */
+export const DEFAULT_BACKTEST_ID = 'default';
+/**
+ * Load the bundled default backtest dataset.
+ */
+export function loadDefaultBacktest() {
+    return DEFAULT_BACKTEST_DATA;
+}

package/dist/commands/start/services/backtest/types.js

@@ -0,0 +1 @@
+export {};

package/dist/commands/start/services/command-registry.js

@@ -0,0 +1,13 @@
+export const SLASH_COMMANDS = [
+    { name: '/skills', description: 'List available skills' },
+    { name: '/help', description: 'Show available commands' },
+    { name: '/clear', description: 'Clear chat history' },
+    { name: '/memory', description: 'Show current memory state' },
+    { name: '/backtest', description: 'Run agent against test set (/backtest <num> fetches from API)' },
+    { name: '/prediction', description: 'Show your last 10 resolved predictions' },
+];
+export function filterCommands(prefix) {
+    const lowerPrefix = prefix.toLowerCase();
+    const filtered = SLASH_COMMANDS.filter((cmd) => cmd.name.toLowerCase().startsWith(lowerPrefix));
+    return filtered;
+}

package/dist/commands/start/ui/AsciiTicker.js

@@ -0,0 +1,81 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import { animation, colors } from '../../shared/theme.js';
+function buildTickerChars(step) {
+    const stepStr = String(step).padStart(2, '0');
+    const digits = stepStr.split('');
+    return animation.HEX_CHARS + digits.join('') + '\u25AA\u25AB\u2591\u2592';
+}
+function buildRow(cols, frame, rowIndex, tickerChars) {
+    const segments = [];
+    const isSecondRow = rowIndex === 1;
+    const scrollSpeed = isSecondRow ? 3 : 2;
+    const direction = isSecondRow ? -1 : 1;
+    const sinFreq = isSecondRow ? 0.4 : 0.3;
+    const sinPhase = isSecondRow ? -0.4 : 0.6;
+    const wrapLen = cols * 2;
+    for (let c = 0; c < cols; c++) {
+        const scrolledC = direction === 1
+            ? (c + frame * scrollSpeed) % wrapLen
+            : (cols - c + frame * scrollSpeed) % wrapLen;
+        const charIdx = scrolledC % tickerChars.length;
+        const char = tickerChars[charIdx];
+        const isHex = char === '\u2B21' || char === '\u2B22';
+        const pulseHit = Math.sin((c + frame * sinPhase) * sinFreq) > 0.5;
+        // Edge fade: dim the outermost 4 columns
+        const edgeDist = Math.min(c, cols - 1 - c);
+        if (edgeDist < 2) {
+            segments.push({ char: '\u00B7', color: colors.grayDim });
+            continue;
+        }
+        if (edgeDist < 4) {
+            segments.push({ char, color: colors.grayDim });
+            continue;
+        }
+        if (pulseHit && isHex) {
+            segments.push({ char, color: colors.honey });
+        }
+        else if (pulseHit) {
+            segments.push({ char, color: colors.green });
+        }
+        else {
+            segments.push({ char, color: colors.grayDim });
+        }
+    }
+    return segments;
+}
+function renderSegments(segments) {
+    const elements = [];
+    let runColor = segments[0]?.color ?? colors.grayDim;
+    let runChars = '';
+    for (let i = 0; i < segments.length; i++) {
+        const seg = segments[i];
+        if (seg.color === runColor) {
+            runChars += seg.char;
+        }
+        else {
+            elements.push(_jsx(Text, { color: runColor, children: runChars }, `${elements.length}`));
+            runColor = seg.color;
+            runChars = seg.char;
+        }
+    }
+    if (runChars.length > 0) {
+        elements.push(_jsx(Text, { color: runColor, children: runChars }, `${elements.length}`));
+    }
+    return elements;
+}
+export function AsciiTicker({ rows = 1, step = 1 }) {
+    const [frame, setFrame] = useState(0);
+    const cols = process.stdout.columns || 60;
+    const tickerChars = buildTickerChars(step);
+    useEffect(() => {
+        const timer = setInterval(() => {
+            setFrame((prev) => prev + 1);
+        }, animation.TICK_MS);
+        return () => {
+            clearInterval(timer);
+        };
+    }, []);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: renderSegments(buildRow(cols, frame, 0, tickerChars)) }), rows === 2 && _jsx(Text, { children: renderSegments(buildRow(cols, frame, 1, tickerChars)) })] }));
+}

package/dist/commands/start/ui/CommandInput.js

@@ -0,0 +1,65 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState, useCallback, useMemo } from 'react';
+import { Box, Text, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import { filterCommands } from '../services/command-registry.js';
+import { colors, symbols } from '../../shared/theme.js';
+export function CommandInput({ value, onChange, onSubmit, placeholder, }) {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    // Determine if autocomplete should be active
+    const isAutocompleteActive = value.startsWith('/') && !value.includes(' ');
+    // Get filtered commands
+    const filteredCommands = useMemo(() => {
+        if (!isAutocompleteActive) {
+            return [];
+        }
+        const commands = filterCommands(value);
+        return commands;
+    }, [value, isAutocompleteActive]);
+    // Reset selection when filtered commands change
+    const commandCount = filteredCommands.length;
+    const safeSelectedIndex = commandCount > 0 ? Math.min(selectedIndex, commandCount - 1) : 0;
+    const handleChange = useCallback((newValue) => {
+        onChange(newValue);
+        setSelectedIndex(0);
+    }, [onChange]);
+    const handleSubmit = useCallback((submittedValue) => {
+        // If autocomplete is active and there are matches, complete first
+        if (isAutocompleteActive && filteredCommands.length > 0) {
+            const selected = filteredCommands[safeSelectedIndex];
+            if (selected && submittedValue !== selected.name) {
+                onChange(selected.name);
+                onSubmit(selected.name);
+                return;
+            }
+        }
+        onSubmit(submittedValue);
+    }, [isAutocompleteActive, filteredCommands, safeSelectedIndex, onChange, onSubmit]);
+    useInput((input, key) => {
+        if (!isAutocompleteActive || filteredCommands.length === 0) {
+            return;
+        }
+        if (key.upArrow) {
+            setSelectedIndex((prev) => (prev > 0 ? prev - 1 : commandCount - 1));
+        }
+        else if (key.downArrow) {
+            setSelectedIndex((prev) => (prev < commandCount - 1 ? prev + 1 : 0));
+        }
+        else if (key.tab) {
+            // Tab to complete without submitting
+            const selected = filteredCommands[safeSelectedIndex];
+            if (selected) {
+                onChange(selected.name);
+            }
+        }
+        else if (key.escape) {
+            // Escape to clear input
+            onChange('');
+            setSelectedIndex(0);
+        }
+    }, { isActive: isAutocompleteActive && filteredCommands.length > 0 });
+    return (_jsxs(Box, { flexDirection: "column", children: [isAutocompleteActive && filteredCommands.length > 0 && (_jsx(Box, { flexDirection: "column", marginBottom: 0, marginLeft: 2, children: filteredCommands.map((cmd, index) => {
+                    const isSelected = index === safeSelectedIndex;
+                    return (_jsxs(Box, { children: [_jsxs(Text, { color: isSelected ? colors.honey : colors.gray, children: [isSelected ? symbols.diamond : ' ', ' '] }), _jsx(Text, { color: isSelected ? colors.honey : colors.white, children: cmd.name }), _jsxs(Text, { color: colors.gray, children: [" - ", cmd.description] })] }, cmd.name));
+                }) })), _jsxs(Box, { children: [_jsxs(Text, { color: colors.honey, children: [symbols.arrow, " "] }), _jsx(TextInput, { value: value, onChange: handleChange, onSubmit: handleSubmit, placeholder: placeholder })] })] }));
+}

package/dist/commands/start/ui/HoneycombBoot.js

@@ -0,0 +1,291 @@
+import chalk from 'chalk';
+import { animation, colors } from '../../shared/theme.js';
+const BOOT_TOTAL_FRAMES = 58;
+const BOOT_FRAME_MS = 80;
+const DURATION_MS = BOOT_TOTAL_FRAMES * BOOT_FRAME_MS;
+const NUM_BEES = 4;
+const NUM_STREAMS = 5;
+const SCRAMBLE_CHARS = '\u2B21\u2B22\u25C6\u25C7\u2591\u2592!@#$%01';
+const BOOT_MESSAGES = [
+    { prefix: '\u2B21', text: 'Initializing {name} agent...', frame: 30 },
+    { prefix: '\u25C6', text: 'Loading personality matrix...', frame: 36 },
+    { prefix: '\u25C7', text: 'Connecting to the hive...', frame: 42 },
+    { prefix: '\u2713', text: 'Neural link established', frame: 48 },
+];
+// ─── Private helpers ─────────────────────────────────
+function isHexEdge(r, c) {
+    const rowInHex = ((r % animation.HEX_H) + animation.HEX_H) % animation.HEX_H;
+    const isOddHex = Math.floor(r / animation.HEX_H) % 2 === 1;
+    const colOffset = isOddHex ? animation.HEX_W / 2 : 0;
+    const colInHex = (((c - colOffset) % animation.HEX_W) + animation.HEX_W) % animation.HEX_W;
+    if (rowInHex === 0 || rowInHex === animation.HEX_H - 1) {
+        return colInHex >= 2 && colInHex <= 5;
+    }
+    if (rowInHex === 1 || rowInHex === 2) {
+        return colInHex === 1 || colInHex === 6;
+    }
+    return false;
+}
+// ─── Raw ANSI boot animation ────────────────────────
+export function showHoneycombBoot(agentName) {
+    return new Promise((resolve) => {
+        const cols = process.stdout.columns || 60;
+        const gridRows = process.stdout.rows || 24;
+        let frame = 0;
+        // Init bees
+        const bees = [];
+        for (let i = 0; i < NUM_BEES; i++) {
+            bees.push({
+                r: Math.floor(Math.random() * gridRows),
+                c: Math.floor(Math.random() * cols),
+                vr: Math.random() > 0.5 ? 1 : -1,
+                vc: Math.random() > 0.5 ? 1 : -1,
+            });
+        }
+        // Init stream columns
+        const streamCols = [];
+        const spacing = Math.floor(cols / (NUM_STREAMS + 1));
+        for (let i = 1; i <= NUM_STREAMS; i++) {
+            streamCols.push(spacing * i);
+        }
+        let pulses = [];
+        // Text positioning
+        const centerR = Math.floor(gridRows / 2) - 2;
+        const centerC = Math.floor(cols / 2);
+        const nameText = `\u2B21  ${agentName} agent  \u2B21`;
+        const nameStart = Math.max(0, centerC - Math.floor(nameText.length / 2));
+        const msgStartRow = centerR + 4;
+        // Quiet zone around text: no animation renders here
+        const PADDING_H = 3;
+        const PADDING_V = 1;
+        const longestMsg = BOOT_MESSAGES.reduce((max, m) => Math.max(max, m.prefix.length + 1 + m.text.replace('{name}', agentName).length), 0);
+        const msgLeftEdge = Math.floor((cols - longestMsg) / 2);
+        const msgRightEdge = msgLeftEdge + longestMsg;
+        const quietLeft = Math.min(nameStart, msgLeftEdge) - PADDING_H;
+        const quietRight = Math.max(nameStart + nameText.length, msgRightEdge) + PADDING_H;
+        const quietTop = centerR - 1 - PADDING_V;
+        const quietBottom = msgStartRow + BOOT_MESSAGES.length + PADDING_V;
+        // Hide cursor
+        process.stdout.write('\x1b[?25l');
+        // Clear screen
+        process.stdout.write('\x1b[2J');
+        function renderFrame() {
+            // Move cursor to top-left
+            process.stdout.write('\x1b[H');
+            // Advance bees every other frame
+            if (frame > 0 && frame % 2 === 0) {
+                for (const bee of bees) {
+                    bee.r += bee.vr;
+                    bee.c += bee.vc;
+                    if (bee.r <= 0 || bee.r >= gridRows - 1) {
+                        bee.vr *= -1;
+                        bee.r = Math.max(0, Math.min(gridRows - 1, bee.r));
+                    }
+                    if (bee.c <= 0 || bee.c >= cols - 1) {
+                        bee.vc *= -1;
+                        bee.c = Math.max(0, Math.min(cols - 1, bee.c));
+                    }
+                    if (Math.random() > 0.3) {
+                        bee.vc = Math.random() > 0.5 ? 1 : -1;
+                    }
+                }
+            }
+            // Spawn pulses
+            if (frame % 4 === 0) {
+                for (let i = 0; i < 3; i++) {
+                    const pr = Math.floor(Math.random() * gridRows);
+                    const pc = Math.floor(Math.random() * cols);
+                    if (isHexEdge(pr, pc)) {
+                        const pulseColors = [colors.green, colors.red, colors.honey];
+                        const color = pulseColors[Math.floor(Math.random() * pulseColors.length)];
+                        pulses.push({ r: pr, c: pc, ttl: 8, color });
+                    }
+                }
+                pulses = pulses.filter((p) => p.ttl > 0).map((p) => ({ ...p, ttl: p.ttl - 1 }));
+            }
+            // Build grid: char + color pairs
+            const charGrid = [];
+            const colorGrid = [];
+            for (let r = 0; r < gridRows; r++) {
+                const chars = [];
+                const clrs = [];
+                for (let c = 0; c < cols; c++) {
+                    // Skip animation in quiet zone around text
+                    const inQuietZone = r >= quietTop && r <= quietBottom && c >= quietLeft && c < quietRight;
+                    if (inQuietZone) {
+                        chars.push(' ');
+                        clrs.push(colors.grayDim);
+                        continue;
+                    }
+                    const hexEdge = isHexEdge(r, c);
+                    // Scanning wave
+                    const scanRow = frame % (gridRows + 6);
+                    const dist = Math.abs(r - scanRow);
+                    if (hexEdge && dist === 0) {
+                        chars.push('\u2B22');
+                        clrs.push(colors.honey);
+                        continue;
+                    }
+                    if (hexEdge && dist <= 1) {
+                        chars.push('\u2B21');
+                        clrs.push(colors.honey);
+                        continue;
+                    }
+                    // Data streams
+                    let isStream = false;
+                    if (frame >= 8) {
+                        for (const sc of streamCols) {
+                            if (c === sc) {
+                                const streamOffset = ((frame - 8) * 2 + sc) % (gridRows * 3);
+                                const streamDist = (((r - streamOffset) % gridRows) + gridRows) % gridRows;
+                                if (streamDist < 6) {
+                                    const charIdx = (frame + r) % animation.DATA_CHARS.length;
+                                    const streamChar = animation.DATA_CHARS[charIdx];
+                                    chars.push(streamChar);
+                                    if (streamDist === 0) {
+                                        clrs.push(colors.white);
+                                    }
+                                    else if (streamDist < 3) {
+                                        clrs.push(colors.green);
+                                    }
+                                    else {
+                                        clrs.push(colors.grayDim);
+                                    }
+                                    isStream = true;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    if (isStream)
+                        continue;
+                    // Default
+                    if (hexEdge) {
+                        chars.push('\u00B7');
+                        clrs.push(colors.grayDim);
+                    }
+                    else {
+                        chars.push(' ');
+                        clrs.push(colors.grayDim);
+                    }
+                }
+                charGrid.push(chars);
+                colorGrid.push(clrs);
+            }
+            // Overlay pulses (skip quiet zone)
+            for (const pulse of pulses) {
+                if (pulse.r >= 0 && pulse.r < gridRows && pulse.c >= 0 && pulse.c < cols) {
+                    const inQuietZone = pulse.r >= quietTop &&
+                        pulse.r <= quietBottom &&
+                        pulse.c >= quietLeft &&
+                        pulse.c < quietRight;
+                    if (inQuietZone)
+                        continue;
+                    const brightness = pulse.ttl / 8;
+                    const cell = charGrid[pulse.r][pulse.c];
+                    if (cell === '\u00B7' || cell === ' ') {
+                        charGrid[pulse.r][pulse.c] = brightness > 0.5 ? '\u2B21' : '\u00B7';
+                        colorGrid[pulse.r][pulse.c] = pulse.color;
+                    }
+                }
+            }
+            // Overlay bees (skip quiet zone)
+            for (const bee of bees) {
+                const br = Math.max(0, Math.min(gridRows - 1, Math.round(bee.r)));
+                const bc = Math.max(0, Math.min(cols - 1, Math.round(bee.c)));
+                const inQuietZone = br >= quietTop && br <= quietBottom && bc >= quietLeft && bc < quietRight;
+                if (!inQuietZone) {
+                    charGrid[br][bc] = '\u25C6';
+                    colorGrid[br][bc] = colors.honey;
+                }
+            }
+            // Overlay agent name with scramble→reveal effect
+            if (frame >= 22) {
+                const scrambleProgress = Math.min(1, (frame - 22) / 8);
+                // Top/bottom border lines around name
+                for (let c = nameStart; c < nameStart + nameText.length && c < cols; c++) {
+                    if (centerR - 1 >= 0) {
+                        charGrid[centerR - 1][c] = '\u2500';
+                        colorGrid[centerR - 1][c] = colors.honey;
+                    }
+                    if (centerR + 1 < gridRows) {
+                        charGrid[centerR + 1][c] = '\u2500';
+                        colorGrid[centerR + 1][c] = colors.honey;
+                    }
+                }
+                // Name text with scramble effect
+                for (let i = 0; i < nameText.length; i++) {
+                    const c = nameStart + i;
+                    if (c >= cols)
+                        break;
+                    const charThreshold = i / nameText.length;
+                    if (charThreshold <= scrambleProgress) {
+                        charGrid[centerR][c] = nameText[i];
+                        colorGrid[centerR][c] = colors.honey;
+                    }
+                    else {
+                        const scrambleIdx = Math.floor(Math.random() * SCRAMBLE_CHARS.length);
+                        charGrid[centerR][c] = SCRAMBLE_CHARS[scrambleIdx];
+                        colorGrid[centerR][c] = colors.gray;
+                    }
+                }
+            }
+            // Overlay typewriter boot messages
+            for (let idx = 0; idx < BOOT_MESSAGES.length; idx++) {
+                const msg = BOOT_MESSAGES[idx];
+                if (frame < msg.frame)
+                    continue;
+                const r = msgStartRow + idx;
+                if (r < 0 || r >= gridRows)
+                    continue;
+                const fullText = `${msg.prefix} ${msg.text.replace('{name}', agentName)}`;
+                const msgCol = Math.floor((cols - fullText.length) / 2);
+                const visibleChars = Math.min(fullText.length, (frame - msg.frame) * 3);
+                const isCheckmark = msg.prefix === '\u2713';
+                const msgColor = isCheckmark ? colors.green : colors.honey;
+                for (let i = 0; i < visibleChars; i++) {
+                    const c = msgCol + i;
+                    if (c < 0 || c >= cols)
+                        continue;
+                    charGrid[r][c] = fullText[i];
+                    colorGrid[r][c] = msgColor;
+                }
+            }
+            // Render to stdout
+            let output = '';
+            for (let r = 0; r < gridRows; r++) {
+                let line = '';
+                let runColor = colorGrid[r][0];
+                let runChars = '';
+                for (let c = 0; c < cols; c++) {
+                    const curColor = colorGrid[r][c];
+                    const curChar = charGrid[r][c];
+                    if (curColor === runColor) {
+                        runChars += curChar;
+                    }
+                    else {
+                        line += chalk.hex(runColor)(runChars);
+                        runColor = curColor;
+                        runChars = curChar;
+                    }
+                }
+                if (runChars.length > 0) {
+                    line += chalk.hex(runColor)(runChars);
+                }
+                output += line;
+                if (r < gridRows - 1) {
+                    output += '\n';
+                }
+            }
+            process.stdout.write(output);
+            frame++;
+        }
+        const timer = setInterval(renderFrame, BOOT_FRAME_MS);
+        setTimeout(() => {
+            clearInterval(timer);
+            // Clear screen, show cursor, move to top
+            process.stdout.write('\x1b[2J\x1b[H\x1b[?25h');
+            resolve();
+        }, DURATION_MS);
+    });
+}

package/dist/commands/start/ui/PollText.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Text } from 'ink';
+export function TypewriterText({ text, color, speed = 25, }) {
+    const [visible, setVisible] = useState(0);
+    useEffect(() => {
+        if (visible >= text.length)
+            return;
+        const timer = setTimeout(() => {
+            setVisible((prev) => Math.min(prev + 2, text.length));
+        }, speed);
+        return () => {
+            clearTimeout(timer);
+        };
+    }, [visible, text, speed]);
+    return _jsx(Text, { color: color, children: text.slice(0, visible) });
+}
+export function PollText({ text, color, animate, }) {
+    if (animate) {
+        return _jsx(TypewriterText, { text: text, color: color });
+    }
+    return _jsx(Text, { color: color, children: text });
+}