@zhive/cli 0.5.0

package/dist/agent/components/HoneycombBoot.js

@@ -0,0 +1,291 @@
+import chalk from 'chalk';
+import { colors, animation } from '../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/agent/components/Spinner.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Text } from 'ink';
+import { colors } from '../theme.js';
+const SPINNER_FRAMES = ['\u25D0', '\u25D3', '\u25D1', '\u25D2'];
+export function Spinner({ label }) {
+    const [frame, setFrame] = useState(0);
+    useEffect(() => {
+        const timer = setInterval(() => {
+            setFrame((prev) => (prev + 1) % SPINNER_FRAMES.length);
+        }, 120);
+        return () => {
+            clearInterval(timer);
+        };
+    }, []);
+    return (_jsxs(Text, { children: [_jsx(Text, { color: colors.honey, children: SPINNER_FRAMES[frame] }), _jsxs(Text, { color: colors.gray, children: [" ", label] })] }));
+}
+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 });
+}

package/dist/agent/config.js

@@ -0,0 +1,75 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+async function loadMarkdownFile(filename) {
+    const filePath = path.join(process.cwd(), filename);
+    const content = await fs.readFile(filePath, 'utf-8');
+    return content;
+}
+function extractField(content, pattern) {
+    const match = content.match(pattern);
+    if (match === null) {
+        return null;
+    }
+    const value = match[1].trim();
+    return value;
+}
+const VALID_SENTIMENTS = [
+    'very-bullish',
+    'bullish',
+    'neutral',
+    'bearish',
+    'very-bearish',
+];
+const VALID_TIMEFRAMES = ['1h', '4h', '24h'];
+function parseSentiment(raw) {
+    if (raw !== null && VALID_SENTIMENTS.includes(raw)) {
+        return raw;
+    }
+    return 'neutral';
+}
+function parseSectors(raw) {
+    if (raw === null || raw.trim() === '') {
+        return [];
+    }
+    const sectors = raw
+        .split(',')
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    return sectors;
+}
+function parseTimeframes(raw) {
+    if (raw === null || raw.trim() === '') {
+        return ['1h', '4h', '24h'];
+    }
+    const parsed = raw
+        .split(',')
+        .map((t) => t.trim())
+        .filter((t) => VALID_TIMEFRAMES.includes(t));
+    if (parsed.length === 0) {
+        return ['1h', '4h', '24h'];
+    }
+    return parsed;
+}
+export async function loadAgentConfig() {
+    const soulContent = await loadMarkdownFile('SOUL.md');
+    const strategyContent = await loadMarkdownFile('STRATEGY.md');
+    const name = extractField(soulContent, /^#\s+Agent:\s+(.+)$/m);
+    if (name === null) {
+        throw new Error('Could not parse agent name from SOUL.md. Expected "# Agent: <name>" as the first heading.');
+    }
+    const avatarUrl = extractField(soulContent, /^## Avatar\s*\n+(https?:\/\/.+)$/m);
+    if (avatarUrl === null) {
+        throw new Error('Could not parse avatar URL from SOUL.md. Expected a valid URL under "## Avatar".');
+    }
+    const bioRaw = extractField(soulContent, /^## Bio\s*\n+(.+)$/m);
+    const bio = bioRaw ?? null;
+    const sentimentRaw = extractField(strategyContent, /^-\s+Bias:\s+(.+)$/m);
+    const sectorsRaw = extractField(strategyContent, /^-\s+Sectors:\s+(.+)$/m);
+    const timeframesRaw = extractField(strategyContent, /^-\s+Active timeframes:\s+(.+)$/m);
+    const agentProfile = {
+        sentiment: parseSentiment(sentimentRaw),
+        sectors: parseSectors(sectorsRaw),
+        timeframes: parseTimeframes(timeframesRaw),
+    };
+    return { name, bio, avatarUrl, soulContent, strategyContent, agentProfile };
+}

package/dist/agent/edit-section.js

@@ -0,0 +1,59 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export function replaceSection(fileContent, heading, newContent) {
+    const lines = fileContent.split('\n');
+    const headingLine = `## ${heading}`;
+    let startIdx = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].trim() === headingLine) {
+            startIdx = i;
+            break;
+        }
+    }
+    if (startIdx === -1) {
+        throw new Error(`Section "## ${heading}" not found in file.`);
+    }
+    let endIdx = lines.length;
+    for (let i = startIdx + 1; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (trimmed.startsWith('## ') || trimmed.startsWith('# ')) {
+            endIdx = i;
+            break;
+        }
+    }
+    const before = lines.slice(0, startIdx + 1);
+    const after = lines.slice(endIdx);
+    const trimmedContent = newContent.trim();
+    const newSection = ['', ...trimmedContent.split('\n'), ''];
+    const result = [...before, ...newSection, ...after].join('\n');
+    return result;
+}
+export const editSectionTool = tool({
+    description: 'Edit a section of SOUL.md or STRATEGY.md. Only call AFTER user confirms.',
+    inputSchema: z.object({
+        file: z.enum(['SOUL.md', 'STRATEGY.md']),
+        section: z.string().describe('Exact ## heading name, e.g. "Personality", "Conviction Style"'),
+        content: z.string().describe('New content for the section (without the ## heading line)'),
+    }),
+    execute: async ({ file, section, content }) => {
+        const filePath = path.join(process.cwd(), file);
+        let fileContent;
+        try {
+            fileContent = await fs.readFile(filePath, 'utf-8');
+        }
+        catch {
+            return `Error: ${file} not found in current directory.`;
+        }
+        try {
+            const updated = replaceSection(fileContent, section, content);
+            await fs.writeFile(filePath, updated, 'utf-8');
+            return `Updated "${section}" section in ${file}.`;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return `Error: ${message}`;
+        }
+    },
+});

package/dist/agent/fetch-rules.js

@@ -0,0 +1,21 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+const RULES_URL = 'https://hive.z3n.dev/RULES.md';
+export const fetchRulesTool = tool({
+    description: 'Fetch the rules of the Hive game. Call when the user asks about rules, scoring, honey, wax, streaks, or how the platform works.',
+    inputSchema: z.object({}),
+    execute: async () => {
+        try {
+            const response = await fetch(RULES_URL);
+            if (!response.ok) {
+                return `Error: failed to fetch rules (HTTP ${response.status}).`;
+            }
+            const rules = await response.text();
+            return rules;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return `Error: could not reach Hive to fetch rules. ${message}`;
+        }
+    },
+});

package/dist/agent/helpers.js

@@ -0,0 +1,22 @@
+export function formatTime(date) {
+    const hours = String(date.getHours()).padStart(2, '0');
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    const seconds = String(date.getSeconds()).padStart(2, '0');
+    return `${hours}:${minutes}:${seconds}`;
+}
+export function convictionColor(conviction) {
+    if (conviction > 0)
+        return 'green';
+    if (conviction < 0)
+        return 'red';
+    return 'gray';
+}
+export function stripCodeFences(text) {
+    const trimmed = text.trim();
+    const fencePattern = /^```(?:markdown|md)?\s*\n([\s\S]*?)\n```$/;
+    const match = trimmed.match(fencePattern);
+    if (match) {
+        return match[1].trim();
+    }
+    return trimmed;
+}