@zhive/cli 0.6.0 → 0.6.1

package/dist/start/patch-managed-mode.js

@@ -0,0 +1,142 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TEMPLATES_DIR = path.resolve(__dirname, '../../templates');
+const MANAGED_MARKER = 'HIVE_MANAGED';
+const INTERACTIVE_GUARD_MARKER = 'Input Bar — only when stdin is a real TTY';
+/**
+ * Patches an existing agent to support:
+ * 1. Headless mode — skip TextInput when stdin is not a TTY (piped by dashboard)
+ * 2. Managed mode — Escape exits back to dashboard when HIVE_MANAGED=1
+ *
+ * Idempotent — skips if already patched.
+ */
+export async function ensureManagedMode(agentDir) {
+    await patchProcessLifecycle(agentDir);
+    await patchIndexTsx(agentDir);
+}
+async function patchProcessLifecycle(agentDir) {
+    const filePath = path.join(agentDir, 'process-lifecycle.ts');
+    const exists = await fs.pathExists(filePath);
+    if (!exists) {
+        return;
+    }
+    const content = await fs.readFile(filePath, 'utf-8');
+    // Already patched if gracefulShutdown is exported
+    if (content.includes('export const gracefulShutdown')) {
+        return;
+    }
+    // Copy the template version (it has the export + exitCode param)
+    const templatePath = path.join(TEMPLATES_DIR, 'process-lifecycle.ts');
+    const templateExists = await fs.pathExists(templatePath);
+    if (!templateExists) {
+        return;
+    }
+    await fs.copyFile(templatePath, filePath);
+}
+async function patchIndexTsx(agentDir) {
+    const filePath = path.join(agentDir, 'index.tsx');
+    const exists = await fs.pathExists(filePath);
+    if (!exists) {
+        return;
+    }
+    let content = await fs.readFile(filePath, 'utf-8');
+    // Already fully patched
+    if (content.includes(MANAGED_MARKER) && content.includes(INTERACTIVE_GUARD_MARKER)) {
+        return;
+    }
+    // 1. Add useInput to ink import if not present
+    //    Existing pattern: "import { render, Box, Text } from 'ink';"
+    //    Target:           "import { render, Box, Text, useInput } from 'ink';"
+    if (!content.includes('useInput')) {
+        content = content.replace(/\s*}\s*from\s*'ink'/, ", useInput } from 'ink'");
+    }
+    // 2. Add gracefulShutdown import from process-lifecycle if not present
+    if (!content.includes('gracefulShutdown')) {
+        content = content.replace(/import\s*\{\s*setupProcessLifecycle\s*\}\s*from\s*'\.\/process-lifecycle'/, "import { setupProcessLifecycle, gracefulShutdown } from './process-lifecycle'");
+    }
+    // 3. Add isInteractive + managed mode hooks after useAgent() destructuring
+    if (!content.includes(MANAGED_MARKER)) {
+        const useAgentClose = '} = useAgent();';
+        const hookInsertIndex = content.indexOf(useAgentClose);
+        if (hookInsertIndex === -1) {
+            return;
+        }
+        const insertAfter = hookInsertIndex + useAgentClose.length;
+        const hooks = `
+
+  // When stdin is not a TTY (piped by hive-cli start), skip interactive input
+  const isInteractive = process.stdin.isTTY === true;
+
+  // When managed by hive-cli start, Escape exits back to dashboard
+  const isManaged = process.env.HIVE_MANAGED === '1';
+
+  useInput((_input, key) => {
+    if (isManaged && key.escape) {
+      void gracefulShutdown(0);
+    }
+  }, { isActive: isManaged });`;
+        content = content.slice(0, insertAfter) + hooks + content.slice(insertAfter);
+    }
+    // 4. Wrap TextInput in isInteractive guard
+    //    Replace the input bar section to conditionally render TextInput
+    if (!content.includes(INTERACTIVE_GUARD_MARKER) && content.includes('<TextInput')) {
+        // Find the Input Bar comment and replace the entire block
+        const inputBarStart = content.indexOf('{/* Input Bar */}');
+        if (inputBarStart === -1) {
+            // Fallback: just wrap the TextInput line
+            await fs.writeFile(filePath, content, 'utf-8');
+            return;
+        }
+        // Find the closing </Box> of the bottom border (3 Box elements after Input Bar comment)
+        // Pattern: <Box> separator </Box> <Box> TextInput </Box> <Box> bottom border </Box>
+        let pos = inputBarStart;
+        let boxCloseCount = 0;
+        const boxCloseTag = '</Box>';
+        while (boxCloseCount < 3 && pos < content.length) {
+            const nextClose = content.indexOf(boxCloseTag, pos);
+            if (nextClose === -1) {
+                break;
+            }
+            pos = nextClose + boxCloseTag.length;
+            boxCloseCount++;
+        }
+        if (boxCloseCount === 3) {
+            const inputBarEnd = pos;
+            const replacement = `{/* Input Bar — only when stdin is a real TTY */}
+      <Box>
+        <Text color="gray">
+          {isInteractive ? border.teeLeft : border.bottomLeft}
+          {border.horizontal.repeat(boxWidth - 2)}
+          {isInteractive ? border.teeRight : border.bottomRight}
+        </Text>
+      </Box>
+      {isInteractive && (
+        <>
+          <Box paddingLeft={1}>
+            <Text color={colors.honey}>{symbols.arrow} </Text>
+            <TextInput
+              value={input}
+              onChange={setInput}
+              onSubmit={(val) => {
+                setInput('');
+                void handleChatSubmit(val);
+              }}
+              placeholder={chatStreaming ? 'thinking...' : \`chat with \${agentName} agent...\`}
+            />
+          </Box>
+          <Box>
+            <Text color="gray">
+              {border.bottomLeft}
+              {border.horizontal.repeat(boxWidth - 2)}
+              {border.bottomRight}
+            </Text>
+          </Box>
+        </>
+      )}`;
+            content = content.slice(0, inputBarStart) + replacement + content.slice(inputBarEnd);
+        }
+    }
+    await fs.writeFile(filePath, content, 'utf-8');
+}

package/dist/start/start-command.js

@@ -0,0 +1,24 @@
+import React from 'react';
+import { render } from 'ink';
+import { showWelcome } from '../create/welcome.js';
+import { scanAgents, fetchBulkStats, sortAgentsByHoney } from '../agents.js';
+import { symbols, styled } from '../theme.js';
+import { AgentProcessManager } from './AgentProcessManager.js';
+import { Dashboard } from './Dashboard.js';
+export async function startCommand() {
+    // Run welcome animation and scan agents in parallel
+    const results = await Promise.all([showWelcome(), scanAgents()]);
+    const discovered = results[1];
+    if (discovered.length === 0) {
+        console.log(`\n  ${styled.honey(symbols.hive)} ${styled.red('No agents found in ~/.hive/agents/')}\n`);
+        console.log(`  ${styled.gray('Create agents with:')} ${styled.white('npx @hive-org/cli@latest create')}\n`);
+        return;
+    }
+    const names = discovered.map((a) => a.name);
+    const statsMap = await fetchBulkStats(names);
+    const sortedDiscovered = sortAgentsByHoney(discovered, statsMap);
+    const manager = new AgentProcessManager();
+    manager.spawnAll(sortedDiscovered);
+    const { waitUntilExit } = render(React.createElement(Dashboard, { manager, statsMap }));
+    await waitUntilExit();
+}

package/dist/theme.js

@@ -0,0 +1,54 @@
+import chalk from 'chalk';
+export const colors = {
+    honey: '#F5A623',
+    honeyDark: '#D4891A',
+    honeyBright: '#FFD700',
+    white: '#FFFFFF',
+    gray: '#A6A6A6',
+    grayDim: '#555555',
+    green: '#27C587',
+    red: '#E14B4B',
+    wax: '#C45C5C',
+    cyan: '#22D3EE',
+    hot: '#FB923C',
+    controversial: '#C084FC',
+};
+export const symbols = {
+    hive: '\u2B21', // ⬡
+    diamond: '\u25C6', // ◆
+    diamondOpen: '\u25C7', // ◇
+    dot: '\u25CF', // ●
+    spinner: ['\u25D0', '\u25D3', '\u25D1', '\u25D2'], // ◐ ◓ ◑ ◒
+    check: '\u2713', // ✓
+    cross: '\u2717', // ✗
+    arrow: '\u203A', // ›
+};
+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▪▫░▒',
+    HEX_CHARS: '⬡⬢',
+    TICK_MS: 120,
+};
+export const styled = {
+    honey: (text) => chalk.hex(colors.honey)(text),
+    honeyBold: (text) => chalk.hex(colors.honey).bold(text),
+    white: (text) => chalk.white(text),
+    whiteBold: (text) => chalk.bold.white(text),
+    gray: (text) => chalk.gray(text),
+    dim: (text) => chalk.hex(colors.grayDim)(text),
+    green: (text) => chalk.hex(colors.green)(text),
+    red: (text) => chalk.hex(colors.red)(text),
+    wax: (text) => chalk.hex(colors.wax)(text),
+    cyan: (text) => chalk.hex(colors.cyan)(text),
+    hot: (text) => chalk.hex(colors.hot)(text),
+    controversial: (text) => chalk.hex(colors.controversial)(text),
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhive/cli",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "CLI for bootstrapping zHive AI Agents",
   "type": "module",
   "main": "dist/index.js",
@@ -31,7 +31,7 @@
     "@ai-sdk/openai": "^3.0.25",
     "@ai-sdk/xai": "^3.0.0",
     "@openrouter/ai-sdk-provider": "^0.4.0",
-    "@zhive/sdk": "^0.5.2",
+    "@zhive/sdk": "^0.5.3",
     "ai": "^6.0.71",
     "axios": "^1.6.0",
     "chalk": "^5.3.0",

package/dist/CLAUDE.md

@@ -1,7 +0,0 @@
-<claude-mem-context>
-# Recent Activity
-
-<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
-
-*No recent activity*
-</claude-mem-context>

package/dist/backtest/CLAUDE.md

@@ -1,7 +0,0 @@
-<claude-mem-context>
-# Recent Activity
-
-<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
-
-*No recent activity*
-</claude-mem-context>

package/dist/cli.js

@@ -1,20 +0,0 @@
-#!/usr/bin/env node
-import { Command } from 'commander';
-import { createRequire } from 'module';
-import { createCreateCommand } from './commands/create/commands/index.js';
-import { createListCommand } from './commands/list/commands/index.js';
-import { createStartCommand } from './commands/start/commands/index.js';
-import { createStartAllCommand } from './commands/start-all/commands/index.js';
-import { createRunCommand } from './commands/run/commands/index.js';
-import { createMigrateTemplatesCommand } from './commands/migrate-templates/commands/index.js';
-const require = createRequire(import.meta.url);
-const packageJson = require('../package.json');
-const program = new Command();
-program.name('@zhive/cli').version(packageJson.version);
-program.addCommand(createCreateCommand());
-program.addCommand(createListCommand());
-program.addCommand(createStartCommand());
-program.addCommand(createStartAllCommand());
-program.addCommand(createRunCommand());
-program.addCommand(createMigrateTemplatesCommand());
-program.parse(process.argv);

package/dist/services/config/constant.js

@@ -1,8 +0,0 @@
-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/agent/config.js

@@ -1,75 +0,0 @@
-import * as fs from 'fs/promises';
-import * as path from 'path';
-async function loadMarkdownFile(filename) {
-    const filePath = path.join(process.cwd(), filename);
-    const content = await fs.readFile(filePath, 'utf-8');
-    return content;
-}
-function extractField(content, pattern) {
-    const match = content.match(pattern);
-    if (match === null) {
-        return null;
-    }
-    const value = match[1].trim();
-    return value;
-}
-const VALID_SENTIMENTS = [
-    'very-bullish',
-    'bullish',
-    'neutral',
-    'bearish',
-    'very-bearish',
-];
-const VALID_TIMEFRAMES = ['1h', '4h', '24h'];
-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;
-}
-export async function loadAgentConfig() {
-    const soulContent = await loadMarkdownFile('SOUL.md');
-    const strategyContent = await loadMarkdownFile('STRATEGY.md');
-    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 agentProfile = {
-        sentiment: parseSentiment(sentimentRaw),
-        sectors: parseSectors(sectorsRaw),
-        timeframes: parseTimeframes(timeframesRaw),
-    };
-    return { name, bio, avatarUrl, soulContent, strategyContent, agentProfile };
-}

package/dist/shared/agent/env.js

@@ -1,30 +0,0 @@
-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/agent/helpers/model.js

@@ -1,92 +0,0 @@
-import { AI_PROVIDERS } from '../../ai-providers.js';
-import { getAgentProviderKeys } from '../../config/env-loader.js';
-const PROVIDERS = [
-    {
-        label: 'Anthropic',
-        envVar: 'ANTHROPIC_API_KEY',
-        load: async (modelId) => {
-            const { anthropic } = await import('@ai-sdk/anthropic');
-            return anthropic(modelId);
-        },
-    },
-    {
-        label: 'OpenAI',
-        envVar: 'OPENAI_API_KEY',
-        load: async (modelId) => {
-            const { openai } = await import('@ai-sdk/openai');
-            return openai(modelId);
-        },
-    },
-    {
-        label: 'Google',
-        envVar: 'GOOGLE_GENERATIVE_AI_API_KEY',
-        load: async (modelId) => {
-            const { google } = await import('@ai-sdk/google');
-            return google(modelId);
-        },
-    },
-    {
-        label: 'xAI',
-        envVar: 'XAI_API_KEY',
-        load: async (modelId) => {
-            const { xai } = await import('@ai-sdk/xai');
-            return xai(modelId);
-        },
-    },
-    {
-        label: 'OpenRouter',
-        envVar: 'OPENROUTER_API_KEY',
-        load: async (modelId) => {
-            const { createOpenRouter } = await import('@openrouter/ai-sdk-provider');
-            const openrouter = createOpenRouter({ apiKey: process.env.OPENROUTER_API_KEY });
-            return openrouter.chat(modelId);
-        },
-    },
-];
-export function resolveModelInfo() {
-    const overrideModel = process.env.HIVE_MODEL;
-    const agentKeys = getAgentProviderKeys();
-    const sortedProviders = [
-        ...PROVIDERS.filter((p) => agentKeys.has(p.envVar)),
-        ...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' };
-}
-let _modelPromise = null;
-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 = [
-            ...PROVIDERS.filter((p) => agentKeys.has(p.envVar)),
-            ...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/ai-providers.js

@@ -1,66 +0,0 @@
-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' },
-    },
-    {
-        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',
-        },
-    },
-    {
-        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',
-        },
-    },
-    {
-        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',
-        },
-    },
-    {
-        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',
-        },
-    },
-];
-/**
- * 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 getProvider(id) {
-    const provider = AI_PROVIDERS.find((p) => p.id === id);
-    if (!provider) {
-        throw new Error(`Unknown AI provider: ${id}`);
-    }
-    return provider;
-}