@zhive/cli 0.6.3 → 0.6.4

package/dist/agent/hooks/useAgent.js

@@ -1,480 +0,0 @@
-import { HiveAgent, loadMemory } from '@hive-org/sdk';
-import { ToolLoopAgent } from 'ai';
-import { useCallback, useEffect, useRef, useState } from 'react';
-import { HIVE_FRONTEND_URL } from '../../config.js';
-import { buildTextReport, fetchBacktestThreads, loadDefaultBacktest, runBacktest, } from '../../backtest/index.js';
-import { extractAndSaveMemory, processMegathreadRound, processSignalAndSummarize, } from '../analysis.js';
-import { buildChatPrompt } from '../chat-prompt.js';
-import { SLASH_COMMANDS } from '../commands/registry.js';
-import { loadAgentConfig } from '../config.js';
-import { editSectionTool } from '../edit-section.js';
-import { fetchRulesTool } from '../fetch-rules.js';
-import { getModel, resolveModelInfo } from '../model.js';
-import { getAllTools, getReadSkillTool, getSkillMetadataList, initializeSkills, } from '../tools/index.js';
-import { getMarketClient } from '../tools/market/index.js';
-export function useAgent() {
-    const [connected, setConnected] = useState(false);
-    const [agentName, setAgentName] = useState('agent');
-    const [agentBio, setAgentBio] = useState('');
-    const [modelInfo, setModelInfo] = useState(null);
-    const [pollActivity, setPollActivity] = useState([]);
-    const [chatActivity, setChatActivity] = useState([]);
-    const [input, setInput] = useState('');
-    const [chatStreaming, setChatStreaming] = useState(false);
-    const [chatBuffer, setChatBuffer] = useState('');
-    const [predictionCount, setPredictionCount] = useState(0);
-    const [termWidth, setTermWidth] = useState(process.stdout.columns || 60);
-    const agentRef = useRef(null);
-    const sessionMessagesRef = useRef([]);
-    const memoryRef = useRef('');
-    const chatCountSinceExtractRef = useRef(0);
-    const extractingRef = useRef(false);
-    const recentThreadsRef = useRef([]);
-    const recentPredictionsRef = useRef([]);
-    const predictionCountRef = useRef(0);
-    const soulContentRef = useRef('');
-    const strategyContentRef = useRef('');
-    const skillToolsRef = useRef({});
-    const skillMetadataRef = useRef('');
-    // ─── Terminal resize tracking ───────────────────────
-    useEffect(() => {
-        const onResize = () => {
-            setTermWidth(process.stdout.columns || 60);
-        };
-        process.stdout.on('resize', onResize);
-        return () => {
-            process.stdout.off('resize', onResize);
-        };
-    }, []);
-    // ─── Activity helpers ───────────────────────────────
-    const addPollActivity = useCallback((item) => {
-        setPollActivity((prev) => {
-            const updated = [...prev, { ...item, timestamp: new Date() }];
-            const maxItems = 50;
-            if (updated.length > maxItems) {
-                return updated.slice(updated.length - maxItems);
-            }
-            return updated;
-        });
-    }, []);
-    const addIdleActivity = useCallback(() => {
-        setPollActivity((prev) => {
-            const updated = [
-                ...prev,
-                { type: 'idle', text: 'Polled but no new threads', timestamp: new Date() },
-            ];
-            const maxItems = 50;
-            if (updated.length > maxItems) {
-                return updated.slice(updated.length - maxItems);
-            }
-            return updated;
-        });
-    }, []);
-    const updatePollActivity = useCallback((id, updates) => {
-        setPollActivity((prev) => {
-            let idx = -1;
-            for (let i = prev.length - 1; i >= 0; i--) {
-                if (prev[i].id === id) {
-                    idx = i;
-                    break;
-                }
-            }
-            if (idx === -1)
-                return prev;
-            const updated = [...prev];
-            updated[idx] = { ...updated[idx], ...updates };
-            return updated;
-        });
-    }, []);
-    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;
-        });
-    }, []);
-    // ─── Agent lifecycle ────────────────────────────────
-    useEffect(() => {
-        const start = async () => {
-            const { HIVE_API_URL } = await import('../../config.js');
-            const baseUrl = HIVE_API_URL;
-            const config = await loadAgentConfig();
-            setAgentName(config.name);
-            setAgentBio(config.bio ?? '');
-            soulContentRef.current = config.soulContent;
-            strategyContentRef.current = config.strategyContent;
-            const resolvedModelInfo = resolveModelInfo();
-            setModelInfo(resolvedModelInfo);
-            const skillRegistry = await initializeSkills(process.cwd());
-            const allTools = getAllTools();
-            const readSkillTool = getReadSkillTool(skillRegistry);
-            skillToolsRef.current = { ...allTools, readSkill: readSkillTool };
-            skillMetadataRef.current = getSkillMetadataList(skillRegistry);
-            const initialMemory = await loadMemory();
-            memoryRef.current = initialMemory;
-            const agent = new HiveAgent(baseUrl, {
-                name: config.name,
-                avatarUrl: config.avatarUrl,
-                bio: config.bio ?? undefined,
-                agentProfile: config.agentProfile,
-                pollIntervalMs: 30_000,
-                pollLimit: 5,
-                onPollEmpty: addIdleActivity,
-                onStop: async () => { },
-                onNewThread: async (thread) => {
-                    const threadPreview = thread.text.length > 80 ? thread.text.slice(0, 80) + '\u2026' : thread.text;
-                    const projectTag = `c/${thread.project_id}`;
-                    addPollActivity({
-                        type: 'signal',
-                        id: thread.id,
-                        text: projectTag,
-                        detail: threadPreview,
-                        status: 'analyzing',
-                    });
-                    const summary = `[${thread.project_id}] ${threadPreview}`;
-                    recentThreadsRef.current = [summary, ...recentThreadsRef.current].slice(0, 5);
-                    try {
-                        const result = await processSignalAndSummarize(thread, agent.recentComments, memoryRef.current, soulContentRef.current, strategyContentRef.current, skillToolsRef.current, skillMetadataRef.current);
-                        if (result.skip) {
-                            updatePollActivity(thread.id, {
-                                status: 'skipped',
-                                tokenUsage: result.usage,
-                            });
-                            return;
-                        }
-                        await agent.postComment(thread.id, {
-                            thread_id: thread.id,
-                            text: result.summary,
-                            conviction: result.conviction,
-                        }, thread.text);
-                        const sign = result.conviction >= 0 ? '+' : '';
-                        const threadUrl = `${HIVE_FRONTEND_URL}/c/${thread.project_id}/${thread.id}`;
-                        updatePollActivity(thread.id, {
-                            status: 'posted',
-                            conviction: result.conviction,
-                            result: `[${sign}${result.conviction.toFixed(2)}%] "${result.summary}"`,
-                            url: threadUrl,
-                            tokenUsage: result.usage,
-                        });
-                        predictionCountRef.current += 1;
-                        setPredictionCount(predictionCountRef.current);
-                        const predSummary = `[${sign}${result.conviction.toFixed(2)}%] ${result.summary}`;
-                        recentPredictionsRef.current = [predSummary, ...recentPredictionsRef.current].slice(0, 5);
-                    }
-                    catch (err) {
-                        const raw = err instanceof Error ? err.message : String(err);
-                        const message = raw.length > 120 ? raw.slice(0, 120) + '\u2026' : raw;
-                        updatePollActivity(thread.id, { status: 'error', result: message });
-                    }
-                },
-                onNewMegathreadRound: async (round) => {
-                    const hours = Math.round(round.durationMs / 3_600_000);
-                    const timeframe = hours >= 1 ? `${hours}h` : `${Math.round(round.durationMs / 60_000)}m`;
-                    const projectTag = `c/${round.projectId}`;
-                    addPollActivity({
-                        type: 'megathread',
-                        id: round.roundId,
-                        text: `${projectTag} \u00B7 ${timeframe} round`,
-                        detail: round.roundId.split('@')[0],
-                        status: 'analyzing',
-                    });
-                    let priceAtStart;
-                    let currentPrice;
-                    try {
-                        const client = getMarketClient();
-                        const roundStartTimestamp = round.roundId.split('@Z')[0];
-                        const [startResponse, nowResponse] = await Promise.all([
-                            client.getPrice(round.projectId, roundStartTimestamp),
-                            client.getPrice(round.projectId, new Date().toISOString()),
-                        ]);
-                        if (startResponse.price !== null) {
-                            priceAtStart = startResponse.price;
-                        }
-                        if (nowResponse.price !== null) {
-                            currentPrice = nowResponse.price;
-                        }
-                    }
-                    catch {
-                        // Price fetch failed — both stay undefined, prompt falls back to current behavior
-                    }
-                    try {
-                        const result = await processMegathreadRound(round.projectId, round.durationMs, agent.recentComments, memoryRef.current, soulContentRef.current, strategyContentRef.current, skillToolsRef.current, skillMetadataRef.current, priceAtStart, currentPrice);
-                        if (result.skip) {
-                            updatePollActivity(round.roundId, {
-                                status: 'skipped',
-                                tokenUsage: result.usage,
-                            });
-                            return;
-                        }
-                        await agent.postMegathreadComment(round.roundId, {
-                            text: result.summary,
-                            conviction: result.conviction,
-                            tokenId: round.projectId,
-                            roundDuration: round.durationMs,
-                        });
-                        const sign = result.conviction >= 0 ? '+' : '';
-                        const megathreadUrl = `${HIVE_FRONTEND_URL}/c/${round.projectId}/megathread/${timeframe}`;
-                        updatePollActivity(round.roundId, {
-                            status: 'posted',
-                            conviction: result.conviction,
-                            result: `[${sign}${result.conviction.toFixed(2)}%] "${result.summary}"`,
-                            url: megathreadUrl,
-                            tokenUsage: result.usage,
-                        });
-                        predictionCountRef.current += 1;
-                        setPredictionCount(predictionCountRef.current);
-                        const predSummary = `[${sign}${result.conviction.toFixed(2)}%] ${result.summary}`;
-                        recentPredictionsRef.current = [predSummary, ...recentPredictionsRef.current].slice(0, 5);
-                    }
-                    catch (err) {
-                        const raw = err instanceof Error ? err.message : String(err);
-                        const message = raw.length > 120 ? raw.slice(0, 120) + '\u2026' : raw;
-                        updatePollActivity(round.roundId, { status: 'error', result: message });
-                    }
-                },
-            });
-            agentRef.current = agent;
-            await agent.start();
-            setConnected(true);
-            const bio = config.bio ?? '';
-            if (bio) {
-                addPollActivity({
-                    type: 'online',
-                    text: `${config.name} agent online \u2014 "${bio}"`,
-                });
-            }
-        };
-        start().catch((err) => {
-            const raw = err instanceof Error ? err.message : String(err);
-            const isNameTaken = raw.includes('409');
-            const hint = isNameTaken ? ' Change the name in SOUL.md under "# Agent: <name>".' : '';
-            addPollActivity({ type: 'error', text: `Fatal: ${raw.slice(0, 120)}${hint}` });
-        });
-        return () => {
-            agentRef.current?.stop().catch(() => { });
-        };
-    }, []);
-    // ─── 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': () => {
-                    const skillsOutput = skillMetadataRef.current || 'No skills loaded.';
-                    addChatActivity({ type: 'chat-agent', text: skillsOutput });
-                },
-                '/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 { HIVE_API_URL } = await import('../../config.js');
-                    const numThreads = commandArg ? parseInt(commandArg, 10) : null;
-                    let data;
-                    if (numThreads !== null && !isNaN(numThreads) && numThreads > 0) {
-                        // Fetch from API
-                        addChatActivity({
-                            type: 'chat-agent',
-                            text: `Fetching ${numThreads} resolved threads...`,
-                        });
-                        const fetchResult = await fetchBacktestThreads(numThreads, HIVE_API_URL);
-                        if (fetchResult.success) {
-                            data = fetchResult.data;
-                        }
-                        else {
-                            addChatActivity({
-                                type: 'chat-agent',
-                                text: `API fetch failed (${fetchResult.error}), falling back to default dataset...`,
-                            });
-                        }
-                    }
-                    // Use default dataset
-                    if (!data) {
-                        addChatActivity({
-                            type: 'chat-agent',
-                            text: 'Starting backtest against default dataset...',
-                        });
-                        data = loadDefaultBacktest();
-                    }
-                    try {
-                        const config = {
-                            agentPath: process.cwd(),
-                            soulContent: soulContentRef.current,
-                            strategyContent: strategyContentRef.current,
-                            agentName: agentName,
-                        };
-                        const result = await runBacktest(data, config, {
-                            onThreadStart: (index, total, thread) => {
-                                addChatActivity({
-                                    type: 'chat-agent',
-                                    text: `Processing ${index + 1}/${total}: ${thread.project_name}...`,
-                                });
-                            },
-                        });
-                        const report = buildTextReport(result);
-                        addChatActivity({ type: 'chat-agent', text: report });
-                        sessionMessagesRef.current.push({ role: 'assistant', content: report });
-                    }
-                    catch (err) {
-                        const errMessage = err instanceof Error ? err.message : String(err);
-                        addChatActivity({ type: 'chat-error', text: `Backtest failed: ${errMessage}` });
-                    }
-                },
-            };
-            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, {
-                recentThreadSummaries: recentThreadsRef.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 = err instanceof Error ? err.message : String(err);
-            addChatActivity({ type: 'chat-error', text: `Chat error: ${raw.slice(0, 120)}` });
-        }
-        finally {
-            setChatStreaming(false);
-        }
-    }, [chatStreaming, addChatActivity]);
-    return {
-        connected,
-        agentName,
-        agentBio,
-        modelInfo,
-        pollActivity,
-        chatActivity,
-        input,
-        chatStreaming,
-        chatBuffer,
-        predictionCount,
-        termWidth,
-        setInput,
-        handleChatSubmit,
-    };
-}

package/dist/agent/objects.js

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

package/dist/agent/process-lifecycle.js

@@ -1,18 +0,0 @@
-import chalk from 'chalk';
-import { symbols } from './theme.js';
-const exitImmediately = (exitCode = 0) => {
-    process.exit(exitCode);
-};
-export function setupProcessLifecycle() {
-    // Unhandled rejection handler
-    process.on('unhandledRejection', (reason) => {
-        const raw = reason instanceof Error ? reason.message : String(reason);
-        const message = raw.length > 200 ? raw.slice(0, 200) + '\u2026' : raw;
-        console.error(chalk.red(`  ${symbols.cross} Unhandled: ${message}`));
-    });
-    // No alternate screen buffer — normal buffer allows terminal scrollback
-    // so users can scroll up to see historical poll activity.
-    // <Static> items from Ink flow into the scrollback naturally.
-    process.on('SIGINT', () => exitImmediately(0));
-    process.on('SIGTERM', () => exitImmediately(0));
-}