@zhive/cli 0.6.3 → 0.6.4

package/dist/services/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/agent/config.js

@@ -0,0 +1,75 @@
+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

@@ -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/agent/helpers/model.js

@@ -0,0 +1,92 @@
+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

@@ -0,0 +1,66 @@
+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;
+}

package/dist/shared/config/agent.js

@@ -1,4 +1,3 @@
-import { loadCredentials, } from '@zhive/sdk';
 import axios from 'axios';
 import fsExtra from 'fs-extra';
 import * as fs from 'fs/promises';
@@ -183,13 +182,3 @@ export async function findAgentByName(name) {
     }
     return agent;
 }
-export function getCredentialsPath(agentDir, agentName) {
-    const sanitized = agentName.replace(/[^a-zA-Z0-9-_]/g, '-');
-    const credPath = path.join(agentDir, `hive-${sanitized}.json`);
-    return credPath;
-}
-export async function loadAgentCredentials(agentDir, agentName) {
-    const credPath = getCredentialsPath(agentDir, agentName);
-    const credentials = await loadCredentials(credPath);
-    return credentials;
-}

package/dist/shared/config/agent.test.js

@@ -14,42 +14,11 @@ vi.mock('./ai-providers.js', () => ({
     ],
 }));
 vi.mock('@zhive/sdk', () => ({
-    loadCredentials: vi.fn(),
+    loadConfig: vi.fn(),
 }));
-import { loadCredentials } from '@zhive/sdk';
-import { findAgentByName, getCredentialsPath, loadAgentCredentials, scanAgents, } from './agent.js';
-const mockLoadCredentials = loadCredentials;
-describe('getCredentialsPath', () => {
-    it('constructs correct path with simple agent name', () => {
-        const result = getCredentialsPath('/mock/.zhive/agents/my-agent', 'my-agent');
-        expect(result).toBe('/mock/.zhive/agents/my-agent/hive-my-agent.json');
-    });
-    it('sanitizes special characters in agent name', () => {
-        const result = getCredentialsPath('/mock/.zhive/agents/my-agent', 'my@agent!test');
-        expect(result).toBe('/mock/.zhive/agents/my-agent/hive-my-agent-test.json');
-    });
-    it('allows underscores and hyphens in agent name', () => {
-        const result = getCredentialsPath('/mock/.zhive/agents/test_agent', 'test_agent-v2');
-        expect(result).toBe('/mock/.zhive/agents/test_agent/hive-test_agent-v2.json');
-    });
-});
-describe('loadAgentCredentials', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('delegates to loadCredentials with correct path', async () => {
-        const mockCredentials = { apiKey: 'test-api-key' };
-        mockLoadCredentials.mockResolvedValue(mockCredentials);
-        const result = await loadAgentCredentials('/mock/.zhive/agents/test-agent', 'test-agent');
-        expect(mockLoadCredentials).toHaveBeenCalledWith('/mock/.zhive/agents/test-agent/hive-test-agent.json');
-        expect(result).toEqual(mockCredentials);
-    });
-    it('returns null when loadCredentials returns null', async () => {
-        mockLoadCredentials.mockResolvedValue(null);
-        const result = await loadAgentCredentials('/mock/.zhive/agents/test-agent', 'test-agent');
-        expect(result).toBeNull();
-    });
-});
+import { loadConfig } from '@zhive/sdk';
+import { findAgentByName, scanAgents } from './agent.js';
+const mockLoadConfig = loadConfig;
 describe('scanAgents', () => {
     beforeEach(() => {
         vi.clearAllMocks();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhive/cli",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "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.5",
+    "@zhive/sdk": "^0.5.6",
     "ai": "^6.0.71",
     "axios": "^1.6.0",
     "chalk": "^5.3.0",

package/dist/agent/app.js

@@ -1,122 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useEffect, useRef } from 'react';
-import { Box, Text, useStdout } from 'ink';
-import chalk from 'chalk';
-import { useAgent } from './hooks/useAgent.js';
-import { colors, symbols, border } from './theme.js';
-import { formatTime, convictionColor } from './helpers.js';
-import { Spinner, PollText } from './components/Spinner.js';
-import { AsciiTicker } from './components/AsciiTicker.js';
-import { CommandInput } from './components/CommandInput.js';
-// ─── Format a settled poll item as a chalk string for stdout ───
-function formatSettledItem(item) {
-    const time = chalk.gray.dim(`${formatTime(item.timestamp)} `);
-    const lines = [];
-    if (item.type === 'online') {
-        lines.push(` ${time}${chalk.hex(colors.honey)(symbols.hive)} ${chalk.white(item.text)}`);
-    }
-    if (item.type === 'signal' || item.type === 'megathread') {
-        const isMega = item.type === 'megathread';
-        const accent = isMega ? colors.controversial : colors.cyan;
-        const hiveColor = isMega ? colors.controversial : colors.honey;
-        let mainLine = ` ${time}${chalk.hex(hiveColor)(symbols.hive)} ${chalk.hex(accent)(item.text)}`;
-        if (item.status === 'skipped') {
-            mainLine += chalk.hex(colors.honey)(` ${symbols.diamondOpen} skipped`);
-            if (item.tokenUsage) {
-                let tokenInfo = ` ${symbols.circle} ${item.tokenUsage.inputTokens.toLocaleString()} in`;
-                if (item.tokenUsage.cacheReadTokens > 0) {
-                    tokenInfo += ` (${item.tokenUsage.cacheReadTokens.toLocaleString()} cached)`;
-                }
-                else if (item.tokenUsage.cacheWriteTokens > 0) {
-                    tokenInfo += ` (${item.tokenUsage.cacheWriteTokens.toLocaleString()} cache write)`;
-                }
-                tokenInfo += ` \u00b7 ${item.tokenUsage.outputTokens.toLocaleString()} out`;
-                if (item.tokenUsage.toolCalls > 0) {
-                    tokenInfo += ` \u00b7 tools: ${item.tokenUsage.toolNames.join(', ')}`;
-                }
-                mainLine += chalk.gray.dim(tokenInfo);
-            }
-        }
-        lines.push(mainLine);
-        if (item.status === 'posted' && item.result) {
-            const pad = ' '.repeat(13);
-            const cColor = isMega ? colors.controversial : convictionColor(item.conviction ?? 0);
-            lines.push(`${pad}${chalk.hex(cColor)(symbols.diamond)} ${chalk.white(item.result)}`);
-            if (item.url) {
-                lines.push(`${' '.repeat(15)}${chalk.gray.dim(`url: ${item.url}`)}`);
-            }
-            if (item.tokenUsage) {
-                let tokenInfo = `tokens: ${item.tokenUsage.inputTokens.toLocaleString()} in`;
-                if (item.tokenUsage.cacheReadTokens > 0) {
-                    tokenInfo += ` (${item.tokenUsage.cacheReadTokens.toLocaleString()} cached)`;
-                }
-                else if (item.tokenUsage.cacheWriteTokens > 0) {
-                    tokenInfo += ` (${item.tokenUsage.cacheWriteTokens.toLocaleString()} cache write)`;
-                }
-                tokenInfo += ` \u00b7 ${item.tokenUsage.outputTokens.toLocaleString()} out`;
-                lines.push(`${' '.repeat(15)}${chalk.gray.dim(tokenInfo)}`);
-                if (item.tokenUsage.toolCalls > 0) {
-                    const toolInfo = `tools: ${item.tokenUsage.toolCalls} tools (${item.tokenUsage.toolNames.join(', ')})`;
-                    lines.push(`${' '.repeat(15)}${chalk.gray.dim(toolInfo)}`);
-                }
-            }
-        }
-        if (item.status === 'error' && item.result) {
-            const pad = ' '.repeat(13);
-            lines.push(`${pad}${chalk.hex(colors.red)(`${symbols.cross} ${item.result}`)}`);
-        }
-    }
-    if (item.type === 'idle') {
-        lines.push(` ${time}${chalk.gray(`${symbols.circle} ${item.text}`)}`);
-    }
-    if (item.type === 'error') {
-        lines.push(` ${time}${chalk.hex(colors.red)(`${symbols.cross} ${item.text}`)}`);
-    }
-    return lines.join('\n');
-}
-// ─── Main TUI App ────────────────────────────────────
-export function App() {
-    const { connected, agentName, modelInfo, pollActivity, chatActivity, input, chatStreaming, chatBuffer, predictionCount, termWidth, setInput, handleChatSubmit, } = useAgent();
-    const { write } = useStdout();
-    // When stdin is not a TTY (piped by hive-cli start), skip interactive input
-    const isInteractive = process.stdin.isTTY === true;
-    const boxWidth = termWidth;
-    // Split poll items: settled items are written to stdout via useStdout (scrollback),
-    // active items render in the dynamic Ink section (need spinner animation).
-    const settledStatuses = new Set(['posted', 'skipped', 'error', undefined]);
-    const settledTypes = new Set(['idle', 'online', 'error']);
-    const isSettled = (item) => {
-        if (settledTypes.has(item.type))
-            return true;
-        return settledStatuses.has(item.status) && item.status !== undefined;
-    };
-    const settledPollItems = pollActivity.filter(isSettled);
-    const activePollItems = pollActivity.filter((item) => !isSettled(item));
-    const visibleChatActivity = chatActivity.slice(-5);
-    // Write settled items to stdout permanently (scrollback history).
-    // Track how many we've already written so each item is written once.
-    const writtenCountRef = useRef(0);
-    useEffect(() => {
-        const newCount = settledPollItems.length;
-        if (newCount > writtenCountRef.current) {
-            const newItems = settledPollItems.slice(writtenCountRef.current);
-            for (const item of newItems) {
-                const formatted = formatSettledItem(item);
-                write(formatted + '\n');
-            }
-            writtenCountRef.current = newCount;
-        }
-    }, [settledPollItems.length, write]);
-    const statsText = predictionCount > 0 ? ` ${border.horizontal.repeat(3)} ${predictionCount} predicted` : '';
-    const connectedDisplay = connected ? 'Connected to the Hive' : 'connecting...';
-    const nameDisplay = `${agentName} agent`;
-    const headerFill = Math.max(0, boxWidth - nameDisplay.length - connectedDisplay.length - 12 - statsText.length);
-    return (_jsxs(Box, { flexDirection: "column", width: boxWidth, children: [_jsx(AsciiTicker, { rows: 2, step: predictionCount }), _jsxs(Box, { children: [_jsx(Text, { color: colors.honey, children: `${border.topLeft}${border.horizontal} ${symbols.hive} ` }), _jsxs(Text, { color: colors.white, bold: true, children: [agentName, " agent"] }), _jsxs(Text, { color: colors.gray, children: [" ", `${border.horizontal.repeat(3)} `] }), _jsx(Text, { color: connected ? colors.green : colors.honey, children: connected ? 'Connected to the Hive' : 'connecting...' }), statsText && _jsxs(Text, { color: colors.gray, children: [" ", `${border.horizontal.repeat(3)} `] }), statsText && _jsxs(Text, { color: colors.honey, children: [predictionCount, " predicted"] }), _jsxs(Text, { color: colors.gray, children: [' ', border.horizontal.repeat(Math.max(0, headerFill)), border.topRight] })] }), modelInfo && (_jsxs(Box, { paddingLeft: 1, children: [_jsxs(Text, { color: colors.gray, children: [symbols.hive, " "] }), _jsx(Text, { color: colors.cyan, children: modelInfo.modelId }), _jsxs(Text, { color: colors.gray, children: [" ", '\u00d7', " "] }), _jsx(Text, { color: colors.white, children: "zData" })] })), _jsxs(Box, { flexDirection: "column", paddingLeft: 1, paddingRight: 1, minHeight: 2, children: [!connected && _jsx(Spinner, { label: "Initiating neural link..." }), activePollItems.map((item, i) => {
-                        const isMega = item.type === 'megathread';
-                        const accentColor = isMega ? colors.controversial : colors.cyan;
-                        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { color: colors.gray, dimColor: true, children: [formatTime(item.timestamp), ' '] }), _jsxs(Text, { color: isMega ? colors.controversial : colors.honey, children: [symbols.hive, " "] }), _jsx(PollText, { color: accentColor, text: item.text, animate: false }), _jsx(Text, { children: " " }), _jsx(Spinner, { label: "analyzing..." })] }), item.detail && (_jsx(Box, { marginLeft: 13, children: _jsx(PollText, { color: colors.gray, text: `"${item.detail}"`, animate: false }) }))] }, `active-${item.id ?? i}`));
-                    })] }), (chatActivity.length > 0 || chatStreaming) && (_jsxs(_Fragment, { children: [_jsx(Box, { children: _jsxs(Text, { color: colors.gray, children: [border.teeLeft, `${border.horizontal.repeat(2)} chat with ${agentName} agent `, border.horizontal.repeat(Math.max(0, boxWidth - agentName.length - 22)), border.teeRight] }) }), _jsxs(Box, { flexDirection: "column", paddingLeft: 1, paddingRight: 1, minHeight: 2, maxHeight: 8, children: [visibleChatActivity.map((item, i) => (_jsxs(Box, { children: [item.type === 'chat-user' && (_jsxs(Box, { children: [_jsxs(Text, { color: colors.white, bold: true, children: ["you:", ' '] }), _jsx(Text, { color: colors.white, children: item.text })] })), item.type === 'chat-agent' && (_jsxs(Box, { children: [_jsxs(Text, { color: colors.honey, bold: true, children: [agentName, " agent:", ' '] }), _jsx(Text, { color: colors.white, wrap: "wrap", children: item.text })] })), item.type === 'chat-error' && (_jsx(Box, { children: _jsxs(Text, { color: colors.red, children: [symbols.cross, " ", item.text] }) }))] }, i))), chatStreaming && chatBuffer && (_jsxs(Box, { children: [_jsxs(Text, { color: colors.honey, bold: true, children: [agentName, " agent:", ' '] }), _jsx(Text, { color: colors.white, wrap: "wrap", children: chatBuffer })] }))] })] })), _jsx(Box, { children: _jsxs(Text, { color: colors.gray, children: [isInteractive ? border.teeLeft : border.bottomLeft, border.horizontal.repeat(boxWidth - 2), isInteractive ? border.teeRight : border.bottomRight] }) }), isInteractive && (_jsxs(_Fragment, { children: [_jsx(Box, { paddingLeft: 1, children: _jsx(CommandInput, { value: input, onChange: setInput, onSubmit: (val) => {
-                                setInput('');
-                                void handleChatSubmit(val);
-                            }, placeholder: chatStreaming ? 'thinking...' : `chat with ${agentName} agent...` }) }), _jsx(Box, { children: _jsxs(Text, { color: colors.gray, children: [border.bottomLeft, border.horizontal.repeat(boxWidth - 2), border.bottomRight] }) })] }))] }));
-}

package/dist/agent/commands/registry.js

@@ -1,12 +0,0 @@
-export const SLASH_COMMANDS = [
-    { name: '/skills', description: 'List available skills' },
-    { name: '/help', description: 'Show available commands' },
-    { name: '/clear', description: 'Clear chat history' },
-    { name: '/memory', description: 'Show current memory state' },
-    { name: '/backtest', description: 'Run agent against test set (/backtest <num> fetches from API)' },
-];
-export function filterCommands(prefix) {
-    const lowerPrefix = prefix.toLowerCase();
-    const filtered = SLASH_COMMANDS.filter((cmd) => cmd.name.toLowerCase().startsWith(lowerPrefix));
-    return filtered;
-}

package/dist/agent/components/AsciiTicker.js

@@ -1,81 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState, useEffect } from 'react';
-import { Box, Text } from 'ink';
-import { colors, animation } from '../theme.js';
-function buildTickerChars(step) {
-    const stepStr = String(step).padStart(2, '0');
-    const digits = stepStr.split('');
-    return animation.HEX_CHARS + digits.join('') + '\u25AA\u25AB\u2591\u2592';
-}
-function buildRow(cols, frame, rowIndex, tickerChars) {
-    const segments = [];
-    const isSecondRow = rowIndex === 1;
-    const scrollSpeed = isSecondRow ? 3 : 2;
-    const direction = isSecondRow ? -1 : 1;
-    const sinFreq = isSecondRow ? 0.4 : 0.3;
-    const sinPhase = isSecondRow ? -0.4 : 0.6;
-    const wrapLen = cols * 2;
-    for (let c = 0; c < cols; c++) {
-        const scrolledC = ((direction === 1)
-            ? (c + frame * scrollSpeed) % wrapLen
-            : (cols - c + frame * scrollSpeed) % wrapLen);
-        const charIdx = scrolledC % tickerChars.length;
-        const char = tickerChars[charIdx];
-        const isHex = char === '\u2B21' || char === '\u2B22';
-        const pulseHit = Math.sin((c + frame * sinPhase) * sinFreq) > 0.5;
-        // Edge fade: dim the outermost 4 columns
-        const edgeDist = Math.min(c, cols - 1 - c);
-        if (edgeDist < 2) {
-            segments.push({ char: '\u00B7', color: colors.grayDim });
-            continue;
-        }
-        if (edgeDist < 4) {
-            segments.push({ char, color: colors.grayDim });
-            continue;
-        }
-        if (pulseHit && isHex) {
-            segments.push({ char, color: colors.honey });
-        }
-        else if (pulseHit) {
-            segments.push({ char, color: colors.green });
-        }
-        else {
-            segments.push({ char, color: colors.grayDim });
-        }
-    }
-    return segments;
-}
-function renderSegments(segments) {
-    const elements = [];
-    let runColor = segments[0]?.color ?? colors.grayDim;
-    let runChars = '';
-    for (let i = 0; i < segments.length; i++) {
-        const seg = segments[i];
-        if (seg.color === runColor) {
-            runChars += seg.char;
-        }
-        else {
-            elements.push(_jsx(Text, { color: runColor, children: runChars }, `${elements.length}`));
-            runColor = seg.color;
-            runChars = seg.char;
-        }
-    }
-    if (runChars.length > 0) {
-        elements.push(_jsx(Text, { color: runColor, children: runChars }, `${elements.length}`));
-    }
-    return elements;
-}
-export function AsciiTicker({ rows = 1, step = 1 }) {
-    const [frame, setFrame] = useState(0);
-    const cols = process.stdout.columns || 60;
-    const tickerChars = buildTickerChars(step);
-    useEffect(() => {
-        const timer = setInterval(() => {
-            setFrame((prev) => prev + 1);
-        }, animation.TICK_MS);
-        return () => {
-            clearInterval(timer);
-        };
-    }, []);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: renderSegments(buildRow(cols, frame, 0, tickerChars)) }), rows === 2 && (_jsx(Text, { children: renderSegments(buildRow(cols, frame, 1, tickerChars)) }))] }));
-}

package/dist/agent/components/CommandInput.js

@@ -1,65 +0,0 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { useState, useCallback, useMemo } from 'react';
-import { Box, Text, useInput } from 'ink';
-import TextInput from 'ink-text-input';
-import { colors, symbols } from '../theme.js';
-import { filterCommands } from '../commands/registry.js';
-export function CommandInput({ value, onChange, onSubmit, placeholder, }) {
-    const [selectedIndex, setSelectedIndex] = useState(0);
-    // Determine if autocomplete should be active
-    const isAutocompleteActive = value.startsWith('/') && !value.includes(' ');
-    // Get filtered commands
-    const filteredCommands = useMemo(() => {
-        if (!isAutocompleteActive) {
-            return [];
-        }
-        const commands = filterCommands(value);
-        return commands;
-    }, [value, isAutocompleteActive]);
-    // Reset selection when filtered commands change
-    const commandCount = filteredCommands.length;
-    const safeSelectedIndex = commandCount > 0 ? Math.min(selectedIndex, commandCount - 1) : 0;
-    const handleChange = useCallback((newValue) => {
-        onChange(newValue);
-        setSelectedIndex(0);
-    }, [onChange]);
-    const handleSubmit = useCallback((submittedValue) => {
-        // If autocomplete is active and there are matches, complete first
-        if (isAutocompleteActive && filteredCommands.length > 0) {
-            const selected = filteredCommands[safeSelectedIndex];
-            if (selected && submittedValue !== selected.name) {
-                onChange(selected.name);
-                onSubmit(selected.name);
-                return;
-            }
-        }
-        onSubmit(submittedValue);
-    }, [isAutocompleteActive, filteredCommands, safeSelectedIndex, onChange, onSubmit]);
-    useInput((input, key) => {
-        if (!isAutocompleteActive || filteredCommands.length === 0) {
-            return;
-        }
-        if (key.upArrow) {
-            setSelectedIndex((prev) => (prev > 0 ? prev - 1 : commandCount - 1));
-        }
-        else if (key.downArrow) {
-            setSelectedIndex((prev) => (prev < commandCount - 1 ? prev + 1 : 0));
-        }
-        else if (key.tab) {
-            // Tab to complete without submitting
-            const selected = filteredCommands[safeSelectedIndex];
-            if (selected) {
-                onChange(selected.name);
-            }
-        }
-        else if (key.escape) {
-            // Escape to clear input
-            onChange('');
-            setSelectedIndex(0);
-        }
-    }, { isActive: isAutocompleteActive && filteredCommands.length > 0 });
-    return (_jsxs(Box, { flexDirection: "column", children: [isAutocompleteActive && filteredCommands.length > 0 && (_jsx(Box, { flexDirection: "column", marginBottom: 0, marginLeft: 2, children: filteredCommands.map((cmd, index) => {
-                    const isSelected = index === safeSelectedIndex;
-                    return (_jsxs(Box, { children: [_jsxs(Text, { color: isSelected ? colors.honey : colors.gray, children: [isSelected ? symbols.diamond : ' ', ' '] }), _jsx(Text, { color: isSelected ? colors.honey : colors.white, children: cmd.name }), _jsxs(Text, { color: colors.gray, children: [" - ", cmd.description] })] }, cmd.name));
-                }) })), _jsxs(Box, { children: [_jsxs(Text, { color: colors.honey, children: [symbols.arrow, " "] }), _jsx(TextInput, { value: value, onChange: handleChange, onSubmit: handleSubmit, placeholder: placeholder })] })] }));
-}