@zhive/cli 0.5.0

package/dist/commands/shared/theme.js

@@ -0,0 +1,57 @@
+import chalk from 'chalk';
+export const colors = {
+    honey: '#F5A623',
+    honeyDark: '#D4891A',
+    honeyBright: '#FFD700',
+    white: '#FFFFFF',
+    gray: '#A6A6A6',
+    grayDim: '#555555',
+    green: '#27C587',
+    red: '#E14B4B',
+    wax: '#C45C5C',
+    cyan: '#22D3EE',
+    hot: '#FB923C',
+    controversial: '#C084FC',
+};
+export const symbols = {
+    hive: '\u2B21', // ⬡
+    diamond: '\u25C6', // ◆
+    diamondOpen: '\u25C7', // ◇
+    dot: '\u25CF', // ●
+    spinner: ['\u25D0', '\u25D3', '\u25D1', '\u25D2'], // ◐ ◓ ◑ ◒
+    check: '\u2713', // ✓
+    arrow: '\u203A', // ›
+    circle: '\u25CB', // ○
+    cross: '\u2717', // ✗
+};
+export const border = {
+    horizontal: '\u2500', // ─
+    vertical: '\u2502', // │
+    topLeft: '\u250C', // ┌
+    topRight: '\u2510', // ┐
+    bottomLeft: '\u2514', // └
+    bottomRight: '\u2518', // ┘
+    teeLeft: '\u251C', // ├
+    teeRight: '\u2524', // ┤
+};
+export const animation = {
+    DATA_CHARS: '01▪▫░▒',
+    HEX_CHARS: '⬡⬢',
+    TICK_MS: 120,
+    HEX_W: 8,
+    HEX_H: 4,
+};
+export const styled = {
+    honey: (text) => chalk.hex(colors.honey)(text),
+    honeyBold: (text) => chalk.hex(colors.honey).bold(text),
+    white: (text) => chalk.white(text),
+    whiteBold: (text) => chalk.bold.white(text),
+    gray: (text) => chalk.gray(text),
+    dim: (text) => chalk.hex(colors.grayDim)(text),
+    green: (text) => chalk.hex(colors.green)(text),
+    red: (text) => chalk.hex(colors.red)(text),
+    wax: (text) => chalk.hex(colors.wax)(text),
+    cyan: (text) => chalk.hex(colors.cyan)(text),
+    hot: (text) => chalk.hex(colors.hot)(text),
+    controversial: (text) => chalk.hex(colors.controversial)(text),
+};

package/dist/commands/shared/welcome.js

@@ -0,0 +1,304 @@
+import chalk from 'chalk';
+const HEX_W = 8;
+const HEX_H = 4;
+const DATA_CHARS = '01▪▫░▒';
+const TICK_MS = 80;
+const DURATION_MS = 3200;
+const NUM_BEES = 4;
+const NUM_STREAMS = 5;
+const HONEY = '#F5A623';
+const GREEN = '#27C587';
+const DIM = '#555555';
+const WHITE = '#FFFFFF';
+const RED = '#E14B4B';
+const SCRAMBLE_CHARS = '⬡⬢◆◇░▒!@#$%01';
+const BOOT_MESSAGES = [
+    { prefix: '⬡', text: 'Initializing creation studio...', frame: 18, color: HONEY },
+    { prefix: '◆', text: 'Loading agent templates...', frame: 24, color: HONEY },
+    { prefix: '◇', text: 'Connecting to hive network...', frame: 30, color: HONEY },
+    { prefix: '✓', text: 'Ready', frame: 36, color: GREEN },
+];
+function isHexEdge(r, c) {
+    const rowInHex = ((r % HEX_H) + HEX_H) % HEX_H;
+    const isOddHex = Math.floor(r / HEX_H) % 2 === 1;
+    const colOffset = isOddHex ? HEX_W / 2 : 0;
+    const colInHex = (((c - colOffset) % HEX_W) + HEX_W) % HEX_W;
+    if (rowInHex === 0 || rowInHex === HEX_H - 1) {
+        return colInHex >= 2 && colInHex <= 5;
+    }
+    if (rowInHex === 1 || rowInHex === 2) {
+        return colInHex === 1 || colInHex === 6;
+    }
+    return false;
+}
+export function showWelcome() {
+    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 = [];
+        // Title positioning
+        const title = '\u2B21 HIVE';
+        const subtitle = 'Agent Creation Studio';
+        const titleRow = Math.floor(gridRows / 2) - 1;
+        const subtitleRow = titleRow + 1;
+        const titleCol = Math.floor((cols - title.length) / 2);
+        const subtitleCol = Math.floor((cols - subtitle.length) / 2);
+        // Boot message row positions
+        const msgStartRow = subtitleRow + 2;
+        // Quiet zone around title + boot messages: 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.length), 0);
+        const msgLeftEdge = Math.floor((cols - longestMsg) / 2);
+        const msgRightEdge = msgLeftEdge + longestMsg;
+        const quietLeft = Math.min(titleCol, subtitleCol, msgLeftEdge) - PADDING_H;
+        const quietRight = Math.max(titleCol + title.length, subtitleCol + subtitle.length, msgRightEdge) + PADDING_H;
+        const quietTop = titleRow - 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 = [GREEN, RED, 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 title
+                    if (r >= quietTop && r <= quietBottom && c >= quietLeft && c < quietRight) {
+                        chars.push(' ');
+                        clrs.push(DIM);
+                        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('⬢');
+                        clrs.push(HONEY);
+                        continue;
+                    }
+                    if (hexEdge && dist <= 1) {
+                        chars.push('⬡');
+                        clrs.push(HONEY);
+                        continue;
+                    }
+                    // Data streams
+                    let isStream = false;
+                    for (const sc of streamCols) {
+                        if (c === sc) {
+                            const streamOffset = (frame * 2 + sc) % (gridRows * 3);
+                            const streamDist = (((r - streamOffset) % gridRows) + gridRows) % gridRows;
+                            if (streamDist < 6) {
+                                const charIdx = (frame + r) % DATA_CHARS.length;
+                                const streamChar = DATA_CHARS[charIdx];
+                                chars.push(streamChar);
+                                if (streamDist === 0) {
+                                    clrs.push(WHITE);
+                                }
+                                else if (streamDist < 3) {
+                                    clrs.push(GREEN);
+                                }
+                                else {
+                                    clrs.push(DIM);
+                                }
+                                isStream = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (isStream)
+                        continue;
+                    // Default
+                    if (hexEdge) {
+                        chars.push('·');
+                        clrs.push(DIM);
+                    }
+                    else {
+                        chars.push(' ');
+                        clrs.push(DIM);
+                    }
+                }
+                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 === '·' || cell === ' ') {
+                        charGrid[pulse.r][pulse.c] = brightness > 0.5 ? '⬡' : '·';
+                        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] = '◆';
+                    colorGrid[br][bc] = HONEY;
+                }
+            }
+            // Overlay title with scramble→reveal effect
+            const TITLE_START_FRAME = 6;
+            const TITLE_REVEAL_FRAMES = 8;
+            if (frame >= TITLE_START_FRAME && titleRow >= 0 && titleRow < gridRows) {
+                const scrambleProgress = Math.min(1, (frame - TITLE_START_FRAME) / TITLE_REVEAL_FRAMES);
+                for (let i = 0; i < title.length; i++) {
+                    const tc = titleCol + i;
+                    if (tc < 0 || tc >= cols)
+                        continue;
+                    const charThreshold = i / title.length;
+                    if (charThreshold <= scrambleProgress) {
+                        charGrid[titleRow][tc] = title[i];
+                        colorGrid[titleRow][tc] = HONEY;
+                    }
+                    else {
+                        const scrambleIdx = Math.floor(Math.random() * SCRAMBLE_CHARS.length);
+                        charGrid[titleRow][tc] = SCRAMBLE_CHARS[scrambleIdx];
+                        colorGrid[titleRow][tc] = DIM;
+                    }
+                }
+            }
+            // Overlay subtitle with scramble→reveal (starts a few frames after title)
+            const SUB_START_FRAME = 10;
+            const SUB_REVEAL_FRAMES = 8;
+            if (frame >= SUB_START_FRAME && subtitleRow >= 0 && subtitleRow < gridRows) {
+                const scrambleProgress = Math.min(1, (frame - SUB_START_FRAME) / SUB_REVEAL_FRAMES);
+                for (let i = 0; i < subtitle.length; i++) {
+                    const sc = subtitleCol + i;
+                    if (sc < 0 || sc >= cols)
+                        continue;
+                    const charThreshold = i / subtitle.length;
+                    if (charThreshold <= scrambleProgress) {
+                        charGrid[subtitleRow][sc] = subtitle[i];
+                        colorGrid[subtitleRow][sc] = DIM;
+                    }
+                    else {
+                        const scrambleIdx = Math.floor(Math.random() * SCRAMBLE_CHARS.length);
+                        charGrid[subtitleRow][sc] = SCRAMBLE_CHARS[scrambleIdx];
+                        colorGrid[subtitleRow][sc] = DIM;
+                    }
+                }
+            }
+            // 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}`;
+                const msgCol = Math.floor((cols - fullText.length) / 2);
+                const visibleChars = Math.min(fullText.length, (frame - msg.frame) * 3);
+                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] = msg.color;
+                }
+            }
+            // 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, TICK_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/commands/backtest.js

@@ -0,0 +1,35 @@
+import { HIVE_API_URL } from '../../../shared/config/constant.js';
+import { fetchBacktestThreads } from '../services/backtest/fetch.js';
+import { buildTextReport } from '../services/backtest/results.js';
+import { runBacktest } from '../services/backtest/runner.js';
+import { loadDefaultBacktest } from '../services/backtest/storage.js';
+export const backtestSlashCommand = async (args, config, callbacks) => {
+    const commandArg = args.at(0);
+    const numThreads = commandArg ? parseInt(commandArg, 10) : null;
+    let data;
+    if (numThreads !== null && !isNaN(numThreads) && numThreads > 0) {
+        callbacks.onFetchStart?.(numThreads);
+        const fetchResult = await fetchBacktestThreads(numThreads, HIVE_API_URL);
+        if (fetchResult.success) {
+            data = fetchResult.data;
+        }
+        else {
+            callbacks.onFetchError?.(fetchResult.error);
+        }
+    }
+    // Use default dataset
+    if (!data) {
+        data = loadDefaultBacktest();
+    }
+    try {
+        const result = await runBacktest(data, config, {
+            onThreadStart: callbacks.onThreadStart,
+            onThreadComplete: callbacks.onThreadComplete,
+        });
+        const report = buildTextReport(result);
+        callbacks.onBacktestSuccess?.(report);
+    }
+    catch (err) {
+        callbacks.onBacktestError?.(err);
+    }
+};

package/dist/commands/start/commands/index.js

@@ -0,0 +1,62 @@
+import { render } from 'ink';
+import React from 'react';
+import { App } from '../ui/app.js';
+import { SelectAgentApp } from '../ui/SelectAgentApp.js';
+import { showHoneycombBoot } from '../ui/HoneycombBoot.js';
+import chalk from 'chalk';
+import { symbols } from '../../shared/theme.js';
+import { loadAgentEnv } from '../../../shared/config/env-loader.js';
+export const startCommand = async () => {
+    // Detect if cwd is an agent directory (has SOUL.md).
+    // When called via agent's "npm start", cwd is the agent dir.
+    const { access } = await import('fs/promises');
+    const { join } = await import('path');
+    const isAgentDir = await access(join(process.cwd(), 'SOUL.md'))
+        .then(() => true)
+        .catch(() => false);
+    if (isAgentDir) {
+        // Direct agent run — cwd is already the agent directory.
+        await loadAgentEnv();
+        setupProcessLifecycle();
+        const { waitUntilExit } = render(React.createElement(App));
+        await waitUntilExit();
+    }
+    else {
+        // Interactive agent selection
+        let selectedAgent = null;
+        const { waitUntilExit: waitForSelect } = render(React.createElement(SelectAgentApp, {
+            onSelect: (agent) => {
+                selectedAgent = agent;
+            },
+        }));
+        await waitForSelect();
+        if (selectedAgent) {
+            const picked = selectedAgent;
+            await showHoneycombBoot(picked.name);
+            // Clear screen + scrollback so boot animation and agent picker
+            // don't appear when scrolling up in the agent TUI.
+            process.stdout.write('\x1b[2J\x1b[3J\x1b[H');
+            process.chdir(picked.dir);
+            await loadAgentEnv();
+            setupProcessLifecycle();
+            const { waitUntilExit } = render(React.createElement(App));
+            await waitUntilExit();
+        }
+    }
+};
+const exitImmediately = (exitCode = 0) => {
+    process.exit(exitCode);
+};
+function setupProcessLifecycle() {
+    // Unhandled rejection handler
+    process.on('unhandledRejection', (reason) => {
+        const raw = reason instanceof Error ? reason.message : String(reason);
+        const message = raw.length > 200 ? raw.slice(0, 200) + '\u2026' : raw;
+        console.error(chalk.red(`  ${symbols.cross} Unhandled: ${message}`));
+    });
+    // No alternate screen buffer — normal buffer allows terminal scrollback
+    // so users can scroll up to see historical poll activity.
+    // <Static> items from Ink flow into the scrollback naturally.
+    process.on('SIGINT', () => exitImmediately(0));
+    process.on('SIGTERM', () => exitImmediately(0));
+}

package/dist/commands/start/commands/prediction.js

@@ -0,0 +1,73 @@
+import { credentialsPath, loadCredentials } from '@zhive/sdk';
+import { HIVE_API_URL } from '../../../shared/config/constant.js';
+import { extractErrorMessage } from '../../../shared/agent/utils.js';
+import { styled } from '../../shared/theme.js';
+export async function fetchMyPredictions(apiKey, limit = 10) {
+    try {
+        const url = `${HIVE_API_URL}/megathread-comment/me?limit=${limit}&onlyResolved=true`;
+        const response = await fetch(url, {
+            headers: { 'x-api-key': apiKey },
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            return { success: false, error: `HTTP ${response.status}: ${errorText}` };
+        }
+        const result = (await response.json());
+        return { success: true, data: result.data };
+    }
+    catch (error) {
+        const message = extractErrorMessage(error);
+        return { success: false, error: message };
+    }
+}
+export function formatPredictions(predictions) {
+    if (predictions.length === 0) {
+        return 'No resolved predictions yet. Make some predictions and wait for them to resolve!';
+    }
+    const rows = predictions.map((pred) => {
+        const sign = pred.conviction >= 0 ? '+' : '';
+        const conviction = `${sign}${pred.conviction.toFixed(1)}%`;
+        const outcome = getOutcomeStr(pred);
+        const date = new Date(pred.created_at).toLocaleDateString();
+        const roundStart = pred.round_id.split('@Z')[0];
+        const durationMs = new Date(pred.resolved_at).getTime() - new Date(roundStart).getTime();
+        const duration = { 3600000: '1h', 14400000: '4h', 86400000: '24h' }[durationMs] || '??';
+        return { name: pred.project_id, duration, conviction, outcome, date };
+    });
+    const maxName = Math.max(...rows.map((r) => r.name.length));
+    const maxOutcome = Math.max(...rows.map((r) => r.outcome.length));
+    const lines = [styled.honeyBold('Your Recent Predictions:'), ''];
+    for (const r of rows) {
+        const name = r.name.padEnd(maxName);
+        const conv = r.conviction.padStart(6);
+        const paddedOutcome = r.outcome.padEnd(maxOutcome);
+        const tag = r.outcome.includes('WIN') ? styled.green(paddedOutcome) : styled.red(paddedOutcome);
+        lines.push(`  ${name}  ${r.duration.padStart(3)}  ${conv}  ${tag}  ${r.date}`);
+    }
+    return lines.join('\n');
+}
+function getOutcomeStr(pred) {
+    if (pred.honey > 0) {
+        return `[WIN] +${pred.honey.toFixed(2)} Honey`;
+    }
+    if (pred.wax > 0) {
+        return `[WIN] +${pred.wax.toFixed(2)} Wax`;
+    }
+    return '[LOSS]';
+}
+export async function predictionSlashCommand(agentName, callbacks) {
+    const filePath = credentialsPath(agentName);
+    const credentials = await loadCredentials(filePath);
+    if (!credentials?.apiKey) {
+        callbacks.onError?.('Agent not registered yet. Wait for agent to start.');
+        return;
+    }
+    callbacks.onFetchStart?.();
+    const result = await fetchMyPredictions(credentials.apiKey, 10);
+    if (!result.success) {
+        callbacks.onError?.(result.error);
+        return;
+    }
+    const formatted = formatPredictions(result.data);
+    callbacks.onSuccess?.(formatted);
+}

package/dist/commands/start/commands/skills.js

@@ -0,0 +1,44 @@
+import * as path from 'node:path';
+import { getHiveDir } from '../../../shared/config/constant.js';
+import { discoverSkills } from '../../../shared/agent/skills/skill-parser.js';
+import { styled } from '../../shared/theme.js';
+import { extractErrorMessage } from '../../../shared/agent/utils.js';
+export async function fetchSkills(agentName) {
+    try {
+        const hiveDir = getHiveDir();
+        const skillsDir = path.join(hiveDir, 'agents', agentName, 'skills');
+        const skills = await discoverSkills(skillsDir);
+        return { success: true, data: skills };
+    }
+    catch (error) {
+        const message = extractErrorMessage(error);
+        return { success: false, error: message };
+    }
+}
+export function formatSkills(skills) {
+    if (skills.length === 0) {
+        return 'No skills loaded. Add skills to your agent\'s skills/ directory.';
+    }
+    const lines = [styled.honeyBold('Available Skills:'), ''];
+    for (const skill of skills) {
+        const nameDisplay = styled.honey(skill.metadata.name);
+        const descDisplay = skill.metadata.description;
+        lines.push(`  ${nameDisplay}`);
+        lines.push(`    ${descDisplay}`);
+        if (skill.metadata.compatibility) {
+            const compatDisplay = styled.dim(`[${skill.metadata.compatibility}]`);
+            lines.push(`    ${compatDisplay}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n').trimEnd();
+}
+export async function skillsSlashCommand(agentName, callbacks) {
+    const result = await fetchSkills(agentName);
+    if (!result.success) {
+        callbacks.onError?.(result.error);
+        return;
+    }
+    const formatted = formatSkills(result.data);
+    callbacks.onSuccess?.(formatted);
+}