@zhive/cli 0.5.0

package/dist/commands/start/commands/skills.test.js

@@ -0,0 +1,140 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { fileURLToPath } from 'node:url';
+import * as path from 'node:path';
+import { fetchSkills, formatSkills, skillsSlashCommand } from './skills.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const FIXTURES_DIR = path.join(__dirname, '../../../tests/__fixtures__/mock-hive');
+vi.mock('../../../shared/config/constant.js', () => ({
+    getHiveDir: vi.fn(() => path.join(__dirname, '../../../tests/__fixtures__/mock-hive')),
+}));
+function createMockSkill(overrides = {}) {
+    const skill = {
+        id: 'test-skill',
+        path: '/mock/.hive/agents/test-agent/skills/test-skill',
+        metadata: {
+            name: 'Test Skill',
+            description: 'A test skill description',
+        },
+        body: 'Skill body content',
+        ...overrides,
+    };
+    return skill;
+}
+describe('formatSkills', () => {
+    it('returns no skills message for empty array', () => {
+        const result = formatSkills([]);
+        expect(result).toContain('No skills loaded');
+        expect(result).toContain('skills/ directory');
+    });
+    it('formats a single skill correctly', () => {
+        const skills = [createMockSkill()];
+        const result = formatSkills(skills);
+        expect(result).toContain('Available Skills');
+        expect(result).toContain('Test Skill');
+        expect(result).toContain('A test skill description');
+    });
+    it('includes compatibility information when present', () => {
+        const skillWithCompat = createMockSkill({
+            metadata: {
+                name: 'Compat Skill',
+                description: 'Skill with compatibility',
+                compatibility: 'Requires Node 18+',
+            },
+        });
+        const skills = [skillWithCompat];
+        const result = formatSkills(skills);
+        expect(result).toContain('Compat Skill');
+        expect(result).toContain('Skill with compatibility');
+        expect(result).toContain('Requires Node 18+');
+    });
+    it('formats multiple skills correctly', () => {
+        const skills = [
+            createMockSkill({
+                id: 'skill-1',
+                metadata: { name: 'First Skill', description: 'First description' },
+            }),
+            createMockSkill({
+                id: 'skill-2',
+                metadata: { name: 'Second Skill', description: 'Second description' },
+            }),
+        ];
+        const result = formatSkills(skills);
+        expect(result).toContain('First Skill');
+        expect(result).toContain('First description');
+        expect(result).toContain('Second Skill');
+        expect(result).toContain('Second description');
+    });
+});
+describe('fetchSkills', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('returns empty array for non-existent agent', async () => {
+        const result = await fetchSkills('non-existent-agent');
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data).toEqual([]);
+        }
+    });
+    it('returns empty array for agent with empty skills directory', async () => {
+        const result = await fetchSkills('empty-agent');
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data).toEqual([]);
+        }
+    });
+    it('returns discovered skills successfully', async () => {
+        const result = await fetchSkills('test-agent');
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data).toHaveLength(2);
+            const skillIds = result.data.map((s) => s.id).sort();
+            expect(skillIds).toEqual(['skill-with-compat', 'valid-skill']);
+        }
+    });
+    it('loads skill metadata correctly', async () => {
+        const result = await fetchSkills('test-agent');
+        expect(result.success).toBe(true);
+        if (result.success) {
+            const validSkill = result.data.find((s) => s.id === 'valid-skill');
+            expect(validSkill).toBeDefined();
+            expect(validSkill?.metadata.name).toBe('Valid Skill');
+            expect(validSkill?.metadata.description).toBe('A valid test skill for testing');
+        }
+    });
+});
+describe('skillsSlashCommand', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('calls onSuccess with formatted output on success', async () => {
+        const onSuccess = vi.fn();
+        const onError = vi.fn();
+        await skillsSlashCommand('test-agent', { onSuccess, onError });
+        expect(onSuccess).toHaveBeenCalledTimes(1);
+        expect(onSuccess.mock.calls[0][0]).toContain('Available Skills');
+        expect(onSuccess.mock.calls[0][0]).toContain('Valid Skill');
+        expect(onSuccess.mock.calls[0][0]).toContain('Skill With Compatibility');
+        expect(onError).not.toHaveBeenCalled();
+    });
+    it('handles empty skills list', async () => {
+        const onSuccess = vi.fn();
+        const onError = vi.fn();
+        await skillsSlashCommand('empty-agent', { onSuccess, onError });
+        expect(onSuccess).toHaveBeenCalledTimes(1);
+        expect(onSuccess.mock.calls[0][0]).toContain('No skills loaded');
+        expect(onError).not.toHaveBeenCalled();
+    });
+    it('works without callbacks', async () => {
+        // Should not throw
+        await skillsSlashCommand('test-agent', {});
+    });
+    it('works with agent that has no skills directory', async () => {
+        const onSuccess = vi.fn();
+        const onError = vi.fn();
+        await skillsSlashCommand('agent-no-skills', { onSuccess, onError });
+        expect(onSuccess).toHaveBeenCalledTimes(1);
+        expect(onSuccess.mock.calls[0][0]).toContain('No skills loaded');
+        expect(onError).not.toHaveBeenCalled();
+    });
+});

package/dist/commands/start/hooks/types.js

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

package/dist/commands/start/hooks/useAgent.js

@@ -0,0 +1,177 @@
+import { HiveAgent } from '@zhive/sdk';
+import { useEffect, useRef, useState } from 'react';
+import { createMegathreadRoundBatchHandler, createMegathreadRoundHandler, initializeAgentRuntime, } from '../../../shared/agent/agent-runtime.js';
+import { extractErrorMessage } from '../../../shared/agent/utils.js';
+import { resolveModelInfo } from '../../../shared/config/ai-providers.js';
+import { fetchBulkStats } from '../../../shared/config/agent.js';
+import { HIVE_API_URL } from '../../../shared/config/constant.js';
+import { usePollActivity } from './usePollActivity.js';
+const STATS_POLL_INTERVAL_MS = 5 * 60 * 1_000;
+export function useAgent() {
+    const [connected, setConnected] = useState(false);
+    const [agentName, setAgentName] = useState('agent');
+    const [agentBio, setAgentBio] = useState('');
+    const [modelInfo, setModelInfo] = useState(null);
+    const [sectorsDisplay, setSectorsDisplay] = useState(null);
+    const [timeframesDisplay, setTimeframesDisplay] = useState(null);
+    const [predictionCount, setPredictionCount] = useState(0);
+    const [termWidth, setTermWidth] = useState(process.stdout.columns || 60);
+    const [stats, setStats] = useState(null);
+    const [statsUpdatedAt, setStatsUpdatedAt] = useState(null);
+    const agentRef = useRef(null);
+    const recentPredictionsRef = useRef([]);
+    const predictionCountRef = useRef(0);
+    const { activePollActivities, settledPollActivities, addLog, addMegathreadActivity, finalizeMegathreadActivity, } = usePollActivity();
+    // ─── Terminal resize tracking ───────────────────────
+    useEffect(() => {
+        const onResize = () => {
+            setTermWidth(process.stdout.columns || 60);
+        };
+        process.stdout.on('resize', onResize);
+        return () => {
+            process.stdout.off('resize', onResize);
+        };
+    }, []);
+    // ─── Stats polling (every 5 min) ───────────────────
+    useEffect(() => {
+        if (!connected)
+            return;
+        const fetchStats = async () => {
+            const statsMap = await fetchBulkStats([agentName]);
+            const agentStats = statsMap.get(agentName) ?? null;
+            setStats(agentStats);
+            if (agentStats) {
+                setStatsUpdatedAt(new Date());
+            }
+        };
+        void fetchStats();
+        const timer = setInterval(() => void fetchStats(), STATS_POLL_INTERVAL_MS);
+        return () => clearInterval(timer);
+    }, [connected, agentName]);
+    // ─── Agent lifecycle ────────────────────────────────
+    useEffect(() => {
+        const start = async () => {
+            const runtime = await initializeAgentRuntime();
+            const { config, memory, tools, skills } = runtime;
+            setAgentName(config.name);
+            setAgentBio(config.bio ?? '');
+            const resolvedModelInfo = resolveModelInfo();
+            setModelInfo(resolvedModelInfo);
+            const tuiReporter = {
+                onRoundStart(round, timeframe) {
+                    addMegathreadActivity({
+                        id: round.roundId,
+                        type: 'megathread',
+                        projectId: round.projectId,
+                        timeframe,
+                        timestamp: new Date(),
+                        status: 'analyzing',
+                    });
+                },
+                onPriceInfo() {
+                    // TUI does not display price info inline
+                },
+                onResearching() {
+                    // TUI status is already 'analyzing' from onRoundStart
+                },
+                onScreenResult(round, result) {
+                    if (!result.engage) {
+                        finalizeMegathreadActivity(round.roundId, {
+                            status: 'skipped',
+                            skipReason: `screened: ${result.reason}`,
+                            tokenUsage: result.usage,
+                        });
+                    }
+                },
+                onToolsUsed() {
+                    // TUI does not display tool usage inline
+                },
+                onSkipped(round, usage) {
+                    finalizeMegathreadActivity(round.roundId, {
+                        status: 'skipped',
+                        tokenUsage: usage,
+                    });
+                },
+                onPosted(round, conviction, summary, _timeframe, usage) {
+                    const sign = conviction >= 0 ? '+' : '';
+                    finalizeMegathreadActivity(round.roundId, {
+                        status: 'posted',
+                        conviction,
+                        summary,
+                        tokenUsage: usage,
+                    });
+                    predictionCountRef.current += 1;
+                    setPredictionCount(predictionCountRef.current);
+                    const predSummary = `[${sign}${conviction.toFixed(2)}%] ${summary}`;
+                    recentPredictionsRef.current = [predSummary, ...recentPredictionsRef.current].slice(0, 5);
+                },
+                onError(round, message) {
+                    finalizeMegathreadActivity(round.roundId, { status: 'error', errorMessage: message });
+                },
+            };
+            // eslint-disable-next-line prefer-const
+            let agent;
+            const roundHandler = createMegathreadRoundHandler(() => agent, runtime, tuiReporter);
+            const batchHandler = createMegathreadRoundBatchHandler(() => agent, runtime, tuiReporter);
+            agent = new HiveAgent(HIVE_API_URL, {
+                name: config.name,
+                avatarUrl: config.avatarUrl,
+                bio: config.bio ?? undefined,
+                agentProfile: config.agentProfile,
+                onPollEmpty: () => {
+                    addLog({
+                        type: 'idle',
+                        text: 'Polled but no new rounds',
+                        timestamp: new Date(),
+                    });
+                },
+                onNewMegathreadRound: roundHandler,
+                onNewMegathreadRounds: batchHandler,
+            });
+            agentRef.current = agent;
+            await agent.start();
+            setConnected(true);
+            const { agentProfile } = config;
+            const resolvedSectors = agentProfile.sectors.length > 0 ? agentProfile.sectors.join(', ') : 'all';
+            const resolvedTimeframes = agentProfile.timeframes.join(', ');
+            setSectorsDisplay(resolvedSectors);
+            setTimeframesDisplay(resolvedTimeframes);
+            const bio = config.bio ?? '';
+            if (bio) {
+                addLog({
+                    type: 'online',
+                    name: config.name,
+                    bio,
+                    timestamp: new Date(),
+                });
+            }
+        };
+        start().catch((err) => {
+            const raw = extractErrorMessage(err);
+            const isNameTaken = raw.includes('409');
+            const hint = isNameTaken ? ' Change the name in SOUL.md under "# Agent: <name>".' : '';
+            addLog({
+                type: 'error',
+                errorMessage: `Fatal: ${raw.slice(0, 120)}${hint}`,
+                timestamp: new Date(),
+            });
+        });
+        return () => {
+            agentRef.current?.stop().catch(() => { });
+        };
+    }, []);
+    return {
+        connected,
+        agentName,
+        agentBio,
+        modelInfo,
+        sectorsDisplay,
+        timeframesDisplay,
+        activePollActivities,
+        settledPollActivities,
+        predictionCount,
+        termWidth,
+        stats,
+        statsUpdatedAt,
+    };
+}

package/dist/commands/start/hooks/useChat.js

@@ -0,0 +1,266 @@
+import { ToolLoopAgent } from 'ai';
+import { useCallback, useRef, useState } from 'react';
+import { extractAndSaveMemory } from '../../../shared/agent/analysis.js';
+import { buildChatPrompt } from '../../../shared/agent/prompts/chat-prompt.js';
+import { editSectionTool } from '../../../shared/agent/tools/edit-section.js';
+import { fetchRulesTool } from '../../../shared/agent/tools/fetch-rules.js';
+import { extractErrorMessage } from '../../../shared/agent/utils.js';
+import { loadAgentConfig } from '../../../shared/config/agent.js';
+import { getModel } from '../../../shared/config/ai-providers.js';
+import { backtestSlashCommand } from '../commands/backtest.js';
+import { predictionSlashCommand } from '../commands/prediction.js';
+import { skillsSlashCommand } from '../commands/skills.js';
+import { SLASH_COMMANDS } from '../services/command-registry.js';
+export function useChat(agentName) {
+    const [chatActivity, setChatActivity] = useState([]);
+    const [input, setInput] = useState('');
+    const [chatStreaming, setChatStreaming] = useState(false);
+    const [chatBuffer, setChatBuffer] = useState('');
+    const sessionMessagesRef = useRef([]);
+    const memoryRef = useRef('');
+    const chatCountSinceExtractRef = useRef(0);
+    const extractingRef = useRef(false);
+    const recentPredictionsRef = useRef([]);
+    const soulContentRef = useRef('');
+    const strategyContentRef = useRef('');
+    const skillToolsRef = useRef({});
+    const skillMetadataRef = useRef('');
+    // ─── Activity helpers ───────────────────────────────
+    const addChatActivity = useCallback((item) => {
+        setChatActivity((prev) => {
+            const updated = [...prev, { ...item, timestamp: new Date() }];
+            const maxItems = 50;
+            if (updated.length > maxItems) {
+                return updated.slice(updated.length - maxItems);
+            }
+            return updated;
+        });
+    }, []);
+    // ─── Chat submission ────────────────────────────────
+    const handleChatSubmit = useCallback(async (message) => {
+        if (!message.trim() || chatStreaming) {
+            return;
+        }
+        // Handle slash commands
+        if (message.startsWith('/')) {
+            const trimmedMessage = message.trim().toLowerCase();
+            const parts = trimmedMessage.split(/\s+/);
+            const baseCommand = parts[0];
+            const commandArg = parts[1];
+            const commandHandlers = {
+                '/skills': async () => {
+                    await skillsSlashCommand(agentName, {
+                        onSuccess: (output) => {
+                            addChatActivity({ type: 'chat-agent', text: output });
+                        },
+                        onError: (error) => {
+                            addChatActivity({
+                                type: 'chat-error',
+                                text: `Failed to load skills: ${error}`,
+                            });
+                        },
+                    });
+                },
+                '/help': () => {
+                    const helpText = SLASH_COMMANDS.map((cmd) => `${cmd.name} - ${cmd.description}`).join('\n');
+                    addChatActivity({ type: 'chat-agent', text: helpText });
+                },
+                '/clear': () => {
+                    setChatActivity([]);
+                    sessionMessagesRef.current = [];
+                },
+                '/memory': () => {
+                    const memoryOutput = memoryRef.current || 'No memory stored yet.';
+                    addChatActivity({ type: 'chat-agent', text: memoryOutput });
+                },
+                '/backtest': async () => {
+                    const config = {
+                        agentPath: process.cwd(),
+                        soulContent: soulContentRef.current,
+                        strategyContent: strategyContentRef.current,
+                        agentName: agentName,
+                    };
+                    await backtestSlashCommand(parts.slice(1), config, {
+                        onFetchStart: (numThreads) => {
+                            addChatActivity({
+                                type: 'chat-agent',
+                                text: `Fetching ${numThreads} resolved threads...`,
+                            });
+                        },
+                        onFetchError: (error) => {
+                            addChatActivity({
+                                type: 'chat-agent',
+                                text: `API fetch failed (${error}), falling back to default dataset...`,
+                            });
+                            addChatActivity({
+                                type: 'chat-agent',
+                                text: 'Starting backtest against default dataset...',
+                            });
+                        },
+                        onThreadStart: (index, total, thread) => {
+                            addChatActivity({
+                                type: 'chat-agent',
+                                text: `Processing ${index + 1}/${total}: ${thread.project_name}...`,
+                            });
+                        },
+                        onBacktestSuccess: (report) => {
+                            addChatActivity({ type: 'chat-agent', text: report });
+                            sessionMessagesRef.current.push({ role: 'assistant', content: report });
+                        },
+                        onBacktestError: (err) => {
+                            const errMessage = extractErrorMessage(err);
+                            addChatActivity({ type: 'chat-error', text: `Backtest failed: ${errMessage}` });
+                        },
+                    });
+                },
+                '/prediction': async () => {
+                    await predictionSlashCommand(agentName, {
+                        onFetchStart: () => {
+                            addChatActivity({
+                                type: 'chat-agent',
+                                text: 'Fetching your predictions...',
+                            });
+                        },
+                        onSuccess: (output) => {
+                            addChatActivity({ type: 'chat-agent', text: output });
+                        },
+                        onError: (error) => {
+                            addChatActivity({
+                                type: 'chat-error',
+                                text: `Failed to fetch predictions: ${error}`,
+                            });
+                        },
+                    });
+                },
+            };
+            const handler = commandHandlers[baseCommand];
+            if (handler) {
+                await handler();
+                return;
+            }
+            // Unknown command
+            addChatActivity({ type: 'chat-error', text: `Unknown command: ${message}` });
+            return;
+        }
+        addChatActivity({ type: 'chat-user', text: message });
+        sessionMessagesRef.current.push({ role: 'user', content: message });
+        chatCountSinceExtractRef.current += 1;
+        if (chatCountSinceExtractRef.current >= 3 && !extractingRef.current) {
+            extractingRef.current = true;
+            const messagesSnapshot = [...sessionMessagesRef.current];
+            extractAndSaveMemory(messagesSnapshot)
+                .then((newMemory) => {
+                if (newMemory !== null) {
+                    memoryRef.current = newMemory;
+                }
+                chatCountSinceExtractRef.current = 0;
+            })
+                .catch(() => { })
+                .finally(() => {
+                extractingRef.current = false;
+            });
+        }
+        setChatStreaming(true);
+        setChatBuffer('');
+        try {
+            const { system, prompt } = buildChatPrompt(soulContentRef.current, strategyContentRef.current, {
+                recentPredictions: recentPredictionsRef.current,
+                sessionMessages: sessionMessagesRef.current.slice(-20),
+                memory: memoryRef.current,
+                userMessage: message,
+            });
+            const model = await getModel();
+            const cacheableSystem = {
+                role: 'system',
+                content: system,
+                providerOptions: {
+                    anthropic: { cacheControl: { type: 'ephemeral' } },
+                },
+            };
+            const agent = new ToolLoopAgent({
+                model,
+                instructions: cacheableSystem,
+                tools: {
+                    editSection: editSectionTool,
+                    fetchRules: fetchRulesTool,
+                    ...skillToolsRef.current,
+                },
+                maxOutputTokens: 4096,
+            });
+            const result = await agent.stream({
+                prompt,
+                onStepFinish: async ({ toolResults }) => {
+                    for (const toolResult of toolResults) {
+                        if (toolResult.toolName === 'editSection') {
+                            const output = String(toolResult.output);
+                            // Only reload if update was successful
+                            if (output.startsWith('Updated')) {
+                                const config = await loadAgentConfig();
+                                soulContentRef.current = config.soulContent;
+                                strategyContentRef.current = config.strategyContent;
+                            }
+                        }
+                    }
+                },
+            });
+            let fullResponse = '';
+            let lastFlushTime = 0;
+            const THROTTLE_MS = 80;
+            const streamErrors = [];
+            for await (const part of result.fullStream) {
+                if (part.type === 'text-delta') {
+                    fullResponse += part.text;
+                    const now = Date.now();
+                    if (now - lastFlushTime >= THROTTLE_MS) {
+                        setChatBuffer(fullResponse);
+                        lastFlushTime = now;
+                    }
+                }
+                else if (part.type === 'error') {
+                    const errMsg = typeof part.error === 'string' ? part.error : String(part.error);
+                    streamErrors.push(errMsg);
+                }
+            }
+            // Always flush the final value
+            setChatBuffer(fullResponse);
+            // Surface tool results when the model didn't produce follow-up text
+            const steps = await result.steps;
+            for (const step of steps) {
+                for (const toolResult of step.toolResults) {
+                    const output = String(toolResult.output);
+                    if (!fullResponse.includes(output)) {
+                        const suffix = `\n[${output}]`;
+                        fullResponse += suffix;
+                        setChatBuffer(fullResponse);
+                    }
+                }
+            }
+            if (fullResponse.trim().length === 0) {
+                const errorText = streamErrors.length > 0
+                    ? `Chat error: ${streamErrors.join('; ').slice(0, 120)}`
+                    : 'No response generated. Try again or rephrase.';
+                addChatActivity({ type: 'chat-error', text: errorText });
+                setChatBuffer('');
+                return;
+            }
+            sessionMessagesRef.current.push({ role: 'assistant', content: fullResponse });
+            addChatActivity({ type: 'chat-agent', text: fullResponse });
+            setChatBuffer('');
+        }
+        catch (err) {
+            const raw = extractErrorMessage(err);
+            addChatActivity({ type: 'chat-error', text: `Chat error: ${raw.slice(0, 120)}` });
+        }
+        finally {
+            setChatStreaming(false);
+        }
+    }, [chatStreaming, addChatActivity, agentName]);
+    return {
+        chatActivity,
+        input,
+        chatStreaming,
+        chatBuffer,
+        setInput,
+        handleChatSubmit,
+    };
+}

package/dist/commands/start/hooks/usePollActivity.js

@@ -0,0 +1,45 @@
+import { useCallback, useState } from 'react';
+const MAX_ITEM = 50;
+export const usePollActivity = () => {
+    const [pollActivityQueues, setPollActivityQueues] = useState({
+        active: [],
+        settled: [],
+    });
+    // idle, online, error
+    const addLog = useCallback((item) => {
+        setPollActivityQueues((prev) => {
+            const { active, settled } = prev;
+            let updated = [...settled, item];
+            if (updated.length > MAX_ITEM) {
+                updated = updated.slice(updated.length - MAX_ITEM);
+            }
+            return { active, settled: updated };
+        });
+    }, [setPollActivityQueues]);
+    const addMegathreadActivity = useCallback((item) => {
+        setPollActivityQueues((prev) => {
+            const { active, settled } = prev;
+            let updated = [...active, item];
+            return { active: updated, settled };
+        });
+    }, [setPollActivityQueues]);
+    const finalizeMegathreadActivity = useCallback((roundId, updates) => {
+        setPollActivityQueues(({ active, settled }) => {
+            const idx = active.findIndex((item) => item.type === 'megathread' && item.id === roundId);
+            if (idx === -1)
+                return { active, settled };
+            const tmp = active[idx];
+            const updated = { ...tmp, ...updates };
+            const updatedSettle = [...settled, updated];
+            const updatedActive = [...active.slice(0, idx), ...active.slice(idx + 1)];
+            return { active: updatedActive, settled: updatedSettle };
+        });
+    }, [setPollActivityQueues]);
+    return {
+        activePollActivities: pollActivityQueues.active,
+        settledPollActivities: pollActivityQueues.settled,
+        addLog,
+        addMegathreadActivity,
+        finalizeMegathreadActivity,
+    };
+};