@zhive/cli 0.5.0

package/dist/shared/config/agent.js

@@ -0,0 +1,177 @@
+import axios from 'axios';
+import fsExtra from 'fs-extra';
+import * as fs from 'fs/promises';
+import os from 'os';
+import path, { join } from 'path';
+import { HIVE_API_URL } from './constant.js';
+import { AI_PROVIDERS } from './ai-providers.js';
+const VALID_SENTIMENTS = [
+    'very-bullish',
+    'bullish',
+    'neutral',
+    'bearish',
+    'very-bearish',
+];
+const VALID_TIMEFRAMES = ['1h', '4h', '24h'];
+function extractField(content, pattern) {
+    const match = content.match(pattern);
+    if (match === null) {
+        return null;
+    }
+    const value = match[1].trim();
+    return value;
+}
+async function detectProvider(agentDir) {
+    // Try old-style detection: check package.json dependencies
+    const pkgPath = path.join(agentDir, 'package.json');
+    const pkgExists = await fsExtra.pathExists(pkgPath);
+    if (pkgExists) {
+        const pkg = await fsExtra.readJson(pkgPath);
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        for (const provider of AI_PROVIDERS) {
+            if (deps[provider.package]) {
+                return provider.label;
+            }
+        }
+    }
+    // New-style detection: check .env for provider API keys
+    const envPath = path.join(agentDir, '.env');
+    const envExists = await fsExtra.pathExists(envPath);
+    if (envExists) {
+        const envContent = await fs.readFile(envPath, 'utf-8');
+        for (const provider of AI_PROVIDERS) {
+            const pattern = new RegExp(`^${provider.envVar}=.+`, 'm');
+            if (pattern.test(envContent)) {
+                return provider.label;
+            }
+        }
+    }
+    return 'unknown';
+}
+export async function loadAgentConfig(_agentDir) {
+    const agentDir = _agentDir ?? process.cwd();
+    const soulPath = join(agentDir, 'SOUL.md');
+    const strategyPath = join(agentDir, 'STRATEGY.md');
+    const soulContent = await loadMarkdownFile(soulPath);
+    const strategyContent = await loadMarkdownFile(strategyPath);
+    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 stat = await fs.stat(soulPath);
+    const provider = await detectProvider(agentDir);
+    const agentProfile = {
+        sentiment: parseSentiment(sentimentRaw),
+        sectors: parseSectors(sectorsRaw),
+        timeframes: parseTimeframes(timeframesRaw),
+    };
+    return {
+        name,
+        bio,
+        dir: agentDir,
+        provider,
+        avatarUrl,
+        soulContent,
+        strategyContent,
+        agentProfile,
+        created: stat.birthtime,
+    };
+}
+export async function scanAgents() {
+    const agentsDir = path.join(os.homedir(), '.hive', 'agents');
+    const exists = await fsExtra.pathExists(agentsDir);
+    if (!exists) {
+        return [];
+    }
+    const entries = await fsExtra.readdir(agentsDir, { withFileTypes: true });
+    const agents = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const dir = path.join(agentsDir, entry.name);
+        const config = await loadAgentConfig(dir).catch((err) => null);
+        if (!config) {
+            continue;
+        }
+        agents.push(config);
+    }
+    return agents;
+}
+export function sortByHoney(rows) {
+    const sorted = [...rows].sort((a, b) => (b.stats?.honey ?? 0) - (a.stats?.honey ?? 0));
+    return sorted;
+}
+export function sortAgentsByHoney(agents, statsMap) {
+    const sorted = [...agents].sort((a, b) => {
+        const honeyA = statsMap.get(a.name)?.honey ?? 0;
+        const honeyB = statsMap.get(b.name)?.honey ?? 0;
+        return honeyB - honeyA;
+    });
+    return sorted;
+}
+export async function fetchBulkStats(names) {
+    const statsMap = new Map();
+    if (names.length === 0) {
+        return statsMap;
+    }
+    try {
+        const response = await axios.post(`${HIVE_API_URL}/agent/by-names`, { names });
+        for (const agent of response.data) {
+            statsMap.set(agent.name, {
+                honey: agent.honey ?? 0,
+                wax: agent.wax ?? 0,
+                win_rate: agent.win_rate ?? 0,
+                confidence: agent.confidence ?? 0,
+                simulated_pnl: agent.simulated_pnl ?? 0,
+                total_comments: agent.total_comments ?? 0,
+            });
+        }
+    }
+    catch {
+        // API unreachable — return empty map, CLI will show dashes
+    }
+    return statsMap;
+}
+async function loadMarkdownFile(filePath) {
+    const content = await fs.readFile(filePath, 'utf-8');
+    return content;
+}
+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;
+}

package/dist/shared/config/ai-providers.js

@@ -0,0 +1,156 @@
+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';
+import { getAgentProviderKeys } from './env-loader.js';
+let _modelPromise = null;
+export const AI_PROVIDERS = [
+    {
+        id: 'openai',
+        label: 'OpenAI',
+        package: '@ai-sdk/openai',
+        envVar: 'OPENAI_API_KEY',
+        models: { validation: 'gpt-4o-mini', generation: 'gpt-5-mini', runtime: 'gpt-5-mini' },
+        load: async (modelId) => {
+            const { openai } = await import('@ai-sdk/openai');
+            return openai(modelId);
+        },
+    },
+    {
+        id: 'anthropic',
+        label: 'Anthropic',
+        package: '@ai-sdk/anthropic',
+        envVar: 'ANTHROPIC_API_KEY',
+        models: {
+            validation: 'claude-haiku-4-5-20251001',
+            generation: 'claude-haiku-4-5',
+            runtime: 'claude-haiku-4-5',
+        },
+        load: async (modelId) => {
+            const { anthropic } = await import('@ai-sdk/anthropic');
+            return anthropic(modelId);
+        },
+    },
+    {
+        id: 'google',
+        label: 'Google',
+        package: '@ai-sdk/google',
+        envVar: 'GOOGLE_GENERATIVE_AI_API_KEY',
+        models: {
+            validation: 'gemini-2.0-flash',
+            generation: 'gemini-3-flash-preview',
+            runtime: 'gemini-3-flash-preview',
+        },
+        load: async (modelId) => {
+            const { google } = await import('@ai-sdk/google');
+            return google(modelId);
+        },
+    },
+    {
+        id: 'xai',
+        label: 'xAI',
+        package: '@ai-sdk/xai',
+        envVar: 'XAI_API_KEY',
+        models: {
+            validation: 'grok-2',
+            generation: 'grok-4-1-fast-reasoning',
+            runtime: 'grok-4-1-fast-reasoning',
+        },
+        load: async (modelId) => {
+            const { xai } = await import('@ai-sdk/xai');
+            return xai(modelId);
+        },
+    },
+    {
+        id: 'openrouter',
+        label: 'OpenRouter',
+        package: '@openrouter/ai-sdk-provider',
+        envVar: 'OPENROUTER_API_KEY',
+        models: {
+            validation: 'openai/gpt-4o-mini',
+            generation: 'openai/gpt-5.1-mini',
+            runtime: 'openai/gpt-5.1-mini',
+        },
+        load: async (modelId) => {
+            const { createOpenRouter } = await import('@openrouter/ai-sdk-provider');
+            const openrouter = createOpenRouter({ apiKey: process.env.OPENROUTER_API_KEY });
+            return openrouter.chat(modelId);
+        },
+    },
+];
+/**
+ * All env-var names used by AI providers.
+ * Used to clear shell-inherited keys before loading an agent's .env,
+ * so only the agent's chosen provider is active.
+ */
+export const AI_PROVIDER_ENV_VARS = AI_PROVIDERS.map((p) => p.envVar);
+export function buildLanguageModel(providerId, apiKey, modelType) {
+    const provider = getProvider(providerId);
+    const modelId = provider.models[modelType];
+    switch (providerId) {
+        case 'openai':
+            return createOpenAI({ apiKey })(modelId);
+        case 'anthropic':
+            return createAnthropic({ apiKey })(modelId);
+        case 'google':
+            return createGoogleGenerativeAI({ apiKey })(modelId);
+        case 'xai':
+            return createXai({ apiKey })(modelId);
+        case 'openrouter':
+            return createOpenRouter({ apiKey }).chat(modelId);
+    }
+}
+export function getProvider(id) {
+    const provider = AI_PROVIDERS.find((p) => p.id === id);
+    if (!provider) {
+        throw new Error(`Unknown AI provider: ${id}`);
+    }
+    return provider;
+}
+export function resolveModelInfo() {
+    const overrideModel = process.env.HIVE_MODEL;
+    const agentKeys = getAgentProviderKeys();
+    const sortedProviders = [
+        ...AI_PROVIDERS.filter((p) => agentKeys.has(p.envVar)),
+        ...AI_PROVIDERS.filter((p) => !agentKeys.has(p.envVar)),
+    ];
+    for (const provider of sortedProviders) {
+        const keyValue = process.env[provider.envVar];
+        if (keyValue && keyValue.trim().length > 0) {
+            const centralProvider = AI_PROVIDERS.find((p) => p.envVar === provider.envVar);
+            const runtimeModel = centralProvider?.models.runtime ?? 'unknown';
+            const modelId = overrideModel ?? runtimeModel;
+            const source = agentKeys.has(provider.envVar) ? '.env' : 'shell';
+            return { provider: provider.label, modelId, source };
+        }
+    }
+    return { provider: 'unknown', modelId: 'unknown', source: 'unknown' };
+}
+export function getModel() {
+    if (_modelPromise) {
+        return _modelPromise;
+    }
+    _modelPromise = (async () => {
+        const info = resolveModelInfo();
+        if (info.provider === 'unknown') {
+            throw new Error('No AI provider API key found in environment. ' +
+                'Set one of: ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_GENERATIVE_AI_API_KEY, XAI_API_KEY, OPENROUTER_API_KEY');
+        }
+        const agentKeys = getAgentProviderKeys();
+        const sortedProviders = [
+            ...AI_PROVIDERS.filter((p) => agentKeys.has(p.envVar)),
+            ...AI_PROVIDERS.filter((p) => !agentKeys.has(p.envVar)),
+        ];
+        for (const provider of sortedProviders) {
+            const keyValue = process.env[provider.envVar];
+            if (keyValue && keyValue.trim().length > 0) {
+                const modelId = info.modelId;
+                const model = await provider.load(modelId);
+                return model;
+            }
+        }
+        throw new Error('Unreachable: resolveModelInfo succeeded but no provider found');
+    })();
+    return _modelPromise;
+}

package/dist/shared/config/config.js

@@ -0,0 +1,22 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { getHiveDir } from './constant.js';
+export async function readConfig() {
+    try {
+        const configPath = path.join(getHiveDir(), 'config.json');
+        const config = (await fs.readJson(configPath));
+        if (!config.providerId || !config.apiKey) {
+            return null;
+        }
+        return config;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeConfig(config) {
+    const hiveDir = getHiveDir();
+    await fs.ensureDir(hiveDir);
+    const configPath = path.join(hiveDir, 'config.json');
+    await fs.writeJson(configPath, config, { spaces: 2, mode: 0o600 });
+}

package/dist/shared/config/constant.js

@@ -0,0 +1,8 @@
+import path from 'path';
+import os from 'os';
+export const HIVE_API_URL = 'https://api.zhive.ai';
+export const HIVE_FRONTEND_URL = 'https://www.zhive.ai';
+export function getHiveDir() {
+    const hiveDir = path.join(os.homedir(), '.hive');
+    return hiveDir;
+}

package/dist/shared/config/env-loader.js

@@ -0,0 +1,30 @@
+import { readFileSync } from 'fs';
+import { AI_PROVIDER_ENV_VARS } from './ai-providers.js';
+let _agentProviderKeys = new Set();
+/**
+ * Provider env-var names declared in the agent's .env file.
+ * Used by getModel() to prioritize the agent's chosen provider
+ * over keys inherited from the shell.
+ */
+export function getAgentProviderKeys() {
+    return _agentProviderKeys;
+}
+/**
+ * Load the agent's .env with provider-key priority.
+ *
+ * 1. Parse .env to discover which provider keys the agent declared.
+ * 2. Load .env with override so the agent's values win for the same key.
+ * 3. getModel() uses getAgentProviderKeys() to check those providers first,
+ *    falling back to shell-inherited keys if the agent has none.
+ */
+export async function loadAgentEnv() {
+    try {
+        const content = readFileSync('.env', 'utf-8');
+        _agentProviderKeys = new Set(AI_PROVIDER_ENV_VARS.filter((key) => new RegExp(`^${key}=`, 'm').test(content)));
+    }
+    catch {
+        _agentProviderKeys = new Set();
+    }
+    const { config } = await import('dotenv');
+    config({ override: true });
+}

package/dist/shared/types.js

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

package/dist/start/AgentProcessManager.js

@@ -0,0 +1,98 @@
+import { spawn } from 'child_process';
+import path from 'path';
+import os from 'os';
+const FORCE_KILL_TIMEOUT_MS = 5_000;
+const ABSOLUTE_TIMEOUT_MS = FORCE_KILL_TIMEOUT_MS + 2_000;
+export class AgentProcessManager {
+    constructor() {
+        this._agents = new Map();
+        this._agentsDir = path.join(os.homedir(), '.hive', 'agents');
+    }
+    spawnAll(discovered) {
+        for (const agent of discovered) {
+            this._agents.set(agent.name, {
+                name: agent.name,
+                status: 'spawning',
+                exitCode: null,
+                child: null,
+            });
+            this._spawnPiped(agent.name);
+        }
+    }
+    getStates() {
+        const states = [];
+        for (const agent of this._agents.values()) {
+            states.push({
+                name: agent.name,
+                status: agent.status,
+                exitCode: agent.exitCode,
+            });
+        }
+        return states;
+    }
+    async stopAgent(name) {
+        const agent = this._agents.get(name);
+        if (!agent?.child) {
+            return;
+        }
+        const child = agent.child;
+        const exitPromise = new Promise((resolve) => {
+            if (child.exitCode !== null) {
+                resolve();
+                return;
+            }
+            child.on('exit', () => resolve());
+            // Absolute safety timeout in case SIGKILL is not enough
+            setTimeout(() => resolve(), ABSOLUTE_TIMEOUT_MS);
+        });
+        child.kill('SIGTERM');
+        const forceKillTimer = setTimeout(() => {
+            child.kill('SIGKILL');
+        }, FORCE_KILL_TIMEOUT_MS);
+        await exitPromise;
+        clearTimeout(forceKillTimer);
+        agent.child = null;
+    }
+    respawnPiped(name) {
+        const agent = this._agents.get(name);
+        if (!agent) {
+            return;
+        }
+        agent.status = 'spawning';
+        agent.exitCode = null;
+        agent.child = null;
+        this._spawnPiped(name);
+    }
+    _spawnPiped(name) {
+        const agentDir = path.join(this._agentsDir, name);
+        const child = spawn('npx', ['@hive-org/cli@latest', 'run'], {
+            cwd: agentDir,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const agent = this._agents.get(name);
+        if (!agent) {
+            return;
+        }
+        agent.child = child;
+        // Transition to 'running' once the OS has spawned the process
+        child.on('spawn', () => {
+            if (agent.status === 'spawning') {
+                agent.status = 'running';
+            }
+        });
+        // Drain stdout/stderr to prevent buffer blocking
+        child.stdout?.resume();
+        child.stderr?.resume();
+        child.on('error', () => {
+            agent.status = 'errored';
+            agent.exitCode = null;
+            agent.child = null;
+        });
+        child.on('exit', (code) => {
+            const exitCode = code ?? 1;
+            agent.status = exitCode === 0 ? 'exited' : 'errored';
+            agent.exitCode = exitCode;
+            agent.child = null;
+        });
+    }
+}

package/dist/start/Dashboard.js

@@ -0,0 +1,92 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text, useApp, useInput } from 'ink';
+import { colors, symbols, border } from '../theme.js';
+const STATUS_COLORS = {
+    spawning: colors.honey,
+    running: colors.green,
+    exited: colors.grayDim,
+    errored: colors.red,
+};
+const STATUS_SYMBOLS = {
+    spawning: symbols.diamondOpen,
+    running: symbols.dot,
+    exited: '\u25CB', // ○
+    errored: symbols.cross,
+};
+const POLL_INTERVAL_MS = 1_000;
+const STOPPABLE = new Set(['running', 'spawning']);
+const STARTABLE = new Set(['exited', 'errored']);
+function ColoredStats({ stats }) {
+    return (_jsxs(_Fragment, { children: [_jsxs(Text, { color: colors.honey, children: ["H:", Math.floor(stats.honey)] }), _jsx(Text, { color: colors.grayDim, children: "  " }), _jsxs(Text, { color: colors.wax, children: ["W:", Math.floor(stats.wax)] }), _jsx(Text, { color: colors.grayDim, children: "  " }), _jsxs(Text, { color: colors.green, children: ["WR:", (stats.win_rate * 100).toFixed(2), "%"] }), _jsx(Text, { color: colors.grayDim, children: "  " }), _jsxs(Text, { color: colors.cyan, children: ["C:", stats.confidence.toFixed(2)] })] }));
+}
+export function Dashboard({ manager, statsMap }) {
+    const { exit } = useApp();
+    const [agents, setAgents] = useState(manager.getStates());
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    useEffect(() => {
+        const timer = setInterval(() => {
+            setAgents(manager.getStates());
+        }, POLL_INTERVAL_MS);
+        return () => clearInterval(timer);
+    }, [manager]);
+    // Clamp selectedIndex when agents list changes
+    useEffect(() => {
+        const maxIndex = Math.max(agents.length - 1, 0);
+        setSelectedIndex((prev) => Math.min(prev, maxIndex));
+    }, [agents.length]);
+    useInput((_input, key) => {
+        if (key.upArrow) {
+            setSelectedIndex((prev) => {
+                const max = agents.length - 1;
+                return prev > 0 ? prev - 1 : max;
+            });
+        }
+        else if (key.downArrow) {
+            setSelectedIndex((prev) => {
+                const max = agents.length - 1;
+                return prev < max ? prev + 1 : 0;
+            });
+        }
+        else if (_input === ' ' || key.return) {
+            const agent = agents[selectedIndex];
+            if (!agent) {
+                return;
+            }
+            if (STOPPABLE.has(agent.status)) {
+                void manager.stopAgent(agent.name);
+            }
+            else if (STARTABLE.has(agent.status)) {
+                manager.respawnPiped(agent.name);
+            }
+        }
+        else if (key.ctrl && _input === 'c') {
+            exit();
+        }
+    });
+    const runningCount = agents.filter((a) => a.status === 'running').length;
+    const spawningCount = agents.filter((a) => a.status === 'spawning').length;
+    const stoppedCount = agents.filter((a) => a.status === 'exited' || a.status === 'errored').length;
+    const statusParts = [];
+    if (runningCount > 0) {
+        statusParts.push(`${runningCount} running`);
+    }
+    if (spawningCount > 0) {
+        statusParts.push(`${spawningCount} starting`);
+    }
+    if (stoppedCount > 0) {
+        statusParts.push(`${stoppedCount} stopped`);
+    }
+    const statusLabel = statusParts.length > 0 ? statusParts.join(', ') : 'no agents running';
+    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: "Hive Swarm" }), _jsxs(Text, { color: colors.gray, children: [' ', border.horizontal, " ", agents.length, " agent", agents.length !== 1 ? 's' : '', ' ', border.horizontal, " ", statusLabel] })] }), agents.map((agent, index) => {
+                const isSelected = index === selectedIndex;
+                const statusColor = STATUS_COLORS[agent.status];
+                const statusSymbol = STATUS_SYMBOLS[agent.status];
+                const isAlive = agent.status === 'running' || agent.status === 'spawning';
+                const statusText = agent.status === 'exited' || agent.status === 'errored'
+                    ? `${agent.status} (${agent.exitCode})`
+                    : agent.status;
+                const agentStats = statsMap.get(agent.name);
+                return (_jsxs(Box, { children: [_jsx(Text, { color: isSelected ? colors.honey : undefined, children: isSelected ? `${symbols.diamond} ` : '  ' }), _jsxs(Text, { color: statusColor, children: [statusSymbol, " "] }), _jsx(Text, { color: isAlive ? colors.white : colors.grayDim, children: agent.name.padEnd(20) }), _jsx(Text, { color: statusColor, children: statusText.padEnd(16) }), agentStats && _jsx(ColoredStats, { stats: agentStats })] }, agent.name));
+            }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: colors.grayDim, children: [symbols.arrow, " ", '\u2191\u2193', " navigate ", '  ', " space/enter stop/start ", '  ', " ctrl+c quit"] }) })] }));
+}

package/dist/start/SelectAgentApp.js

@@ -0,0 +1,81 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text, useApp, useInput } from 'ink';
+import { colors, symbols } from '../theme.js';
+import { scanAgents, fetchBulkStats, sortByHoney } from '../agents.js';
+function formatDate(date) {
+    const formatted = date.toLocaleDateString('en-US', {
+        year: 'numeric',
+        month: 'short',
+        day: 'numeric',
+    });
+    return formatted;
+}
+function StatsText({ stats }) {
+    if (stats === null) {
+        return _jsx(Text, { color: colors.grayDim, children: "-" });
+    }
+    return (_jsxs(_Fragment, { children: [_jsxs(Text, { color: colors.honey, children: ["H:", Math.floor(stats.honey)] }), _jsx(Text, { color: colors.grayDim, children: "  " }), _jsxs(Text, { color: colors.wax, children: ["W:", Math.floor(stats.wax)] }), _jsx(Text, { color: colors.grayDim, children: "  " }), _jsxs(Text, { color: colors.green, children: ["WR:", (stats.win_rate * 100).toFixed(2), "%"] }), _jsx(Text, { color: colors.grayDim, children: "  " }), _jsxs(Text, { color: colors.cyan, children: ["C:", stats.confidence.toFixed(2)] })] }));
+}
+export function SelectAgentApp({ onSelect }) {
+    const { exit } = useApp();
+    const [rows, setRows] = useState(null);
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    useEffect(() => {
+        const load = async () => {
+            const agents = await scanAgents();
+            if (agents.length === 0) {
+                setRows([]);
+                exit();
+                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();
+    }, []);
+    useInput((_input, key) => {
+        if (rows === null || rows.length === 0) {
+            return;
+        }
+        if (key.upArrow) {
+            setSelectedIndex((prev) => {
+                const max = rows.length - 1;
+                return prev > 0 ? prev - 1 : max;
+            });
+        }
+        else if (key.downArrow) {
+            setSelectedIndex((prev) => {
+                const max = rows.length - 1;
+                return prev < max ? prev + 1 : 0;
+            });
+        }
+        else if (key.return) {
+            const row = rows[selectedIndex];
+            if (row) {
+                onSelect(row.info);
+                exit();
+            }
+        }
+        else if (key.ctrl && _input === 'c') {
+            exit();
+        }
+    });
+    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 @hive-org/cli@latest create" })] })] }));
+    }
+    const nameWidth = Math.max(6, ...rows.map((r) => r.info.name.length)) + 2;
+    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: "Select an agent to start" }), _jsxs(Text, { color: colors.grayDim, children: [" (", rows.length, ")"] })] }), rows.map((row, index) => {
+                const isSelected = index === selectedIndex;
+                return (_jsxs(Box, { children: [_jsx(Text, { color: isSelected ? colors.honey : colors.grayDim, children: isSelected ? `${symbols.diamond} ` : '  ' }), _jsx(Text, { color: isSelected ? colors.white : colors.gray, bold: isSelected, children: row.info.name.padEnd(nameWidth) }), _jsx(StatsText, { stats: row.stats }), _jsxs(Text, { color: colors.grayDim, children: ["  ", formatDate(row.info.created)] })] }, row.info.name));
+            }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: colors.grayDim, children: [symbols.arrow, " ", '\u2191\u2193', " navigate ", '  ', " enter select ", '  ', " ctrl+c quit"] }) })] }));
+}