@zhive/cli 0.6.2 → 0.6.3

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

@@ -0,0 +1,47 @@
+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';
+import { getProvider } from '../ai-providers.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 = 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) {
+    const provider = getProvider(providerId);
+    const modelId = provider.models.validation;
+    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);
+    }
+}

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 = '#27C587';
+const DIM = '#555555';
+const WHITE = '#FFFFFF';
+const RED = '#E14B4B';
+const SCRAMBLE_CHARS = '⬡⬢◆◇░▒!@#$%01';
+const BOOT_MESSAGES = [
+    { prefix: '⬡', text: 'Initializing creation studio...', frame: 18, color: HONEY },
+    { prefix: '◆', text: 'Loading agent templates...', frame: 24, color: HONEY },
+    { prefix: '◇', text: 'Connecting to hive network...', frame: 30, color: HONEY },
+    { prefix: '✓', text: 'Ready', frame: 36, color: GREEN },
+];
+function isHexEdge(r, c) {
+    const rowInHex = ((r % HEX_H) + HEX_H) % HEX_H;
+    const isOddHex = Math.floor(r / HEX_H) % 2 === 1;
+    const colOffset = isOddHex ? HEX_W / 2 : 0;
+    const colInHex = (((c - colOffset) % HEX_W) + HEX_W) % HEX_W;
+    if (rowInHex === 0 || rowInHex === HEX_H - 1) {
+        return colInHex >= 2 && colInHex <= 5;
+    }
+    if (rowInHex === 1 || rowInHex === 2) {
+        return colInHex === 1 || colInHex === 6;
+    }
+    return false;
+}
+export function showWelcome() {
+    return new Promise((resolve) => {
+        const cols = process.stdout.columns || 60;
+        const gridRows = process.stdout.rows || 24;
+        let frame = 0;
+        // Init bees
+        const bees = [];
+        for (let i = 0; i < NUM_BEES; i++) {
+            bees.push({
+                r: Math.floor(Math.random() * gridRows),
+                c: Math.floor(Math.random() * cols),
+                vr: Math.random() > 0.5 ? 1 : -1,
+                vc: Math.random() > 0.5 ? 1 : -1,
+            });
+        }
+        // Init stream columns
+        const streamCols = [];
+        const spacing = Math.floor(cols / (NUM_STREAMS + 1));
+        for (let i = 1; i <= NUM_STREAMS; i++) {
+            streamCols.push(spacing * i);
+        }
+        let pulses = [];
+        // Title positioning
+        const title = '\u2B21 HIVE';
+        const subtitle = 'Agent Creation Studio';
+        const titleRow = Math.floor(gridRows / 2) - 1;
+        const subtitleRow = titleRow + 1;
+        const titleCol = Math.floor((cols - title.length) / 2);
+        const subtitleCol = Math.floor((cols - subtitle.length) / 2);
+        // Boot message row positions
+        const msgStartRow = subtitleRow + 2;
+        // Quiet zone around title + boot messages: no animation renders here
+        const PADDING_H = 3;
+        const PADDING_V = 1;
+        const longestMsg = BOOT_MESSAGES.reduce((max, m) => Math.max(max, m.prefix.length + 1 + m.text.length), 0);
+        const msgLeftEdge = Math.floor((cols - longestMsg) / 2);
+        const msgRightEdge = msgLeftEdge + longestMsg;
+        const quietLeft = Math.min(titleCol, subtitleCol, msgLeftEdge) - PADDING_H;
+        const quietRight = Math.max(titleCol + title.length, subtitleCol + subtitle.length, msgRightEdge) + PADDING_H;
+        const quietTop = titleRow - PADDING_V;
+        const quietBottom = msgStartRow + BOOT_MESSAGES.length + PADDING_V;
+        // Hide cursor
+        process.stdout.write('\x1b[?25l');
+        // Clear screen
+        process.stdout.write('\x1b[2J');
+        function renderFrame() {
+            // Move cursor to top-left
+            process.stdout.write('\x1b[H');
+            // Advance bees every other frame
+            if (frame > 0 && frame % 2 === 0) {
+                for (const bee of bees) {
+                    bee.r += bee.vr;
+                    bee.c += bee.vc;
+                    if (bee.r <= 0 || bee.r >= gridRows - 1) {
+                        bee.vr *= -1;
+                        bee.r = Math.max(0, Math.min(gridRows - 1, bee.r));
+                    }
+                    if (bee.c <= 0 || bee.c >= cols - 1) {
+                        bee.vc *= -1;
+                        bee.c = Math.max(0, Math.min(cols - 1, bee.c));
+                    }
+                    if (Math.random() > 0.3) {
+                        bee.vc = Math.random() > 0.5 ? 1 : -1;
+                    }
+                }
+            }
+            // Spawn pulses
+            if (frame % 4 === 0) {
+                for (let i = 0; i < 3; i++) {
+                    const pr = Math.floor(Math.random() * gridRows);
+                    const pc = Math.floor(Math.random() * cols);
+                    if (isHexEdge(pr, pc)) {
+                        const pulseColors = [GREEN, RED, HONEY];
+                        const color = pulseColors[Math.floor(Math.random() * pulseColors.length)];
+                        pulses.push({ r: pr, c: pc, ttl: 8, color });
+                    }
+                }
+                pulses = pulses.filter((p) => p.ttl > 0).map((p) => ({ ...p, ttl: p.ttl - 1 }));
+            }
+            // Build grid: char + color pairs
+            const charGrid = [];
+            const colorGrid = [];
+            for (let r = 0; r < gridRows; r++) {
+                const chars = [];
+                const clrs = [];
+                for (let c = 0; c < cols; c++) {
+                    // Skip animation in quiet zone around title
+                    if (r >= quietTop && r <= quietBottom && c >= quietLeft && c < quietRight) {
+                        chars.push(' ');
+                        clrs.push(DIM);
+                        continue;
+                    }
+                    const hexEdge = isHexEdge(r, c);
+                    // Scanning wave
+                    const scanRow = frame % (gridRows + 6);
+                    const dist = Math.abs(r - scanRow);
+                    if (hexEdge && dist === 0) {
+                        chars.push('⬢');
+                        clrs.push(HONEY);
+                        continue;
+                    }
+                    if (hexEdge && dist <= 1) {
+                        chars.push('⬡');
+                        clrs.push(HONEY);
+                        continue;
+                    }
+                    // Data streams
+                    let isStream = false;
+                    for (const sc of streamCols) {
+                        if (c === sc) {
+                            const streamOffset = (frame * 2 + sc) % (gridRows * 3);
+                            const streamDist = (((r - streamOffset) % gridRows) + gridRows) % gridRows;
+                            if (streamDist < 6) {
+                                const charIdx = (frame + r) % DATA_CHARS.length;
+                                const streamChar = DATA_CHARS[charIdx];
+                                chars.push(streamChar);
+                                if (streamDist === 0) {
+                                    clrs.push(WHITE);
+                                }
+                                else if (streamDist < 3) {
+                                    clrs.push(GREEN);
+                                }
+                                else {
+                                    clrs.push(DIM);
+                                }
+                                isStream = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (isStream)
+                        continue;
+                    // Default
+                    if (hexEdge) {
+                        chars.push('·');
+                        clrs.push(DIM);
+                    }
+                    else {
+                        chars.push(' ');
+                        clrs.push(DIM);
+                    }
+                }
+                charGrid.push(chars);
+                colorGrid.push(clrs);
+            }
+            // Overlay pulses (skip quiet zone)
+            for (const pulse of pulses) {
+                if (pulse.r >= 0 && pulse.r < gridRows && pulse.c >= 0 && pulse.c < cols) {
+                    const inQuietZone = pulse.r >= quietTop &&
+                        pulse.r <= quietBottom &&
+                        pulse.c >= quietLeft &&
+                        pulse.c < quietRight;
+                    if (inQuietZone)
+                        continue;
+                    const brightness = pulse.ttl / 8;
+                    const cell = charGrid[pulse.r][pulse.c];
+                    if (cell === '·' || cell === ' ') {
+                        charGrid[pulse.r][pulse.c] = brightness > 0.5 ? '⬡' : '·';
+                        colorGrid[pulse.r][pulse.c] = pulse.color;
+                    }
+                }
+            }
+            // Overlay bees (skip quiet zone)
+            for (const bee of bees) {
+                const br = Math.max(0, Math.min(gridRows - 1, Math.round(bee.r)));
+                const bc = Math.max(0, Math.min(cols - 1, Math.round(bee.c)));
+                const inQuietZone = br >= quietTop && br <= quietBottom && bc >= quietLeft && bc < quietRight;
+                if (!inQuietZone) {
+                    charGrid[br][bc] = '◆';
+                    colorGrid[br][bc] = HONEY;
+                }
+            }
+            // Overlay title with scramble→reveal effect
+            const TITLE_START_FRAME = 6;
+            const TITLE_REVEAL_FRAMES = 8;
+            if (frame >= TITLE_START_FRAME && titleRow >= 0 && titleRow < gridRows) {
+                const scrambleProgress = Math.min(1, (frame - TITLE_START_FRAME) / TITLE_REVEAL_FRAMES);
+                for (let i = 0; i < title.length; i++) {
+                    const tc = titleCol + i;
+                    if (tc < 0 || tc >= cols)
+                        continue;
+                    const charThreshold = i / title.length;
+                    if (charThreshold <= scrambleProgress) {
+                        charGrid[titleRow][tc] = title[i];
+                        colorGrid[titleRow][tc] = HONEY;
+                    }
+                    else {
+                        const scrambleIdx = Math.floor(Math.random() * SCRAMBLE_CHARS.length);
+                        charGrid[titleRow][tc] = SCRAMBLE_CHARS[scrambleIdx];
+                        colorGrid[titleRow][tc] = DIM;
+                    }
+                }
+            }
+            // Overlay subtitle with scramble→reveal (starts a few frames after title)
+            const SUB_START_FRAME = 10;
+            const SUB_REVEAL_FRAMES = 8;
+            if (frame >= SUB_START_FRAME && subtitleRow >= 0 && subtitleRow < gridRows) {
+                const scrambleProgress = Math.min(1, (frame - SUB_START_FRAME) / SUB_REVEAL_FRAMES);
+                for (let i = 0; i < subtitle.length; i++) {
+                    const sc = subtitleCol + i;
+                    if (sc < 0 || sc >= cols)
+                        continue;
+                    const charThreshold = i / subtitle.length;
+                    if (charThreshold <= scrambleProgress) {
+                        charGrid[subtitleRow][sc] = subtitle[i];
+                        colorGrid[subtitleRow][sc] = DIM;
+                    }
+                    else {
+                        const scrambleIdx = Math.floor(Math.random() * SCRAMBLE_CHARS.length);
+                        charGrid[subtitleRow][sc] = SCRAMBLE_CHARS[scrambleIdx];
+                        colorGrid[subtitleRow][sc] = DIM;
+                    }
+                }
+            }
+            // Overlay typewriter boot messages
+            for (let idx = 0; idx < BOOT_MESSAGES.length; idx++) {
+                const msg = BOOT_MESSAGES[idx];
+                if (frame < msg.frame)
+                    continue;
+                const r = msgStartRow + idx;
+                if (r < 0 || r >= gridRows)
+                    continue;
+                const fullText = `${msg.prefix} ${msg.text}`;
+                const msgCol = Math.floor((cols - fullText.length) / 2);
+                const visibleChars = Math.min(fullText.length, (frame - msg.frame) * 3);
+                for (let i = 0; i < visibleChars; i++) {
+                    const c = msgCol + i;
+                    if (c < 0 || c >= cols)
+                        continue;
+                    charGrid[r][c] = fullText[i];
+                    colorGrid[r][c] = msg.color;
+                }
+            }
+            // Render to stdout
+            let output = '';
+            for (let r = 0; r < gridRows; r++) {
+                let line = '';
+                let runColor = colorGrid[r][0];
+                let runChars = '';
+                for (let c = 0; c < cols; c++) {
+                    const curColor = colorGrid[r][c];
+                    const curChar = charGrid[r][c];
+                    if (curColor === runColor) {
+                        runChars += curChar;
+                    }
+                    else {
+                        line += chalk.hex(runColor)(runChars);
+                        runColor = curColor;
+                        runChars = curChar;
+                    }
+                }
+                if (runChars.length > 0) {
+                    line += chalk.hex(runColor)(runChars);
+                }
+                output += line;
+                if (r < gridRows - 1) {
+                    output += '\n';
+                }
+            }
+            process.stdout.write(output);
+            frame++;
+        }
+        const timer = setInterval(renderFrame, TICK_MS);
+        setTimeout(() => {
+            clearInterval(timer);
+            // Clear screen, show cursor, move to top
+            process.stdout.write('\x1b[2J\x1b[H\x1b[?25h');
+            resolve();
+        }, DURATION_MS);
+    });
+}

package/dist/list/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 '../theme.js';
+import { scanAgents, fetchBulkStats, sortByHoney } from '../agents.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 @hive-org/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/{services/agent/env.js → load-agent-env.js}

@@ -1,5 +1,5 @@
 import { readFileSync } from 'fs';
-import { AI_PROVIDER_ENV_VARS } from '../ai-providers.js';
+import { AI_PROVIDER_ENV_VARS } from './ai-providers.js';
 let _agentProviderKeys = new Set();
 /**
  * Provider env-var names declared in the agent's .env file.

package/dist/migrate-templates/MigrateApp.js

@@ -0,0 +1,131 @@
+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 '../agents.js';
+import { colors, symbols, styled, border } from '../theme.js';
+import { isOldStyleAgent, migrateAgent } from './migrate.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 = err instanceof Error ? err.message : String(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 @hive-org/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 @hive-org/cli. ", styled.white('npx @hive-org/cli@latest start'), " always uses the latest version."] }))] }));
+}

package/dist/migrate-templates/migrate.js

@@ -0,0 +1,86 @@
+import fs from 'fs-extra';
+import path from 'path';
+/** Files scaffolded by the old `hive create` that are now in @hive-org/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 @hive-org/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 = err instanceof Error ? err.message : String(err);
+        return { name, success: false, error: message.slice(0, 200) };
+    }
+}