@hive-org/cli 0.0.6 → 0.0.7

package/dist/agent/edit-section.js

@@ -0,0 +1,59 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export function replaceSection(fileContent, heading, newContent) {
+    const lines = fileContent.split('\n');
+    const headingLine = `## ${heading}`;
+    let startIdx = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].trim() === headingLine) {
+            startIdx = i;
+            break;
+        }
+    }
+    if (startIdx === -1) {
+        throw new Error(`Section "## ${heading}" not found in file.`);
+    }
+    let endIdx = lines.length;
+    for (let i = startIdx + 1; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (trimmed.startsWith('## ') || trimmed.startsWith('# ')) {
+            endIdx = i;
+            break;
+        }
+    }
+    const before = lines.slice(0, startIdx + 1);
+    const after = lines.slice(endIdx);
+    const trimmedContent = newContent.trim();
+    const newSection = ['', ...trimmedContent.split('\n'), ''];
+    const result = [...before, ...newSection, ...after].join('\n');
+    return result;
+}
+export const editSectionTool = tool({
+    description: 'Edit a section of SOUL.md or STRATEGY.md. Only call AFTER user confirms.',
+    inputSchema: z.object({
+        file: z.enum(['SOUL.md', 'STRATEGY.md']),
+        section: z.string().describe('Exact ## heading name, e.g. "Personality", "Conviction Style"'),
+        content: z.string().describe('New content for the section (without the ## heading line)'),
+    }),
+    execute: async ({ file, section, content }) => {
+        const filePath = path.join(process.cwd(), file);
+        let fileContent;
+        try {
+            fileContent = await fs.readFile(filePath, 'utf-8');
+        }
+        catch {
+            return `Error: ${file} not found in current directory.`;
+        }
+        try {
+            const updated = replaceSection(fileContent, section, content);
+            await fs.writeFile(filePath, updated, 'utf-8');
+            return `Updated "${section}" section in ${file}.`;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return `Error: ${message}`;
+        }
+    },
+});

package/dist/agent/fetch-rules.js

@@ -0,0 +1,21 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+const RULES_URL = 'https://hive.z3n.dev/RULES.md';
+export const fetchRulesTool = tool({
+    description: 'Fetch the rules of the Hive game. Call when the user asks about rules, scoring, honey, wax, streaks, or how the platform works.',
+    inputSchema: z.object({}),
+    execute: async () => {
+        try {
+            const response = await fetch(RULES_URL);
+            if (!response.ok) {
+                return `Error: failed to fetch rules (HTTP ${response.status}).`;
+            }
+            const rules = await response.text();
+            return rules;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return `Error: could not reach Hive to fetch rules. ${message}`;
+        }
+    },
+});

package/dist/agent/helpers.js

@@ -0,0 +1,22 @@
+export function formatTime(date) {
+    const hours = String(date.getHours()).padStart(2, '0');
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    const seconds = String(date.getSeconds()).padStart(2, '0');
+    return `${hours}:${minutes}:${seconds}`;
+}
+export function convictionColor(conviction) {
+    if (conviction > 0)
+        return 'green';
+    if (conviction < 0)
+        return 'red';
+    return 'gray';
+}
+export function stripCodeFences(text) {
+    const trimmed = text.trim();
+    const fencePattern = /^```(?:markdown|md)?\s*\n([\s\S]*?)\n```$/;
+    const match = trimmed.match(fencePattern);
+    if (match) {
+        return match[1].trim();
+    }
+    return trimmed;
+}

package/dist/agent/hooks/useAgent.js

@@ -0,0 +1,269 @@
+import { streamText, stepCountIs } from 'ai';
+import { useState, useEffect, useRef, useCallback } from 'react';
+import { HiveAgent } from '@hive-org/sdk';
+import { loadAgentConfig } from '../config.js';
+import { buildChatPrompt } from '../chat-prompt.js';
+import { editSectionTool } from '../edit-section.js';
+import { fetchRulesTool } from '../fetch-rules.js';
+import { loadMemory } from '@hive-org/sdk';
+import { processSignalAndSummarize, extractAndSaveMemory } from '../analysis.js';
+import { registerShutdownAgent } from '../process-lifecycle.js';
+import { getModel } from '../model.js';
+export function useAgent() {
+    const [phase, setPhase] = useState('booting');
+    const [connected, setConnected] = useState(false);
+    const [agentName, setAgentName] = useState('agent');
+    const [agentBio, setAgentBio] = useState('');
+    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('');
+    // ─── 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 removeLastAnalyzing = useCallback(() => {
+        setPollActivity((prev) => {
+            let lastIdx = -1;
+            for (let i = prev.length - 1; i >= 0; i--) {
+                if (prev[i].type === 'analyzing') {
+                    lastIdx = i;
+                    break;
+                }
+            }
+            if (lastIdx === -1) {
+                return prev;
+            }
+            return [...prev.slice(0, lastIdx), ...prev.slice(lastIdx + 1)];
+        });
+    }, []);
+    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 baseUrl = process.env.HIVE_API_URL ?? 'http://localhost:6969';
+            const config = await loadAgentConfig();
+            setAgentName(config.name);
+            setAgentBio(config.bio ?? '');
+            soulContentRef.current = config.soulContent;
+            strategyContentRef.current = config.strategyContent;
+            const initialMemory = await loadMemory();
+            memoryRef.current = initialMemory;
+            const agent = new HiveAgent(baseUrl, {
+                name: config.name,
+                avatarUrl: config.avatarUrl,
+                bio: config.bio ?? undefined,
+                predictionProfile: config.predictionProfile,
+                pollIntervalMs: 5000,
+                pollLimit: 20,
+                onPollEmpty: addIdleActivity,
+                onStop: async () => { },
+                onNewThread: async (thread) => {
+                    try {
+                        const threadPreview = thread.text.length > 80 ? thread.text.slice(0, 80) + '\u2026' : thread.text;
+                        addPollActivity({
+                            type: 'signal',
+                            text: `c/${thread.project_id} \u00B7 ${thread.id.slice(0, 8)}`,
+                            detail: threadPreview,
+                        });
+                        const summary = `[${thread.project_id}] ${threadPreview}`;
+                        recentThreadsRef.current = [summary, ...recentThreadsRef.current].slice(0, 5);
+                        addPollActivity({ type: 'analyzing', text: 'Analyzing signal...' });
+                        const result = await processSignalAndSummarize(thread, agent.recentComments, memoryRef.current, soulContentRef.current, strategyContentRef.current);
+                        if (result.skip) {
+                            removeLastAnalyzing();
+                            addPollActivity({ type: 'skipped', text: 'Skipped \u2014 outside expertise' });
+                            return;
+                        }
+                        await agent.postComment(thread.id, {
+                            thread_id: thread.id,
+                            text: result.summary,
+                            conviction: result.conviction,
+                        }, thread.text);
+                        removeLastAnalyzing();
+                        const sign = result.conviction >= 0 ? '+' : '';
+                        addPollActivity({
+                            type: 'posted',
+                            text: `[${sign}${result.conviction}%] "${result.summary}"`,
+                            conviction: result.conviction,
+                        });
+                        predictionCountRef.current += 1;
+                        setPredictionCount(predictionCountRef.current);
+                        const predSummary = `[${sign}${result.conviction}%] ${result.summary}`;
+                        recentPredictionsRef.current = [predSummary, ...recentPredictionsRef.current].slice(0, 5);
+                    }
+                    catch (err) {
+                        removeLastAnalyzing();
+                        const raw = err instanceof Error ? err.message : String(err);
+                        const message = raw.length > 120 ? raw.slice(0, 120) + '\u2026' : raw;
+                        addPollActivity({ type: 'error', text: message });
+                    }
+                },
+            });
+            agentRef.current = agent;
+            registerShutdownAgent(async () => {
+                await agent.stop();
+            });
+            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;
+        }
+        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 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 result = streamText({
+                model,
+                prompt,
+                tools: { editSection: editSectionTool, fetchRules: fetchRulesTool },
+                stopWhen: stepCountIs(2),
+                maxOutputTokens: 600,
+            });
+            let fullResponse = '';
+            for await (const chunk of result.textStream) {
+                fullResponse += chunk;
+                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);
+                    }
+                }
+            }
+            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]);
+    // ─── Boot transition ────────────────────────────────
+    const handleBootComplete = useCallback(() => {
+        setPhase('running');
+    }, []);
+    return {
+        phase,
+        connected,
+        agentName,
+        agentBio,
+        pollActivity,
+        chatActivity,
+        input,
+        chatStreaming,
+        chatBuffer,
+        predictionCount,
+        termWidth,
+        setInput,
+        handleChatSubmit,
+        handleBootComplete,
+    };
+}

package/{templates/memory-prompt.ts → dist/agent/memory-prompt.js}

@@ -1,33 +1,19 @@
-import type { ChatMessage } from './chat-prompt';
-
-export interface MemoryExtractionContext {
-  currentMemory: string;
-  sessionMessages: ChatMessage[];
-  lineCount: number;
-}
-
-export function buildMemoryExtractionPrompt(context: MemoryExtractionContext): string {
-  const { currentMemory, sessionMessages, lineCount } = context;
-
-  let sessionSection = '';
-  if (sessionMessages.length > 0) {
-    const listed = sessionMessages
-      .map((m) => `${m.role === 'user' ? 'Operator' : 'Agent'}: ${m.content}`)
-      .join('\n');
-    sessionSection = `\n## Session Chat Log\n\n${listed}\n`;
-  }
-
-  const currentMemorySection =
-    currentMemory.trim().length > 0
-      ? `\n## Current MEMORY.md\n\n\`\`\`markdown\n${currentMemory}\n\`\`\`\n`
-      : '\n## Current MEMORY.md\n\n(empty - this is a fresh agent)\n';
-
-  const consolidationNote =
-    lineCount > 200
-      ? `\n**IMPORTANT: The current memory is ${lineCount} lines, exceeding the 200-line soft limit. Aggressively consolidate: merge related items, remove outdated or low-value entries, and keep only the most important context.**\n`
-      : '';
-
-  const prompt = `You are an AI trading agent's memory system. Your job is to maintain conversational continuity between sessions with the agent's operator.
+export function buildMemoryExtractionPrompt(context) {
+    const { currentMemory, sessionMessages, lineCount } = context;
+    let sessionSection = '';
+    if (sessionMessages.length > 0) {
+        const listed = sessionMessages
+            .map((m) => `${m.role === 'user' ? 'Operator' : 'Agent'}: ${m.content}`)
+            .join('\n');
+        sessionSection = `\n## Session Chat Log\n\n${listed}\n`;
+    }
+    const currentMemorySection = currentMemory.trim().length > 0
+        ? `\n## Current MEMORY.md\n\n\`\`\`markdown\n${currentMemory}\n\`\`\`\n`
+        : '\n## Current MEMORY.md\n\n(empty - this is a fresh agent)\n';
+    const consolidationNote = lineCount > 200
+        ? `\n**IMPORTANT: The current memory is ${lineCount} lines, exceeding the 200-line soft limit. Aggressively consolidate: merge related items, remove outdated or low-value entries, and keep only the most important context.**\n`
+        : '';
+    const prompt = `You are an AI trading agent's memory system. Your job is to maintain conversational continuity between sessions with the agent's operator.
 ${currentMemorySection}${consolidationNote}
 ## Session Activity
 ${sessionSection}
@@ -55,6 +41,5 @@ Follow these rules:
 6. **Keep it under ~200 lines** — This file is injected into every prompt, so brevity matters.
 
 Output the complete updated MEMORY.md content. Start with \`# Memory\` as the top-level header. Output ONLY the markdown content, no code fences or explanation.`;
-
-  return prompt;
+    return prompt;
 }

package/dist/agent/model.js

@@ -0,0 +1,63 @@
+const PROVIDERS = [
+    {
+        envVar: 'ANTHROPIC_API_KEY',
+        defaultModel: 'claude-opus-4-5',
+        load: async (modelId) => {
+            const { anthropic } = await import('@ai-sdk/anthropic');
+            return anthropic(modelId);
+        },
+    },
+    {
+        envVar: 'OPENAI_API_KEY',
+        defaultModel: 'gpt-4o',
+        load: async (modelId) => {
+            const { openai } = await import('@ai-sdk/openai');
+            return openai(modelId);
+        },
+    },
+    {
+        envVar: 'GOOGLE_GENERATIVE_AI_API_KEY',
+        defaultModel: 'gemini-3-pro-preview',
+        load: async (modelId) => {
+            const { google } = await import('@ai-sdk/google');
+            return google(modelId);
+        },
+    },
+    {
+        envVar: 'XAI_API_KEY',
+        defaultModel: 'grok-4',
+        load: async (modelId) => {
+            const { xai } = await import('@ai-sdk/xai');
+            return xai(modelId);
+        },
+    },
+    {
+        envVar: 'OPENROUTER_API_KEY',
+        defaultModel: 'anthropic/claude-3.5-sonnet',
+        load: async (modelId) => {
+            const { createOpenRouter } = await import('@openrouter/ai-sdk-provider');
+            const openrouter = createOpenRouter({ apiKey: process.env.OPENROUTER_API_KEY });
+            return openrouter.chat(modelId);
+        },
+    },
+];
+let _modelPromise = null;
+export function getModel() {
+    if (_modelPromise) {
+        return _modelPromise;
+    }
+    _modelPromise = (async () => {
+        const overrideModel = process.env.HIVE_MODEL;
+        for (const provider of PROVIDERS) {
+            const keyValue = process.env[provider.envVar];
+            if (keyValue && keyValue.trim().length > 0) {
+                const modelId = overrideModel ?? provider.defaultModel;
+                const model = await provider.load(modelId);
+                return model;
+            }
+        }
+        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');
+    })();
+    return _modelPromise;
+}

package/dist/agent/objects.js

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

package/dist/agent/process-lifecycle.js

@@ -0,0 +1,56 @@
+import chalk from 'chalk';
+import { symbols } from './theme.js';
+let _shutdownAgent = null;
+let _shuttingDown = false;
+export function registerShutdownAgent(fn) {
+    _shutdownAgent = fn;
+}
+export function clearShutdownAgent() {
+    _shutdownAgent = null;
+}
+const restoreScreen = () => {
+    process.stdout.write('\x1b[?1049l');
+};
+export const gracefulShutdown = async (exitCode = 0) => {
+    if (_shuttingDown) {
+        return;
+    }
+    _shuttingDown = true;
+    if (_shutdownAgent) {
+        try {
+            await _shutdownAgent();
+        }
+        catch {
+            // Best-effort memory save on shutdown
+        }
+        _shutdownAgent = null;
+    }
+    restoreScreen();
+    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}`));
+    });
+    // Use alternate screen buffer (like vim/htop) to prevent text reflow on resize.
+    // The normal buffer reflows wrapped lines when the terminal width changes, which
+    // desyncs Ink's internal line counter and produces ghost copies of the UI.
+    // The alternate buffer is position-based — no reflow, no ghosts.
+    process.stdout.write('\x1b[?1049h');
+    process.on('exit', restoreScreen);
+    process.on('SIGINT', () => {
+        gracefulShutdown().catch(() => {
+            restoreScreen();
+            process.exit(1);
+        });
+    });
+    process.on('SIGTERM', () => {
+        gracefulShutdown().catch(() => {
+            restoreScreen();
+            process.exit(1);
+        });
+    });
+}

package/{templates/prompt.ts → dist/agent/prompt.js}

@@ -1,34 +1,9 @@
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import type { CitationDto } from './hive/objects';
-
-export interface BuildPromptOptions {
-  threadText: string;
-  projectId: string;
-  timestamp: string;
-  priceOnFetch: number;
-  citations: CitationDto[];
-  recentPosts?: readonly string[];
-  memory?: string;
-}
-
-async function loadMarkdownFile(filename: string): Promise<string> {
-  const filePath = path.join(process.cwd(), filename);
-  const content = await fs.readFile(filePath, 'utf-8');
-  return content;
-}
-
-export async function buildAnalystPrompt(options: BuildPromptOptions): Promise<string> {
-  const { threadText, projectId, timestamp, priceOnFetch, citations, recentPosts, memory } =
-    options;
-
-  const soulContent = await loadMarkdownFile('SOUL.md');
-  const strategyContent = await loadMarkdownFile('STRATEGY.md');
-
-  let recentPostsSection = '';
-  if (recentPosts && recentPosts.length > 0) {
-    const listed = recentPosts.map((p) => `- "${p}"`).join('\n');
-    recentPostsSection = `
+export function buildAnalystPrompt(soulContent, strategyContent, options) {
+    const { threadText, projectId, timestamp, priceOnFetch, citations, recentPosts, memory } = options;
+    let recentPostsSection = '';
+    if (recentPosts && recentPosts.length > 0) {
+        const listed = recentPosts.map((p) => `- "${p}"`).join('\n');
+        recentPostsSection = `
 ## Anti-repetition
 
 Your recent posts (do NOT repeat these structures, phrases, or opening patterns):
@@ -36,29 +11,26 @@ ${listed}
 
 If you catch yourself writing something that sounds like any of the above - stop and take a completely different angle.
 `;
-  }
-
-  let memorySection = '';
-  if (memory && memory.trim().length > 0) {
-    memorySection = `
+    }
+    let memorySection = '';
+    if (memory && memory.trim().length > 0) {
+        memorySection = `
 ## Agent Memory
 
 Your persistent learnings from past sessions:
 ${memory}
 `;
-  }
-
-  let citationsSection = '';
-  if (citations.length > 0) {
-    const listed = citations.map((c) => `- [${c.title}](${c.url})`).join('\n');
-    citationsSection = `
+    }
+    let citationsSection = '';
+    if (citations.length > 0) {
+        const listed = citations.map((c) => `- [${c.title}](${c.url})`).join('\n');
+        citationsSection = `
 ## Sources
 
 ${listed}
 `;
-  }
-
-  const prompt = `You are a Crypto Twitter personality. Here's who you are:
+    }
+    const prompt = `You are a Crypto Twitter personality. Here's who you are:
 ---
 ${soulContent}
 ---
@@ -163,6 +135,5 @@ Conviction calibration — match signal strength to magnitude:
 - Black swan, regulatory bombshell, massive exploit → ±12.0 to ±25.0
 
 IMPORTANT: Vary your conviction numbers. Do NOT reuse the same number across signals. Each signal has different strength — your conviction should reflect that.`;
-
-  return prompt;
+    return prompt;
 }