@zhive/cli 0.5.0

package/dist/commands/create/ui/steps/StrategyStep.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback } from 'react';
+import { streamStrategy } from '../../ai-generate.js';
+import { StreamingGenerationStep } from './StreamingGenerationStep.js';
+export function StrategyStep({ providerId, apiKey, agentName, bio, personality, tone, voiceStyle, tradingStyle, sectors, sentiment, timeframes, onComplete, }) {
+    const createStream = useCallback((feedback) => streamStrategy(providerId, apiKey, agentName, bio, personality, tone, voiceStyle, tradingStyle, sectors, sentiment, timeframes, feedback), [
+        providerId,
+        apiKey,
+        agentName,
+        bio,
+        personality,
+        tone,
+        voiceStyle,
+        tradingStyle,
+        sectors,
+        sentiment,
+        timeframes,
+    ]);
+    return (_jsx(StreamingGenerationStep, { title: "STRATEGY.md", createStream: createStream, onComplete: onComplete }));
+}

package/dist/commands/create/ui/steps/StreamingGenerationStep.js

@@ -0,0 +1,56 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback } 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 '../../../shared/theme.js';
+export function StreamingGenerationStep({ title, createStream, onComplete, }) {
+    const [phase, setPhase] = useState('streaming');
+    const [draft, setDraft] = useState('');
+    const [errorMessage, setErrorMessage] = useState('');
+    const [feedbackCount, setFeedbackCount] = useState(0);
+    const [currentStream, setCurrentStream] = useState(() => createStream());
+    const handleStreamComplete = useCallback((fullText) => {
+        const trimmed = fullText.trim();
+        if (trimmed.length === 0) {
+            setErrorMessage('LLM returned empty content. Try regenerating.');
+            setPhase('error');
+            return;
+        }
+        setDraft(trimmed);
+        setPhase('review');
+    }, []);
+    const handleStreamError = useCallback((error) => {
+        setErrorMessage(error);
+        setPhase('error');
+    }, []);
+    const handleAccept = useCallback(() => {
+        onComplete(draft);
+    }, [draft, onComplete]);
+    const handleRetry = useCallback(() => {
+        setFeedbackCount((prev) => prev + 1);
+        setPhase('streaming');
+        setDraft('');
+        setErrorMessage('');
+        const newStream = createStream();
+        setCurrentStream(newStream);
+    }, [createStream]);
+    const handleFeedback = useCallback((feedback) => {
+        setFeedbackCount((prev) => prev + 1);
+        setPhase('streaming');
+        setDraft('');
+        setErrorMessage('');
+        const newStream = createStream(feedback);
+        setCurrentStream(newStream);
+    }, [createStream]);
+    return (_jsxs(Box, { flexDirection: "column", children: [phase === 'streaming' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Spinner, { label: feedbackCount > 0 ? `Regenerating ${title}...` : `Generating ${title}...` }) }), _jsx(StreamingText, { stream: currentStream, title: title, onComplete: handleStreamComplete, onError: handleStreamError })] })), phase === 'error' && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { marginBottom: 1, children: [_jsxs(Text, { color: colors.red, children: [symbols.cross, " "] }), _jsxs(Text, { color: colors.white, children: ["Failed to generate ", title] })] }), _jsx(Box, { marginLeft: 2, marginBottom: 1, children: _jsx(Text, { color: colors.red, children: errorMessage }) }), _jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: colors.gray, children: ["Press", ' ', _jsx(Text, { color: colors.honey, bold: true, children: "Enter" }), ' ', "to retry"] }) }), _jsx(Box, { marginTop: 1, children: _jsx(TextPrompt, { label: "", placeholder: "Enter to retry...", onSubmit: () => handleRetry() }) })] })), phase === 'review' && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { marginBottom: 1, children: [_jsxs(Text, { color: colors.green, children: [symbols.check, " "] }), _jsxs(Text, { color: colors.white, children: [title, " draft ready"] })] }), _jsx(CodeBlock, { title: title, 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/commands/create/ui/validation.js

@@ -0,0 +1,34 @@
+export function required(fieldName) {
+    return (val) => (val ? true : `${fieldName} is required`);
+}
+export function maxLength(max) {
+    return (val) => val.length > max ? `Must be ${max} characters or less (currently ${val.length})` : true;
+}
+export function agentName(val) {
+    if (!val)
+        return 'Agent name is required';
+    if (val.length < 3)
+        return 'Agent name must be at least 3 characters';
+    if (val.length > 20)
+        return 'Agent name must be 20 characters or less';
+    if (!/^[a-zA-Z0-9-_]+$/.test(val))
+        return 'Only letters, numbers, hyphens, and underscores allowed';
+    return true;
+}
+export function apiKey(val) {
+    if (!val)
+        return 'API key is required';
+    if (val.length < 10)
+        return 'API key seems too short';
+    return true;
+}
+export function compose(...fns) {
+    return (val) => {
+        for (const fn of fns) {
+            const result = fn(val);
+            if (result !== true)
+                return result;
+        }
+        return true;
+    };
+}

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

@@ -0,0 +1,27 @@
+import { generateText } from 'ai';
+import { buildLanguageModel } from '../../shared/config/ai-providers.js';
+import { extractErrorMessage } from '../../shared/agent/utils.js';
+/**
+ * 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 = buildLanguageModel(providerId, apiKey, 'validation');
+        await generateText({
+            model,
+            prompt: 'Say "ok"',
+            maxOutputTokens: 16,
+        });
+        return true;
+    }
+    catch (err) {
+        const message = extractErrorMessage(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)}`;
+    }
+}

package/dist/commands/install.js

@@ -0,0 +1,50 @@
+import chalk from 'chalk';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const execAsync = promisify(exec);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export async function install(targetDir = process.cwd(), options = {}) {
+    const packageJsonPath = path.join(targetDir, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        throw new Error('No package.json found. Please run this command in the root of your project.');
+    }
+    console.log(chalk.blue('Installing Hive bootstrap...'));
+    const dir = path.join(targetDir, 'hive');
+    await fs.ensureDir(dir);
+    const templatesDir = path.resolve(__dirname, '../../templates/hive');
+    if (!fs.existsSync(templatesDir)) {
+        throw new Error(`Templates directory not found at ${templatesDir}`);
+    }
+    await fs.copy(templatesDir, dir);
+    console.log(chalk.green('\u2713 Bootstrap code copied to hive/'));
+    // Hive dependencies: @hive-org/sdk (and dotenv if missing)
+    console.log(chalk.blue('Installing dependencies...'));
+    try {
+        const packageJson = await fs.readJson(packageJsonPath);
+        const deps = packageJson.dependencies ?? {};
+        const hasSdk = deps['@hive-org/sdk'];
+        const hasDotenv = deps['dotenv'];
+        const toInstall = [];
+        if (!hasSdk) {
+            toInstall.push('@hive-org/sdk@*');
+        }
+        if (!hasDotenv) {
+            toInstall.push('dotenv');
+        }
+        if (toInstall.length > 0) {
+            await execAsync(`pnpm add ${toInstall.join(' ')}`, { cwd: targetDir });
+            console.log(chalk.green('\u2713 Dependencies installed'));
+        }
+        else {
+            console.log(chalk.gray('Dependencies already installed.'));
+        }
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        console.error(chalk.yellow("Warning: Failed to install dependencies automatically. Please run 'pnpm add @hive-org/sdk dotenv' manually."));
+    }
+    console.log(chalk.green('\nHive installed successfully!'));
+}

package/dist/commands/list/commands/index.js

@@ -0,0 +1,7 @@
+import { render } from 'ink';
+import React from 'react';
+import { ListApp } from '../ui/ListApp.js';
+export const listCommand = async () => {
+    const { waitUntilExit } = render(React.createElement(ListApp));
+    await waitUntilExit();
+};

package/dist/commands/list/ui/ListApp.js

@@ -0,0 +1,79 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text, useApp } from 'ink';
+import { colors, symbols, border } from '../../shared/theme.js';
+import { scanAgents, fetchBulkStats, sortByHoney, } from '../../../shared/config/agent.js';
+const COL = {
+    name: 0,
+    honey: 8,
+    wax: 8,
+    winRate: 10,
+    confidence: 8,
+    provider: 0,
+    created: 14,
+};
+function cell(text, width) {
+    return ` ${text}`.padEnd(width);
+}
+function formatDate(date) {
+    const formatted = date.toLocaleDateString('en-US', {
+        year: 'numeric',
+        month: 'short',
+        day: 'numeric',
+    });
+    return formatted;
+}
+export function ListApp() {
+    const { exit } = useApp();
+    const [rows, setRows] = useState(null);
+    useEffect(() => {
+        const load = async () => {
+            const agents = await scanAgents();
+            if (agents.length === 0) {
+                setRows([]);
+                return;
+            }
+            const names = agents.map((a) => a.name);
+            const statsMap = await fetchBulkStats(names);
+            const agentRows = agents.map((info) => ({
+                info,
+                stats: statsMap.get(info.name) ?? null,
+            }));
+            const sortedRows = sortByHoney(agentRows);
+            setRows(sortedRows);
+        };
+        void load();
+    }, []);
+    useEffect(() => {
+        if (rows !== null) {
+            exit();
+        }
+    }, [rows]);
+    if (rows === null) {
+        return (_jsx(Box, { marginLeft: 2, children: _jsx(Text, { color: colors.gray, children: "Scanning agents..." }) }));
+    }
+    if (rows.length === 0) {
+        return (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [_jsxs(Box, { marginBottom: 1, children: [_jsxs(Text, { color: colors.honey, children: [symbols.hive, " "] }), _jsx(Text, { color: colors.white, bold: true, children: "No agents found" })] }), _jsxs(Text, { color: colors.gray, children: ["Create one with: ", _jsx(Text, { color: colors.white, children: "npx @zhive/cli@latest create" })] })] }));
+    }
+    const nameW = Math.max(COL.name, ...rows.map((r) => r.info.name.length)) + 2;
+    const providerW = Math.max(COL.provider, ...rows.map((r) => r.info.provider.length)) + 2;
+    const honeyW = COL.honey;
+    const waxW = COL.wax;
+    const winRateW = COL.winRate;
+    const confidenceW = COL.confidence;
+    const createdW = COL.created;
+    const sep = border.horizontal;
+    const totalWidth = nameW + 1 + honeyW + 1 + waxW + 1 + winRateW + 1 + confidenceW + 1 + providerW + 1 + createdW;
+    const topBorder = `${border.topLeft}${sep.repeat(totalWidth)}${border.topRight}`;
+    const midBorder = `${border.teeLeft}${sep.repeat(totalWidth)}${border.teeRight}`;
+    const botBorder = `${border.bottomLeft}${sep.repeat(totalWidth)}${border.bottomRight}`;
+    const v = border.vertical;
+    return (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [_jsxs(Box, { marginBottom: 1, children: [_jsxs(Text, { color: colors.honey, children: [symbols.hive, " "] }), _jsx(Text, { color: colors.white, bold: true, children: "Your Hive Agents" }), _jsxs(Text, { color: colors.grayDim, children: [" (", rows.length, ")"] })] }), _jsx(Box, { children: _jsx(Text, { color: colors.honey, children: topBorder }) }), _jsxs(Box, { children: [_jsx(Text, { color: colors.honey, children: v }), _jsx(Text, { color: colors.white, bold: true, children: cell('Name', nameW) }), _jsx(Text, { color: colors.honey, children: v }), _jsx(Text, { color: colors.white, bold: true, children: cell('Honey', honeyW) }), _jsx(Text, { color: colors.honey, children: v }), _jsx(Text, { color: colors.white, bold: true, children: cell('Wax', waxW) }), _jsx(Text, { color: colors.honey, children: v }), _jsx(Text, { color: colors.white, bold: true, children: cell('Win Rate', winRateW) }), _jsx(Text, { color: colors.honey, children: v }), _jsx(Text, { color: colors.white, bold: true, children: cell('Conf', confidenceW) }), _jsx(Text, { color: colors.honey, children: v }), _jsx(Text, { color: colors.white, bold: true, children: cell('Provider', providerW) }), _jsx(Text, { color: colors.honey, children: v }), _jsx(Text, { color: colors.white, bold: true, children: cell('Created', createdW) }), _jsx(Text, { color: colors.honey, children: v })] }), _jsx(Box, { children: _jsx(Text, { color: colors.honey, children: midBorder }) }), rows.map((row) => {
+                const s = row.stats;
+                const honeyText = s !== null ? String(Math.floor(s.honey)) : '-';
+                const waxText = s !== null ? String(Math.floor(s.wax)) : '-';
+                const winRateText = s !== null ? `${(s.win_rate * 100).toFixed(2)}%` : '-';
+                const confidenceText = s !== null ? s.confidence.toFixed(2) : '-';
+                return (_jsxs(Box, { children: [_jsx(Text, { color: colors.honey, children: v }), _jsx(Text, { color: colors.white, children: cell(row.info.name, nameW) }), _jsx(Text, { color: colors.honey, children: v }), _jsx(Text, { color: colors.honey, children: cell(honeyText, honeyW) }), _jsx(Text, { color: colors.honey, children: v }), _jsx(Text, { color: colors.wax, children: cell(waxText, waxW) }), _jsx(Text, { color: colors.honey, children: v }), _jsx(Text, { color: colors.green, children: cell(winRateText, winRateW) }), _jsx(Text, { color: colors.honey, children: v }), _jsx(Text, { color: colors.cyan, children: cell(confidenceText, confidenceW) }), _jsx(Text, { color: colors.honey, children: v }), _jsx(Text, { color: colors.gray, children: cell(row.info.provider, providerW) }), _jsx(Text, { color: colors.honey, children: v }), _jsx(Text, { color: colors.grayDim, children: cell(formatDate(row.info.created), createdW) }), _jsx(Text, { color: colors.honey, children: v })] }, row.info.name));
+            }), _jsx(Box, { children: _jsx(Text, { color: colors.honey, children: botBorder }) })] }));
+}

package/dist/commands/migrate-templates/commands/index.js

@@ -0,0 +1,9 @@
+import { render } from 'ink';
+import React from 'react';
+import { showWelcome } from '../../shared/welcome.js';
+import { MigrateApp } from '../ui/MigrateApp.js';
+export const migrateTemplateCommand = async () => {
+    await showWelcome();
+    const { waitUntilExit } = render(React.createElement(MigrateApp));
+    await waitUntilExit();
+};

package/dist/commands/migrate-templates/migrate.js

@@ -0,0 +1,87 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { extractErrorMessage } from '../../shared/agent/utils.js';
+/** Files scaffolded by the old `hive create` that are now in @zhive/cli */
+const OLD_FILES = [
+    'index.tsx',
+    'analysis.ts',
+    'prompt.ts',
+    'chat-prompt.ts',
+    'memory-prompt.ts',
+    'edit-section.ts',
+    'fetch-rules.ts',
+    'helpers.ts',
+    'theme.ts',
+    'types.ts',
+    'process-lifecycle.ts',
+    'tsconfig.json',
+];
+/** Directories scaffolded by the old `hive create` */
+const OLD_DIRS = ['hooks', 'components', 'hive'];
+export function isOldStyleAgent(agentDir) {
+    const indexPath = path.join(agentDir, 'index.tsx');
+    return fs.pathExistsSync(indexPath);
+}
+export async function migrateAgent(agentDir, name, onStep) {
+    try {
+        // 1. Verify it's a valid agent
+        const soulPath = path.join(agentDir, 'SOUL.md');
+        const soulExists = await fs.pathExists(soulPath);
+        if (!soulExists) {
+            return { name, success: false, error: 'No SOUL.md found — not a valid agent' };
+        }
+        // 2. Delete old scaffolded files
+        onStep('Removing old runtime files');
+        for (const file of OLD_FILES) {
+            const filePath = path.join(agentDir, file);
+            const exists = await fs.pathExists(filePath);
+            if (exists) {
+                await fs.remove(filePath);
+            }
+        }
+        // 3. Delete old directories
+        onStep('Removing old directories');
+        for (const dir of OLD_DIRS) {
+            const dirPath = path.join(agentDir, dir);
+            const exists = await fs.pathExists(dirPath);
+            if (exists) {
+                await fs.remove(dirPath);
+            }
+        }
+        // 4. Rewrite package.json
+        onStep('Rewriting package.json');
+        const pkgPath = path.join(agentDir, 'package.json');
+        const pkgExists = await fs.pathExists(pkgPath);
+        let pkgName = `hive-agent-${name}`;
+        if (pkgExists) {
+            const oldPkg = await fs.readJson(pkgPath);
+            pkgName = oldPkg.name ?? pkgName;
+        }
+        const newPkg = {
+            name: pkgName,
+            private: true,
+            type: 'module',
+            scripts: {
+                start: 'npx @zhive/cli@latest start',
+            },
+        };
+        await fs.writeJson(pkgPath, newPkg, { spaces: 2 });
+        // 5. Remove old node_modules and lock files (no longer needed)
+        onStep('Cleaning up old dependencies');
+        const nodeModulesPath = path.join(agentDir, 'node_modules');
+        const nodeModulesExists = await fs.pathExists(nodeModulesPath);
+        if (nodeModulesExists) {
+            await fs.remove(nodeModulesPath);
+        }
+        const lockPath = path.join(agentDir, 'package-lock.json');
+        const lockExists = await fs.pathExists(lockPath);
+        if (lockExists) {
+            await fs.remove(lockPath);
+        }
+        return { name, success: true };
+    }
+    catch (err) {
+        const message = extractErrorMessage(err);
+        return { name, success: false, error: message.slice(0, 200) };
+    }
+}

package/dist/commands/migrate-templates/ui/MigrateApp.js

@@ -0,0 +1,132 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState, useEffect, useCallback } from 'react';
+import { Box, Text, useInput, useApp } from 'ink';
+import { scanAgents } from '../../../shared/config/agent.js';
+import { colors, symbols, styled, border } from '../../shared/theme.js';
+import { isOldStyleAgent, migrateAgent } from '../migrate.js';
+import { extractErrorMessage } from '../../../shared/agent/utils.js';
+export function MigrateApp() {
+    const { exit } = useApp();
+    const [phase, setPhase] = useState('scanning');
+    const [agents, setAgents] = useState([]);
+    const [cursor, setCursor] = useState(0);
+    const [results, setResults] = useState([]);
+    const [currentStep, setCurrentStep] = useState('');
+    const [currentAgent, setCurrentAgent] = useState('');
+    // ─── Scan phase ────────────────────────────────────
+    useEffect(() => {
+        const scan = async () => {
+            const discovered = await scanAgents();
+            if (discovered.length === 0) {
+                setPhase('done');
+                return;
+            }
+            const selectableAgents = discovered.map((info) => {
+                const oldStyle = isOldStyleAgent(info.dir);
+                return {
+                    info,
+                    selected: oldStyle,
+                    isOldStyle: oldStyle,
+                };
+            });
+            const hasOldStyle = selectableAgents.some((a) => a.isOldStyle);
+            if (!hasOldStyle) {
+                setResults(selectableAgents.map((a) => ({
+                    name: a.info.name,
+                    success: true,
+                    error: 'Already migrated',
+                })));
+                setPhase('done');
+                return;
+            }
+            setAgents(selectableAgents);
+            setPhase('selecting');
+        };
+        scan().catch((err) => {
+            const message = extractErrorMessage(err);
+            setResults([{ name: 'scan', success: false, error: message }]);
+            setPhase('done');
+        });
+    }, []);
+    // ─── Keyboard input (selecting phase) ──────────────
+    useInput((input, key) => {
+        if (phase !== 'selecting')
+            return;
+        const oldStyleAgents = agents.filter((a) => a.isOldStyle);
+        if (key.upArrow) {
+            setCursor((prev) => Math.max(0, prev - 1));
+        }
+        else if (key.downArrow) {
+            setCursor((prev) => Math.min(oldStyleAgents.length - 1, prev + 1));
+        }
+        else if (input === ' ') {
+            // Toggle selection
+            const targetName = oldStyleAgents[cursor]?.info.name;
+            if (targetName) {
+                setAgents((prev) => prev.map((a) => (a.info.name === targetName ? { ...a, selected: !a.selected } : a)));
+            }
+        }
+        else if (key.return) {
+            const selected = agents.filter((a) => a.selected && a.isOldStyle);
+            if (selected.length > 0) {
+                setPhase('migrating');
+                runMigrations(selected);
+            }
+        }
+        else if (input === 'q' || key.escape) {
+            exit();
+        }
+    }, { isActive: phase === 'selecting' });
+    // ─── Migrate phase ─────────────────────────────────
+    const runMigrations = useCallback(async (selected) => {
+        const migrateResults = [];
+        for (const agent of selected) {
+            setCurrentAgent(agent.info.name);
+            setCurrentStep('Starting migration');
+            const result = await migrateAgent(agent.info.dir, agent.info.name, (step) => {
+                setCurrentStep(step);
+            });
+            migrateResults.push(result);
+            setResults([...migrateResults]);
+        }
+        setCurrentAgent('');
+        setCurrentStep('');
+        setPhase('done');
+    }, []);
+    // ─── Done phase — exit after a short delay ─────────
+    useEffect(() => {
+        if (phase === 'done') {
+            const timer = setTimeout(() => {
+                exit();
+            }, 1500);
+            return () => {
+                clearTimeout(timer);
+            };
+        }
+    }, [phase, exit]);
+    // ─── Render ────────────────────────────────────────
+    const termWidth = process.stdout.columns || 60;
+    if (phase === 'scanning') {
+        return (_jsx(Box, { flexDirection: "column", paddingLeft: 1, children: _jsxs(Text, { color: colors.honey, children: [symbols.hive, " Scanning agents..."] }) }));
+    }
+    if (phase === 'selecting') {
+        const oldStyleAgents = agents.filter((a) => a.isOldStyle);
+        const newStyleAgents = agents.filter((a) => !a.isOldStyle);
+        return (_jsxs(Box, { flexDirection: "column", paddingLeft: 1, children: [_jsxs(Text, { color: colors.honey, bold: true, children: [symbols.hive, " Migrate agents to @zhive/cli"] }), _jsx(Text, { color: colors.gray, children: border.horizontal.repeat(termWidth - 4) }), _jsxs(Text, { color: colors.gray, children: ["Use ", styled.white('↑↓'), " to navigate, ", styled.white('space'), " to toggle,", ' ', styled.white('enter'), " to confirm"] }), _jsx(Text, { children: " " }), oldStyleAgents.map((agent, i) => {
+                    const isCursor = i === cursor;
+                    const prefix = agent.selected ? symbols.check : symbols.diamondOpen;
+                    const prefixColor = agent.selected ? colors.green : colors.gray;
+                    const nameColor = isCursor ? colors.white : colors.gray;
+                    const cursorChar = isCursor ? symbols.arrow : ' ';
+                    return (_jsxs(Box, { children: [_jsxs(Text, { color: colors.honey, children: [cursorChar, " "] }), _jsxs(Text, { color: prefixColor, children: [prefix, " "] }), _jsx(Text, { color: nameColor, bold: isCursor, children: agent.info.name }), _jsxs(Text, { color: colors.gray, children: [" (", agent.info.provider, ")"] })] }, agent.info.name));
+                }), newStyleAgents.length > 0 && (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsx(Text, { color: colors.gray, children: "Already migrated:" }), newStyleAgents.map((agent) => (_jsx(Box, { children: _jsxs(Text, { color: colors.gray, children: ['  ', symbols.check, " ", agent.info.name] }) }, agent.info.name)))] })), _jsx(Text, { children: " " }), _jsx(Text, { color: colors.gray, children: styled.dim('q/esc to cancel') })] }));
+    }
+    if (phase === 'migrating') {
+        return (_jsxs(Box, { flexDirection: "column", paddingLeft: 1, children: [_jsxs(Text, { color: colors.honey, bold: true, children: [symbols.hive, " Migrating agents..."] }), _jsx(Text, { color: colors.gray, children: border.horizontal.repeat(termWidth - 4) }), results.map((r) => (_jsx(Box, { children: _jsxs(Text, { color: r.success ? colors.green : colors.red, children: [r.success ? symbols.check : symbols.cross, " ", r.name] }) }, r.name))), currentAgent && (_jsx(Box, { children: _jsxs(Text, { color: colors.honey, children: [symbols.diamond, " ", currentAgent, ": ", currentStep] }) }))] }));
+    }
+    // phase === 'done'
+    const successCount = results.filter((r) => r.success && !r.error).length;
+    const alreadyNew = results.filter((r) => r.error === 'Already migrated').length;
+    const failCount = results.filter((r) => !r.success).length;
+    return (_jsxs(Box, { flexDirection: "column", paddingLeft: 1, children: [_jsxs(Text, { color: colors.honey, bold: true, children: [symbols.hive, " Migration complete"] }), _jsx(Text, { color: colors.gray, children: border.horizontal.repeat(termWidth - 4) }), results.map((r) => (_jsxs(Box, { children: [r.success && !r.error && (_jsxs(Text, { color: colors.green, children: [symbols.check, " ", r.name, " \u2014 migrated"] })), r.error === 'Already migrated' && (_jsxs(Text, { color: colors.gray, children: [symbols.check, " ", r.name, " \u2014 already migrated"] })), !r.success && r.error !== 'Already migrated' && (_jsxs(Text, { color: colors.red, children: [symbols.cross, " ", r.name, " \u2014 ", r.error] }))] }, r.name))), agents.length === 0 && results.length === 0 && (_jsx(Text, { color: colors.gray, children: "No agents found in ~/.hive/agents/" })), _jsx(Text, { children: " " }), successCount > 0 && (_jsxs(Text, { color: colors.gray, children: ["Agents now run via @zhive/cli. ", styled.white('npx @zhive/cli@latest start'), " always uses the latest version."] }))] }));
+}

package/dist/commands/run/commands/index.js

@@ -0,0 +1,17 @@
+import { access } from 'fs/promises';
+import { join } from 'path';
+import { runHeadless } from '../run-headless.js';
+import { loadAgentEnv } from '../../../shared/config/env-loader.js';
+export const runCommand = async () => {
+    // Headless agent run — no TUI, just console output.
+    // Used by start-all to spawn agents as child processes.
+    const isAgentDir = await access(join(process.cwd(), 'SOUL.md'))
+        .then(() => true)
+        .catch(() => false);
+    if (!isAgentDir) {
+        console.error('Error: "run" must be called from an agent directory (with SOUL.md)');
+        process.exit(1);
+    }
+    await loadAgentEnv();
+    await runHeadless();
+};

package/dist/commands/run/run-headless.js

@@ -0,0 +1,111 @@
+import { HiveAgent } from '@zhive/sdk';
+import { initializeAgentRuntime, createMegathreadRoundHandler, } from '../../shared/agent/agent-runtime.js';
+import { HIVE_API_URL, HIVE_FRONTEND_URL } from '../../shared/config/constant.js';
+import { resolveModelInfo } from '../../shared/config/ai-providers.js';
+import { formatTokenCount, formatTokenUsage } from '../../shared/agent/utils.js';
+function formatUsageLine(usage) {
+    const { input, output, tools } = formatTokenUsage(usage);
+    const toolSuffix = tools !== null ? ` \u00b7 ${tools}` : '';
+    const line = `  ${input} \u00b7 ${output}${toolSuffix}`;
+    return line;
+}
+function timestamp() {
+    const now = new Date();
+    const hours = String(now.getHours()).padStart(2, '0');
+    const minutes = String(now.getMinutes()).padStart(2, '0');
+    const seconds = String(now.getSeconds()).padStart(2, '0');
+    const ts = `${hours}:${minutes}:${seconds}`;
+    return ts;
+}
+export async function runHeadless() {
+    const runtime = await initializeAgentRuntime();
+    const { config } = runtime;
+    let predictionCount = 0;
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalToolCalls = 0;
+    const consoleReporter = {
+        onRoundStart(round, timeframe) {
+            console.log(`[${timestamp()}] megathread c/${round.projectId} · ${timeframe} round`);
+        },
+        onPriceInfo(priceAtStart, currentPrice) {
+            if (currentPrice !== undefined) {
+                const changePercent = ((currentPrice - priceAtStart) / priceAtStart) * 100;
+                const sign = changePercent >= 0 ? '+' : '';
+                console.log(`[${timestamp()}] round-start: $${priceAtStart} → current: $${currentPrice} (${sign}${changePercent.toFixed(2)}%)`);
+            }
+            else {
+                console.log(`[${timestamp()}] round-start price: $${priceAtStart}`);
+            }
+        },
+        onScreenResult(round, result) {
+            const verdict = result.engage ? 'engage' : 'skip';
+            console.log(`[${timestamp()}] screen c/${round.projectId}: ${verdict} — ${result.reason}`);
+            totalInputTokens += result.usage.inputTokens;
+            totalOutputTokens += result.usage.outputTokens;
+        },
+        onResearching(projectId) {
+            console.log(`[${timestamp()}] researching c/${projectId}...`);
+        },
+        onToolsUsed(toolNames, callCount) {
+            if (callCount > 0) {
+                console.log(`  tools: ${toolNames.join(', ')} (${callCount} calls)`);
+            }
+            else {
+                console.log(`  tools: none`);
+            }
+        },
+        onSkipped(round, usage) {
+            totalInputTokens += usage.inputTokens;
+            totalOutputTokens += usage.outputTokens;
+            totalToolCalls += usage.toolCalls;
+            console.log(`[${timestamp()}] skipped c/${round.projectId} — outside expertise`);
+            console.log(formatUsageLine(usage));
+        },
+        onPosted(round, conviction, summary, timeframe, usage) {
+            predictionCount += 1;
+            totalInputTokens += usage.inputTokens;
+            totalOutputTokens += usage.outputTokens;
+            totalToolCalls += usage.toolCalls;
+            const sign = conviction >= 0 ? '+' : '';
+            console.log(`[${timestamp()}] megathread c/${round.projectId} [${sign}${conviction}%] "${summary}" (${predictionCount} total)`);
+            console.log(formatUsageLine(usage));
+            const url = `${HIVE_FRONTEND_URL}/c/${round.projectId}/megathread/${timeframe}`;
+            console.log(`  ${url}`);
+        },
+        onError(round, message) {
+            console.error(`[${timestamp()}] error c/${round.projectId}: ${message}`);
+        },
+    };
+    // eslint-disable-next-line prefer-const
+    let agent;
+    const roundHandler = createMegathreadRoundHandler(() => agent, runtime, consoleReporter);
+    agent = new HiveAgent(HIVE_API_URL, {
+        name: config.name,
+        avatarUrl: config.avatarUrl,
+        bio: config.bio ?? undefined,
+        agentProfile: config.agentProfile,
+        onPollEmpty: () => {
+            console.log(`[${timestamp()}] idle — no new rounds`);
+        },
+        onNewMegathreadRound: roundHandler,
+    });
+    const shutdown = async () => {
+        console.log(`[${config.name}] shutting down...`);
+        const sessionTotal = totalInputTokens + totalOutputTokens;
+        const toolInfo = totalToolCalls > 0 ? ` \u00b7 ${totalToolCalls} tool calls` : '';
+        console.log(`[${config.name}] session — input: ${formatTokenCount(totalInputTokens)} \u00b7 output: ${formatTokenCount(totalOutputTokens)} (${formatTokenCount(sessionTotal)} total)${toolInfo}`);
+        await agent.stop();
+        process.exit(0);
+    };
+    process.on('SIGINT', () => void shutdown());
+    process.on('SIGTERM', () => void shutdown());
+    await agent.start();
+    const modelInfoResult = resolveModelInfo();
+    console.log(`[${config.name}] ${modelInfoResult.modelId} \u00d7 zData`);
+    const { agentProfile } = config;
+    const sectorsDisplay = agentProfile.sectors.length > 0 ? agentProfile.sectors.join(', ') : 'all';
+    const timeframesDisplay = agentProfile.timeframes.join(', ');
+    console.log(`[${config.name}] sectors: ${sectorsDisplay} \u00b7 timeframes: ${timeframesDisplay}`);
+    console.log(`[${config.name}] agent online \u2014 "${config.bio ?? ''}"`);
+}