@hive-org/cli 0.0.6 → 0.0.7

package/dist/agent/theme.js

@@ -0,0 +1,37 @@
+export const colors = {
+    honey: '#F5A623',
+    honeyDark: '#D4891A',
+    white: '#FFFFFF',
+    gray: '#888888',
+    grayDim: '#555555',
+    green: '#4CAF50',
+    red: '#F44336',
+    cyan: '#00BCD4',
+};
+export const symbols = {
+    hive: '\u2B21', // ⬡
+    diamond: '\u25C6', // ◆
+    diamondOpen: '\u25C7', // ◇
+    dot: '\u25CF', // ●
+    check: '\u2713', // ✓
+    cross: '\u2717', // ✗
+    arrow: '\u203A', // ›
+    circle: '\u25CB', // ○
+};
+export const border = {
+    horizontal: '\u2500', // ─
+    vertical: '\u2502', // │
+    topLeft: '\u250C', // ┌
+    topRight: '\u2510', // ┐
+    bottomLeft: '\u2514', // └
+    bottomRight: '\u2518', // ┘
+    teeLeft: '\u251C', // ├
+    teeRight: '\u2524', // ┤
+};
+export const animation = {
+    DATA_CHARS: '01\u25AA\u25AB\u2591\u2592',
+    HEX_CHARS: '\u2B21\u2B22',
+    TICK_MS: 120,
+    HEX_W: 8,
+    HEX_H: 4,
+};

package/dist/agent/types.js

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

package/dist/agents.js

@@ -1,6 +1,7 @@
 import fs from 'fs-extra';
 import path from 'path';
 import os from 'os';
+import { AI_PROVIDERS } from './ai-providers.js';
 export async function scanAgents() {
     const agentsDir = path.join(os.homedir(), '.hive', 'agents');
     const exists = await fs.pathExists(agentsDir);
@@ -18,29 +19,37 @@ export async function scanAgents() {
         if (!soulExists) {
             continue;
         }
-        let provider = 'unknown';
-        const envPath = path.join(agentsDir, entry.name, '.env');
-        const envExists = await fs.pathExists(envPath);
-        if (envExists) {
-            const envContent = await fs.readFile(envPath, 'utf-8');
-            if (envContent.includes('OPENAI_API_KEY')) {
-                provider = 'OpenAI';
-            }
-            else if (envContent.includes('ANTHROPIC_API_KEY')) {
-                provider = 'Anthropic';
-            }
-            else if (envContent.includes('GOOGLE_GENERATIVE_AI_API_KEY')) {
-                provider = 'Google';
-            }
-            else if (envContent.includes('XAI_API_KEY')) {
-                provider = 'xAI';
+        const agentDir = path.join(agentsDir, entry.name);
+        const provider = await detectProvider(agentDir);
+        const stat = await fs.stat(soulPath);
+        agents.push({ name: entry.name, dir: agentDir, provider, created: stat.birthtime });
+    }
+    return agents;
+}
+async function detectProvider(agentDir) {
+    // Try old-style detection: check package.json dependencies
+    const pkgPath = path.join(agentDir, 'package.json');
+    const pkgExists = await fs.pathExists(pkgPath);
+    if (pkgExists) {
+        const pkg = await fs.readJson(pkgPath);
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        for (const provider of AI_PROVIDERS) {
+            if (deps[provider.package]) {
+                return provider.label;
             }
-            else if (envContent.includes('OPENROUTER_API_KEY')) {
-                provider = 'OpenRouter';
+        }
+    }
+    // New-style detection: check .env for provider API keys
+    const envPath = path.join(agentDir, '.env');
+    const envExists = await fs.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;
             }
         }
-        const stat = await fs.stat(soulPath);
-        agents.push({ name: entry.name, provider, created: stat.birthtime });
     }
-    return agents;
+    return 'unknown';
 }

package/dist/ai-providers.js

@@ -47,16 +47,3 @@ export function getProvider(id) {
     }
     return provider;
 }
-/** Regex: default provider import line (and trailing newline). */
-const DEFAULT_IMPORT_LINE_REGEX = /import\s*\{\s*openai\s*\}\s*from\s*['"]@ai-sdk\/openai['"]\s*;\s*\n/;
-/** Regex: default model call in generateText() — global to catch all occurrences. */
-const DEFAULT_MODEL_CALL_REGEX = /openai\s*\(\s*['"]gpt-4o['"]\s*\)/g;
-/**
- * Replace the default (OpenAI) provider and model call in the example template with the chosen provider.
- */
-export function applyAdapterToChatTemplate(template, provider) {
-    const importReplacement = provider.importLine + '\n';
-    let out = template.replace(DEFAULT_IMPORT_LINE_REGEX, importReplacement);
-    out = out.replaceAll(DEFAULT_MODEL_CALL_REGEX, provider.modelCall);
-    return out;
-}

package/dist/create/generate.js

@@ -1,12 +1,6 @@
 import fs from 'fs-extra';
 import path from 'path';
 import os from 'os';
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import { fileURLToPath } from 'url';
-import { applyAdapterToChatTemplate } from '../ai-providers.js';
-const execAsync = promisify(exec);
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
 export async function scaffoldProject(projectName, provider, apiKey, soulContent, strategyContent, callbacks) {
     // Validate project name to prevent path traversal / command injection
     if (!/^[a-zA-Z0-9_-]+$/.test(projectName)) {
@@ -29,17 +23,7 @@ export async function scaffoldProject(projectName, provider, apiKey, soulContent
     // 1. Create directory
     callbacks.onStep('Creating project directory');
     await fs.ensureDir(projectDir);
-    // 2. Initialize npm project
-    callbacks.onStep('Initializing project');
-    await execAsync('npm init -y', { cwd: projectDir });
-    // 4. Install hive bootstrap
-    callbacks.onStep('Installing Hive SDK');
-    const templatesDir = path.resolve(__dirname, '../../templates');
-    const hiveTemplatesDir = path.join(templatesDir, 'hive');
-    const hiveDir = path.join(projectDir, 'hive');
-    await fs.ensureDir(hiveDir);
-    await fs.copy(hiveTemplatesDir, hiveDir);
-    // 5. Write SOUL.md and STRATEGY.md
+    // 2. Write SOUL.md and STRATEGY.md
     callbacks.onStep('Writing personality files');
     await fs.writeFile(path.join(projectDir, 'SOUL.md'), soulContent, 'utf-8');
     await fs.writeFile(path.join(projectDir, 'STRATEGY.md'), strategyContent, 'utf-8');
@@ -58,116 +42,22 @@ export async function scaffoldProject(projectName, provider, apiKey, soulContent
 (none yet)
 `;
     await fs.writeFile(path.join(projectDir, 'MEMORY.md'), seedMemory, 'utf-8');
-    // 6. Write .env
+    // 3. Write .env
     callbacks.onStep('Writing environment file');
     const envContent = `HIVE_API_URL="https://hive-backend.z3n.dev"
 ${provider.envVar}="${apiKey}"
 `;
     await fs.writeFile(path.join(projectDir, '.env'), envContent, { encoding: 'utf-8', mode: 0o600 });
-    // 7. Copy prompt.ts
-    callbacks.onStep('Creating agent files');
-    const promptPath = path.join(templatesDir, 'prompt.ts');
-    const promptExists = await fs.pathExists(promptPath);
-    if (promptExists) {
-        const promptFileContent = await fs.readFile(promptPath, 'utf-8');
-        await fs.writeFile(path.join(projectDir, 'prompt.ts'), promptFileContent, 'utf-8');
-    }
-    // 8. Copy and adapt index.tsx (Ink TUI agent — no model calls, just UI shell)
-    const tuiTemplatePath = path.join(templatesDir, 'index.tsx');
-    const tuiTemplate = await fs.readFile(tuiTemplatePath, 'utf-8');
-    await fs.writeFile(path.join(projectDir, 'index.tsx'), tuiTemplate, 'utf-8');
-    // Copy and adapt analysis.ts (contains model calls)
-    const analysisTemplate = await fs.readFile(path.join(templatesDir, 'analysis.ts'), 'utf-8');
-    const analysisContent = applyAdapterToChatTemplate(analysisTemplate, provider);
-    await fs.writeFile(path.join(projectDir, 'analysis.ts'), analysisContent, 'utf-8');
-    // Copy process-lifecycle.ts
-    const lifecycleContent = await fs.readFile(path.join(templatesDir, 'process-lifecycle.ts'), 'utf-8');
-    await fs.writeFile(path.join(projectDir, 'process-lifecycle.ts'), lifecycleContent, 'utf-8');
-    // Copy hooks/ directory and adapt useAgent.ts (contains model calls)
-    const hooksTemplatesDir = path.join(templatesDir, 'hooks');
-    const hooksDir = path.join(projectDir, 'hooks');
-    await fs.ensureDir(hooksDir);
-    const useAgentTemplate = await fs.readFile(path.join(hooksTemplatesDir, 'useAgent.ts'), 'utf-8');
-    const useAgentContent = applyAdapterToChatTemplate(useAgentTemplate, provider);
-    await fs.writeFile(path.join(hooksDir, 'useAgent.ts'), useAgentContent, 'utf-8');
-    // Copy theme.ts, types.ts, helpers.ts
-    const themeContent = await fs.readFile(path.join(templatesDir, 'theme.ts'), 'utf-8');
-    await fs.writeFile(path.join(projectDir, 'theme.ts'), themeContent, 'utf-8');
-    const typesContent = await fs.readFile(path.join(templatesDir, 'types.ts'), 'utf-8');
-    await fs.writeFile(path.join(projectDir, 'types.ts'), typesContent, 'utf-8');
-    const helpersContent = await fs.readFile(path.join(templatesDir, 'helpers.ts'), 'utf-8');
-    await fs.writeFile(path.join(projectDir, 'helpers.ts'), helpersContent, 'utf-8');
-    // Copy components/ directory
-    const componentsTemplatesDir = path.join(templatesDir, 'components');
-    const componentsDir = path.join(projectDir, 'components');
-    await fs.ensureDir(componentsDir);
-    await fs.copy(componentsTemplatesDir, componentsDir);
-    // Copy chat-prompt.ts
-    const chatPromptPath = path.join(templatesDir, 'chat-prompt.ts');
-    const chatPromptContent = await fs.readFile(chatPromptPath, 'utf-8');
-    await fs.writeFile(path.join(projectDir, 'chat-prompt.ts'), chatPromptContent, 'utf-8');
-    // Copy memory-prompt.ts
-    const memoryPromptPath = path.join(templatesDir, 'memory-prompt.ts');
-    const memoryPromptContent = await fs.readFile(memoryPromptPath, 'utf-8');
-    await fs.writeFile(path.join(projectDir, 'memory-prompt.ts'), memoryPromptContent, 'utf-8');
-    // Copy edit-section.ts
-    const editSectionPath = path.join(templatesDir, 'edit-section.ts');
-    const editSectionContent = await fs.readFile(editSectionPath, 'utf-8');
-    await fs.writeFile(path.join(projectDir, 'edit-section.ts'), editSectionContent, 'utf-8');
-    // Copy fetch-rules.ts
-    const fetchRulesPath = path.join(templatesDir, 'fetch-rules.ts');
-    const fetchRulesContent = await fs.readFile(fetchRulesPath, 'utf-8');
-    await fs.writeFile(path.join(projectDir, 'fetch-rules.ts'), fetchRulesContent, 'utf-8');
-    // 9. Configure package.json
+    // 4. Write minimal package.json — no deps needed, npx fetches @hive-org/agent@latest on every run
     callbacks.onStep('Configuring project');
-    const packageJsonPath = path.join(projectDir, 'package.json');
-    const packageJson = await fs.readJson(packageJsonPath);
-    packageJson.type = 'module';
-    packageJson.scripts = {
-        ...packageJson.scripts,
-        start: 'tsx index.tsx',
-    };
-    packageJson.dependencies = {
-        ...packageJson.dependencies,
-        '@hive-org/sdk': 'latest',
-        dotenv: '^16.0.0',
-        ai: '^6.0.71',
-        chalk: '^5.4.1',
-        zod: '^4.0.0',
-        [provider.package]: '^3.0.0',
-        ink: '^5.1.0',
-        'ink-text-input': '^6.0.0',
-        react: '^18.3.1',
-    };
-    await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-    // 10. Write tsconfig.json
-    const tsConfig = {
-        compilerOptions: {
-            target: 'ES2020',
-            module: 'ESNext',
-            moduleResolution: 'bundler',
-            jsx: 'react-jsx',
-            outDir: './dist',
-            rootDir: '.',
-            strict: true,
-            esModuleInterop: true,
-            skipLibCheck: true,
-            baseUrl: '.',
-            paths: {
-                '@/*': ['./*'],
-            },
+    const packageJson = {
+        name: `hive-agent-${projectName}`,
+        private: true,
+        type: 'module',
+        scripts: {
+            start: 'npx @hive-org/cli@latest run',
         },
     };
-    await fs.writeJson(path.join(projectDir, 'tsconfig.json'), tsConfig, { spaces: 2 });
-    // 11. Install dependencies
-    callbacks.onStep('Installing dependencies');
-    const adapterInstall = `ai ${provider.package}`;
-    try {
-        await execAsync(`npm install --save-dev typescript @types/node @types/react tsx && npm install ${adapterInstall}`, { cwd: projectDir });
-    }
-    catch {
-        callbacks.onError(`Failed to install dependencies. Run manually:\n  cd ${normalizedProjectDir}\n  npm install --save-dev typescript @types/node @types/react tsx && npm install ${adapterInstall}`);
-        return;
-    }
+    await fs.writeJson(path.join(projectDir, 'package.json'), packageJson, { spaces: 2 });
     callbacks.onDone(normalizedProjectDir);
 }

package/dist/index.js

@@ -4,7 +4,7 @@ import { render } from 'ink';
 import React from 'react';
 import { CreateApp } from './create/CreateApp.js';
 import { ListApp } from './list/ListApp.js';
-import { StartApp } from './start/StartApp.js';
+import { startCommand } from './start/start-command.js';
 import { showWelcome } from './create/welcome.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
@@ -14,6 +14,8 @@ Usage:
   npx @hive-org/cli@latest create [agent-name]   Scaffold a new Hive agent
   npx @hive-org/cli@latest list                  List existing agents
   npx @hive-org/cli@latest start                 Start all agents
+  npx @hive-org/cli@latest run                   Run agent in current directory
+  npx @hive-org/cli@latest migrate-templates     Migrate old-style agents
   npx @hive-org/cli@latest --help                Show this help message
   npx @hive-org/cli@latest --version             Print version
 
@@ -21,7 +23,8 @@ Examples:
   npx @hive-org/cli@latest create alpha   Creates ~/.hive/agents/alpha/
   npx @hive-org/cli@latest create         Interactive setup
   npx @hive-org/cli@latest list           Show all agents
-  npx @hive-org/cli@latest start          Launch all agents as child processes`;
+  npx @hive-org/cli@latest start          Launch all agents as child processes
+  npx @hive-org/cli@latest run            Run agent from cwd (reads SOUL.md, .env)`;
 const command = process.argv[2];
 const arg = process.argv[3];
 if (command === '--version' || command === '-v') {
@@ -37,8 +40,7 @@ if (command === 'list') {
     await waitUntilExit();
 }
 else if (command === 'start') {
-    const { waitUntilExit } = render(React.createElement(StartApp));
-    await waitUntilExit();
+    await startCommand();
 }
 else if (command === 'create') {
     const projectName = arg;
@@ -46,6 +48,27 @@ else if (command === 'create') {
     const { waitUntilExit } = render(React.createElement(CreateApp, { initialName: projectName }));
     await waitUntilExit();
 }
+else if (command === 'migrate-templates') {
+    await showWelcome();
+    const { MigrateApp } = await import('./migrate-templates/MigrateApp.js');
+    const { waitUntilExit } = render(React.createElement(MigrateApp));
+    await waitUntilExit();
+}
+else if (command === 'run') {
+    const fs = await import('fs');
+    const path = await import('path');
+    const soulPath = path.join(process.cwd(), 'SOUL.md');
+    if (!fs.existsSync(soulPath)) {
+        console.error('No SOUL.md found in current directory. Run this command from an agent directory.');
+        process.exit(1);
+    }
+    await import('dotenv/config');
+    const { setupProcessLifecycle } = await import('./agent/process-lifecycle.js');
+    const { App } = await import('./agent/app.js');
+    setupProcessLifecycle();
+    const { waitUntilExit } = render(React.createElement(App));
+    await waitUntilExit();
+}
 else {
     console.error(`Unknown command: ${command}\n`);
     console.log(HELP_TEXT);

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: "gray", children: border.horizontal.repeat(termWidth - 4) }), _jsxs(Text, { color: "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 ? 'white' : '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: "gray", children: [" (", agent.info.provider, ")"] })] }, agent.info.name));
+                }), newStyleAgents.length > 0 && (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsx(Text, { color: "gray", children: "Already migrated:" }), newStyleAgents.map((agent) => (_jsx(Box, { children: _jsxs(Text, { color: "gray", children: ['  ', symbols.check, " ", agent.info.name] }) }, agent.info.name)))] })), _jsx(Text, { children: " " }), _jsx(Text, { color: "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: "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: "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: "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: "gray", children: "No agents found in ~/.hive/agents/" })), _jsx(Text, { children: " " }), successCount > 0 && (_jsxs(Text, { color: "gray", children: ["Agents now run via @hive-org/cli. ", styled.white('npx @hive-org/cli@latest run'), " 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 run',
+            },
+        };
+        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) };
+    }
+}