@hive-org/cli 0.0.1

package/dist/create/steps/NameStep.js

@@ -0,0 +1,70 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback, useMemo } from 'react';
+import { Box, Text } from 'ink';
+import axios from 'axios';
+import { TextPrompt } from '../../components/TextPrompt.js';
+import { Spinner } from '../../components/Spinner.js';
+import { colors, symbols } from '../../theme.js';
+const ADJECTIVES = [
+    'royal', 'golden', 'buzzy', 'honey', 'sweet', 'stung', 'waxed', 'bold',
+    'swift', 'wild', 'keen', 'warm', 'hazy', 'calm', 'busy', 'amber',
+    'pollen', 'nectar', 'floral', 'sunny', 'misty', 'fuzzy', 'striped',
+    'waggle', 'silent', 'fierce', 'humble', 'lunar', 'solar', 'bloomed',
+    'bullish', 'bearish', 'staked', 'minted', 'forked', 'based', 'degen',
+    'pumped', 'longed', 'shorted', 'bridged', 'pegged', 'hodl', 'mega',
+    'alpha', 'sigma', 'hyper', 'ultra', 'rapid', 'atomic',
+];
+const NOUNS = [
+    'bee', 'drone', 'queen', 'swarm', 'hive', 'comb', 'larva', 'pupa',
+    'sting', 'apiary', 'keeper', 'mead', 'pollen', 'nectar', 'propolis',
+    'colony', 'brood', 'waggle', 'cell', 'wax', 'bloom', 'blossom',
+    'hornet', 'bumble', 'worker', 'forager', 'scout', 'smoker',
+    'whale', 'bull', 'bear', 'shard', 'block', 'node', 'vault',
+    'ledger', 'oracle', 'miner', 'staker', 'bridge', 'token', 'chain',
+    'wick', 'candle', 'pump', 'moon', 'floor', 'whale',
+];
+function generateRandomName() {
+    const adjective = ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)];
+    const noun = NOUNS[Math.floor(Math.random() * NOUNS.length)];
+    const number = Math.floor(Math.random() * 900) + 100;
+    const name = `${adjective}-${noun}-${number}`;
+    return name;
+}
+export function NameStep({ onComplete }) {
+    const [checking, setChecking] = useState(false);
+    const [error, setError] = useState('');
+    const placeholder = useMemo(() => generateRandomName(), []);
+    const handleSubmit = useCallback(async (name) => {
+        setChecking(true);
+        setError('');
+        try {
+            const apiUrl = process.env['HIVE_API_URL'] ?? 'https://hive-backend.z3n.dev';
+            const response = await axios.get(`${apiUrl}/agent/check-name`, {
+                params: { name },
+                timeout: 3000,
+            });
+            if (!response.data.available) {
+                setError(`Name "${name}" is already taken`);
+                setChecking(false);
+                return;
+            }
+        }
+        catch {
+            // best-effort: silently proceed if backend is unavailable
+        }
+        setChecking(false);
+        onComplete(name);
+    }, [onComplete]);
+    if (checking) {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(Spinner, { label: "Checking name availability..." }) }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(TextPrompt, { label: "Enter your agent name", placeholder: placeholder, onSubmit: handleSubmit, validate: (val) => {
+                    if (!val) {
+                        return 'Agent name is required';
+                    }
+                    if (!/^[a-zA-Z0-9-_]+$/.test(val)) {
+                        return 'Only letters, numbers, hyphens, and underscores allowed';
+                    }
+                    return true;
+                } }), error !== '' && (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: colors.red, children: [symbols.cross, " ", error] }) }))] }));
+}

package/dist/create/steps/ScaffoldStep.js

@@ -0,0 +1,58 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import { HoneycombLoader } from '../../components/HoneycombLoader.js';
+import { colors, symbols } from '../../theme.js';
+import { scaffoldProject } from '../generate.js';
+export function ScaffoldStep({ projectName, provider, apiKey, soulContent, strategyContent, onComplete, onError, }) {
+    const [steps, setSteps] = useState([]);
+    const [currentLabel, setCurrentLabel] = useState('Starting...');
+    useEffect(() => {
+        let cancelled = false;
+        const run = async () => {
+            await scaffoldProject(projectName, provider, apiKey, soulContent, strategyContent, {
+                onStep: (label) => {
+                    if (cancelled)
+                        return;
+                    setSteps((prev) => {
+                        if (prev.length > 0) {
+                            const updated = [...prev];
+                            updated[updated.length - 1] = { ...updated[updated.length - 1], done: true };
+                            return [...updated, { label, done: false }];
+                        }
+                        return [{ label, done: false }];
+                    });
+                    setCurrentLabel(label);
+                },
+                onDone: (projectDir) => {
+                    if (cancelled)
+                        return;
+                    setSteps((prev) => {
+                        if (prev.length > 0) {
+                            const updated = [...prev];
+                            updated[updated.length - 1] = { ...updated[updated.length - 1], done: true };
+                            return updated;
+                        }
+                        return prev;
+                    });
+                    onComplete(projectDir);
+                },
+                onError: (message) => {
+                    if (cancelled)
+                        return;
+                    onError(message);
+                },
+            });
+        };
+        run().catch((err) => {
+            if (cancelled)
+                return;
+            const message = err instanceof Error ? err.message : String(err);
+            onError(message);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [projectName, provider, apiKey, soulContent, strategyContent, onComplete, onError]);
+    return (_jsxs(Box, { flexDirection: "column", children: [steps.map((step, i) => (_jsx(Box, { marginLeft: 2, children: step.done ? (_jsxs(Text, { color: colors.green, children: [symbols.check, " ", step.label] })) : (_jsx(HoneycombLoader, { label: step.label })) }, i))), steps.length === 0 && (_jsx(Box, { marginLeft: 2, children: _jsx(HoneycombLoader, { label: currentLabel }) }))] }));
+}

package/dist/create/steps/SoulStep.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback, useMemo } from 'react';
+import { Box, Text } from 'ink';
+import { StreamingText } from '../../components/StreamingText.js';
+import { TextPrompt } from '../../components/TextPrompt.js';
+import { CodeBlock } from '../../components/CodeBlock.js';
+import { Spinner } from '../../components/Spinner.js';
+import { colors, symbols } from '../../theme.js';
+import { streamSoul } from '../ai-generate.js';
+export function SoulStep({ providerId, apiKey, agentName, bio, avatarUrl, personality, tone, voiceStyle, onComplete, }) {
+    const [phase, setPhase] = useState('streaming');
+    const [draft, setDraft] = useState('');
+    const [feedbackCount, setFeedbackCount] = useState(0);
+    const stream = useMemo(() => streamSoul(providerId, apiKey, agentName, bio, avatarUrl, personality, tone, voiceStyle), []);
+    const [currentStream, setCurrentStream] = useState(stream);
+    const handleStreamComplete = useCallback((fullText) => {
+        setDraft(fullText);
+        setPhase('review');
+    }, []);
+    const handleAccept = useCallback(() => {
+        onComplete(draft);
+    }, [draft, onComplete]);
+    const handleFeedback = useCallback((feedback) => {
+        setFeedbackCount((prev) => prev + 1);
+        setPhase('streaming');
+        setDraft('');
+        const newStream = streamSoul(providerId, apiKey, agentName, bio, avatarUrl, personality, tone, voiceStyle, feedback);
+        setCurrentStream(newStream);
+    }, [providerId, apiKey, agentName, bio, avatarUrl, personality, tone, voiceStyle]);
+    return (_jsxs(Box, { flexDirection: "column", children: [phase === 'streaming' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Spinner, { label: feedbackCount > 0 ? 'Regenerating SOUL.md...' : 'Generating SOUL.md...' }) }), _jsx(StreamingText, { stream: currentStream, title: "SOUL.md", onComplete: handleStreamComplete })] })), phase === 'review' && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { marginBottom: 1, children: [_jsxs(Text, { color: colors.green, children: [symbols.check, " "] }), _jsx(Text, { color: colors.white, children: "SOUL.md draft ready" })] }), _jsx(CodeBlock, { title: "SOUL.md", children: draft }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: colors.gray, children: ["Press ", _jsx(Text, { color: colors.honey, bold: true, children: "Enter" }), " to accept", ' ', symbols.dot, ' ', "Type feedback to regenerate"] }) }), _jsx(Box, { marginTop: 1, children: _jsx(TextPrompt, { label: "", placeholder: "Enter to accept, or type feedback...", onSubmit: (val) => {
+                                if (!val) {
+                                    handleAccept();
+                                }
+                                else {
+                                    handleFeedback(val);
+                                }
+                            } }) })] }))] }));
+}

package/dist/create/steps/StrategyStep.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback, useMemo } from 'react';
+import { Box, Text } from 'ink';
+import { StreamingText } from '../../components/StreamingText.js';
+import { TextPrompt } from '../../components/TextPrompt.js';
+import { CodeBlock } from '../../components/CodeBlock.js';
+import { Spinner } from '../../components/Spinner.js';
+import { colors, symbols } from '../../theme.js';
+import { streamStrategy } from '../ai-generate.js';
+export function StrategyStep({ providerId, apiKey, agentName, bio, personality, tone, voiceStyle, onComplete, }) {
+    const [phase, setPhase] = useState('streaming');
+    const [draft, setDraft] = useState('');
+    const [feedbackCount, setFeedbackCount] = useState(0);
+    const stream = useMemo(() => streamStrategy(providerId, apiKey, agentName, bio, personality, tone, voiceStyle), []);
+    const [currentStream, setCurrentStream] = useState(stream);
+    const handleStreamComplete = useCallback((fullText) => {
+        setDraft(fullText);
+        setPhase('review');
+    }, []);
+    const handleAccept = useCallback(() => {
+        onComplete(draft);
+    }, [draft, onComplete]);
+    const handleFeedback = useCallback((feedback) => {
+        setFeedbackCount((prev) => prev + 1);
+        setPhase('streaming');
+        setDraft('');
+        const newStream = streamStrategy(providerId, apiKey, agentName, bio, personality, tone, voiceStyle, feedback);
+        setCurrentStream(newStream);
+    }, [providerId, apiKey, agentName, bio, personality, tone, voiceStyle]);
+    return (_jsxs(Box, { flexDirection: "column", children: [phase === 'streaming' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Spinner, { label: feedbackCount > 0 ? 'Regenerating STRATEGY.md...' : 'Generating STRATEGY.md...' }) }), _jsx(StreamingText, { stream: currentStream, title: "STRATEGY.md", onComplete: handleStreamComplete })] })), phase === 'review' && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { marginBottom: 1, children: [_jsxs(Text, { color: colors.green, children: [symbols.check, " "] }), _jsx(Text, { color: colors.white, children: "STRATEGY.md draft ready" })] }), _jsx(CodeBlock, { title: "STRATEGY.md", children: draft }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: colors.gray, children: ["Press ", _jsx(Text, { color: colors.honey, bold: true, children: "Enter" }), " to accept", ' ', symbols.dot, ' ', "Type feedback to regenerate"] }) }), _jsx(Box, { marginTop: 1, children: _jsx(TextPrompt, { label: "", placeholder: "Enter to accept, or type feedback...", onSubmit: (val) => {
+                                if (!val) {
+                                    handleAccept();
+                                }
+                                else {
+                                    handleFeedback(val);
+                                }
+                            } }) })] }))] }));
+}

package/dist/create/validate-api-key.js

@@ -0,0 +1,44 @@
+import { generateText } from 'ai';
+import { createOpenAI } from '@ai-sdk/openai';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { createXai } from '@ai-sdk/xai';
+import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+/**
+ * Make a lightweight test call to validate the user's API key.
+ * Returns true if the key works, or an error message string on failure.
+ */
+export async function validateApiKey(providerId, apiKey) {
+    try {
+        const model = buildTestModel(providerId, apiKey);
+        await generateText({
+            model,
+            prompt: 'Say "ok"',
+            maxOutputTokens: 16,
+        });
+        return true;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes('401') ||
+            message.includes('Unauthorized') ||
+            message.includes('invalid')) {
+            return 'Invalid API key. Please check and try again.';
+        }
+        return `API validation failed: ${message.slice(0, 120)}`;
+    }
+}
+function buildTestModel(providerId, apiKey) {
+    switch (providerId) {
+        case 'openai':
+            return createOpenAI({ apiKey })('gpt-4o-mini');
+        case 'anthropic':
+            return createAnthropic({ apiKey })('claude-haiku-4-5-20251001');
+        case 'google':
+            return createGoogleGenerativeAI({ apiKey })('gemini-2.0-flash');
+        case 'xai':
+            return createXai({ apiKey })('grok-2');
+        case 'openrouter':
+            return createOpenRouter({ apiKey }).chat('openai/gpt-4o-mini');
+    }
+}

package/dist/create/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 = '#4CAF50';
+const DIM = '#555555';
+const WHITE = '#FFFFFF';
+const RED = '#F44336';
+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/index.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { render } from 'ink';
+import React from 'react';
+import { CreateApp } from './create/CreateApp.js';
+import { ListApp } from './list/ListApp.js';
+import { showWelcome } from './create/welcome.js';
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+const HELP_TEXT = `@hive-org/cli v${pkg.version}
+
+Usage:
+  npx @hive-org/cli create [agent-name]   Scaffold a new Hive agent
+  npx @hive-org/cli list                  List existing agents
+  npx @hive-org/cli --help                Show this help message
+  npx @hive-org/cli --version             Print version
+
+Examples:
+  npx @hive-org/cli create alpha   Creates ~/.hive/agents/alpha/
+  npx @hive-org/cli create         Interactive setup
+  npx @hive-org/cli list           Show all agents`;
+const command = process.argv[2];
+const arg = process.argv[3];
+if (command === '--version' || command === '-v') {
+    console.log(pkg.version);
+    process.exit(0);
+}
+if (!command || command === '--help' || command === '-h') {
+    console.log(HELP_TEXT);
+    process.exit(0);
+}
+if (command === 'list') {
+    const { waitUntilExit } = render(React.createElement(ListApp));
+    await waitUntilExit();
+}
+else if (command === 'create') {
+    const projectName = arg;
+    await showWelcome();
+    const { waitUntilExit } = render(React.createElement(CreateApp, { initialName: projectName }));
+    await waitUntilExit();
+}
+else {
+    console.error(`Unknown command: ${command}\n`);
+    console.log(HELP_TEXT);
+    process.exit(1);
+}