@zhive/cli 0.6.6 → 0.6.7

package/dist/services/agent/tools/read-skill-tool.js

@@ -1,30 +0,0 @@
-import { tool } from 'ai';
-import { z } from 'zod';
-/**
- * Create a tool that allows the agent to read skill knowledge.
- * Returns the full SKILL.md body content when called.
- */
-export function createReadSkillTool(skillRegistry) {
-    const readSkillTool = tool({
-        description: 'Read a skill to get detailed knowledge and instructions. Call this when you need specialized expertise for analysis. Use the skill ID from the available skills list.',
-        inputSchema: z.object({
-            skillId: z
-                .string()
-                .describe('The skill ID to read (from the available skills list in your prompt)'),
-        }),
-        execute: async ({ skillId }) => {
-            const skill = skillRegistry.get(skillId);
-            if (skill === undefined) {
-                const availableIds = Array.from(skillRegistry.keys());
-                if (availableIds.length === 0) {
-                    return `Skill "${skillId}" not found. No skills are currently available.`;
-                }
-                const idList = availableIds.join(', ');
-                return `Skill "${skillId}" not found. Available skills: ${idList}`;
-            }
-            const output = `# ${skill.metadata.name}\n\n${skill.body}`;
-            return output;
-        },
-    });
-    return readSkillTool;
-}

package/dist/services/agent/tools/ta/index.js

@@ -1 +0,0 @@
-export { computeSMA, computeEMA, computeRSI, computeMACD, computeBollingerBands } from './indicators.js';

package/dist/services/agent/tools/ta/indicators.js

@@ -1,201 +0,0 @@
-/**
- * Extract close prices from OHLC data.
- */
-function extractClosePrices(data) {
-    const result = [];
-    for (const point of data) {
-        const timestamp = point[0];
-        const close = point[4];
-        result.push({ timestamp, close });
-    }
-    return result;
-}
-/**
- * Compute Simple Moving Average (SMA).
- * SMA = sum of close prices over period / period
- */
-export function computeSMA(data, period) {
-    const prices = extractClosePrices(data);
-    const result = [];
-    if (prices.length < period) {
-        return result;
-    }
-    for (let i = period - 1; i < prices.length; i++) {
-        let sum = 0;
-        for (let j = i - period + 1; j <= i; j++) {
-            sum += prices[j].close;
-        }
-        const sma = sum / period;
-        result.push({
-            timestamp: prices[i].timestamp,
-            value: sma,
-        });
-    }
-    return result;
-}
-/**
- * Compute Exponential Moving Average (EMA).
- * EMA = (Close - Previous EMA) * multiplier + Previous EMA
- * multiplier = 2 / (period + 1)
- */
-export function computeEMA(data, period) {
-    const prices = extractClosePrices(data);
-    const result = [];
-    if (prices.length < period) {
-        return result;
-    }
-    const multiplier = 2 / (period + 1);
-    let initialSum = 0;
-    for (let i = 0; i < period; i++) {
-        initialSum += prices[i].close;
-    }
-    let ema = initialSum / period;
-    result.push({
-        timestamp: prices[period - 1].timestamp,
-        value: ema,
-    });
-    for (let i = period; i < prices.length; i++) {
-        ema = (prices[i].close - ema) * multiplier + ema;
-        result.push({
-            timestamp: prices[i].timestamp,
-            value: ema,
-        });
-    }
-    return result;
-}
-/**
- * Compute Relative Strength Index (RSI).
- * RSI = 100 - (100 / (1 + RS))
- * RS = Average Gain / Average Loss over period
- */
-export function computeRSI(data, period) {
-    const prices = extractClosePrices(data);
-    const result = [];
-    if (prices.length < period + 1) {
-        return result;
-    }
-    const gains = [];
-    const losses = [];
-    for (let i = 1; i < prices.length; i++) {
-        const change = prices[i].close - prices[i - 1].close;
-        if (change > 0) {
-            gains.push(change);
-            losses.push(0);
-        }
-        else {
-            gains.push(0);
-            losses.push(Math.abs(change));
-        }
-    }
-    let avgGain = 0;
-    let avgLoss = 0;
-    for (let i = 0; i < period; i++) {
-        avgGain += gains[i];
-        avgLoss += losses[i];
-    }
-    avgGain /= period;
-    avgLoss /= period;
-    const rs = avgLoss === 0 ? 100 : avgGain / avgLoss;
-    const rsi = 100 - 100 / (1 + rs);
-    result.push({
-        timestamp: prices[period].timestamp,
-        value: rsi,
-    });
-    for (let i = period; i < gains.length; i++) {
-        avgGain = (avgGain * (period - 1) + gains[i]) / period;
-        avgLoss = (avgLoss * (period - 1) + losses[i]) / period;
-        const currentRs = avgLoss === 0 ? 100 : avgGain / avgLoss;
-        const currentRsi = 100 - 100 / (1 + currentRs);
-        result.push({
-            timestamp: prices[i + 1].timestamp,
-            value: currentRsi,
-        });
-    }
-    return result;
-}
-/**
- * Compute MACD (Moving Average Convergence Divergence).
- * MACD Line = Fast EMA - Slow EMA
- * Signal Line = EMA of MACD Line
- * Histogram = MACD Line - Signal Line
- */
-export function computeMACD(data, fastPeriod = 12, slowPeriod = 26, signalPeriod = 9) {
-    const fastEma = computeEMA(data, fastPeriod);
-    const slowEma = computeEMA(data, slowPeriod);
-    const result = [];
-    if (fastEma.length === 0 || slowEma.length === 0) {
-        return result;
-    }
-    const fastMap = new Map();
-    for (const point of fastEma) {
-        fastMap.set(point.timestamp, point.value);
-    }
-    const macdLine = [];
-    for (const slow of slowEma) {
-        const fast = fastMap.get(slow.timestamp);
-        if (fast !== undefined) {
-            macdLine.push({
-                timestamp: slow.timestamp,
-                value: fast - slow.value,
-            });
-        }
-    }
-    if (macdLine.length < signalPeriod) {
-        return result;
-    }
-    const signalMultiplier = 2 / (signalPeriod + 1);
-    let signalSum = 0;
-    for (let i = 0; i < signalPeriod; i++) {
-        signalSum += macdLine[i].value;
-    }
-    let signal = signalSum / signalPeriod;
-    result.push({
-        timestamp: macdLine[signalPeriod - 1].timestamp,
-        macd: macdLine[signalPeriod - 1].value,
-        signal,
-        histogram: macdLine[signalPeriod - 1].value - signal,
-    });
-    for (let i = signalPeriod; i < macdLine.length; i++) {
-        signal = (macdLine[i].value - signal) * signalMultiplier + signal;
-        result.push({
-            timestamp: macdLine[i].timestamp,
-            macd: macdLine[i].value,
-            signal,
-            histogram: macdLine[i].value - signal,
-        });
-    }
-    return result;
-}
-/**
- * Compute Bollinger Bands.
- * Middle Band = SMA
- * Upper Band = SMA + (stdDev * standard deviation)
- * Lower Band = SMA - (stdDev * standard deviation)
- */
-export function computeBollingerBands(data, period = 20, stdDevMultiplier = 2) {
-    const prices = extractClosePrices(data);
-    const result = [];
-    if (prices.length < period) {
-        return result;
-    }
-    for (let i = period - 1; i < prices.length; i++) {
-        let sum = 0;
-        for (let j = i - period + 1; j <= i; j++) {
-            sum += prices[j].close;
-        }
-        const sma = sum / period;
-        let squaredDiffSum = 0;
-        for (let j = i - period + 1; j <= i; j++) {
-            const diff = prices[j].close - sma;
-            squaredDiffSum += diff * diff;
-        }
-        const stdDev = Math.sqrt(squaredDiffSum / period);
-        result.push({
-            timestamp: prices[i].timestamp,
-            upper: sma + stdDevMultiplier * stdDev,
-            middle: sma,
-            lower: sma - stdDevMultiplier * stdDev,
-        });
-    }
-    return result;
-}

package/dist/services/agent/types.js

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

package/dist/services/ai-providers.js

@@ -1,66 +0,0 @@
-export const AI_PROVIDERS = [
-    {
-        id: 'openai',
-        label: 'OpenAI',
-        package: '@ai-sdk/openai',
-        envVar: 'OPENAI_API_KEY',
-        models: { validation: 'gpt-4o-mini', generation: 'gpt-5-mini', runtime: 'gpt-5-mini' },
-    },
-    {
-        id: 'anthropic',
-        label: 'Anthropic',
-        package: '@ai-sdk/anthropic',
-        envVar: 'ANTHROPIC_API_KEY',
-        models: {
-            validation: 'claude-haiku-4-5-20251001',
-            generation: 'claude-haiku-4-5',
-            runtime: 'claude-haiku-4-5',
-        },
-    },
-    {
-        id: 'google',
-        label: 'Google',
-        package: '@ai-sdk/google',
-        envVar: 'GOOGLE_GENERATIVE_AI_API_KEY',
-        models: {
-            validation: 'gemini-2.0-flash',
-            generation: 'gemini-3-flash-preview',
-            runtime: 'gemini-3-flash-preview',
-        },
-    },
-    {
-        id: 'xai',
-        label: 'xAI',
-        package: '@ai-sdk/xai',
-        envVar: 'XAI_API_KEY',
-        models: {
-            validation: 'grok-2',
-            generation: 'grok-4-1-fast-reasoning',
-            runtime: 'grok-4-1-fast-reasoning',
-        },
-    },
-    {
-        id: 'openrouter',
-        label: 'OpenRouter',
-        package: '@openrouter/ai-sdk-provider',
-        envVar: 'OPENROUTER_API_KEY',
-        models: {
-            validation: 'openai/gpt-4o-mini',
-            generation: 'openai/gpt-5.1-mini',
-            runtime: 'openai/gpt-5.1-mini',
-        },
-    },
-];
-/**
- * All env-var names used by AI providers.
- * Used to clear shell-inherited keys before loading an agent's .env,
- * so only the agent's chosen provider is active.
- */
-export const AI_PROVIDER_ENV_VARS = AI_PROVIDERS.map((p) => p.envVar);
-export function getProvider(id) {
-    const provider = AI_PROVIDERS.find((p) => p.id === id);
-    if (!provider) {
-        throw new Error(`Unknown AI provider: ${id}`);
-    }
-    return provider;
-}

package/dist/services/config/agent.js

@@ -1,110 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import os from 'os';
-import axios from 'axios';
-import { AI_PROVIDERS } from '../ai-providers.js';
-import { HIVE_API_URL } from './constant.js';
-function extractField(content, pattern) {
-    const match = content.match(pattern);
-    if (match === null) {
-        return null;
-    }
-    const value = match[1].trim();
-    return value;
-}
-export async function scanAgents() {
-    const agentsDir = path.join(os.homedir(), '.hive', 'agents');
-    const exists = await fs.pathExists(agentsDir);
-    if (!exists) {
-        return [];
-    }
-    const entries = await fs.readdir(agentsDir, { withFileTypes: true });
-    const agents = [];
-    for (const entry of entries) {
-        if (!entry.isDirectory()) {
-            continue;
-        }
-        const soulPath = path.join(agentsDir, entry.name, 'SOUL.md');
-        const soulExists = await fs.pathExists(soulPath);
-        if (!soulExists) {
-            continue;
-        }
-        const agentDir = path.join(agentsDir, entry.name);
-        const provider = await detectProvider(agentDir);
-        const stat = await fs.stat(soulPath);
-        const soulContent = await fs.readFile(soulPath, 'utf-8');
-        const parsedName = extractField(soulContent, /^#\s+Agent:\s+(.+)$/m);
-        const avatarUrl = extractField(soulContent, /^## Avatar\s*\n+(https?:\/\/.+)$/m);
-        const bio = extractField(soulContent, /^## Bio\s*\n+(.+)$/m);
-        agents.push({
-            name: parsedName ?? entry.name,
-            dir: agentDir,
-            provider,
-            created: stat.birthtime,
-            avatar_url: avatarUrl ?? undefined,
-            bio: bio ?? undefined,
-        });
-    }
-    return agents;
-}
-export function sortByHoney(rows) {
-    const sorted = [...rows].sort((a, b) => (b.stats?.honey ?? 0) - (a.stats?.honey ?? 0));
-    return sorted;
-}
-export function sortAgentsByHoney(agents, statsMap) {
-    const sorted = [...agents].sort((a, b) => {
-        const honeyA = statsMap.get(a.name)?.honey ?? 0;
-        const honeyB = statsMap.get(b.name)?.honey ?? 0;
-        return honeyB - honeyA;
-    });
-    return sorted;
-}
-export async function fetchBulkStats(names) {
-    const statsMap = new Map();
-    if (names.length === 0) {
-        return statsMap;
-    }
-    try {
-        const response = await axios.post(`${HIVE_API_URL}/agent/by-names`, { names });
-        for (const agent of response.data) {
-            statsMap.set(agent.name, {
-                honey: agent.honey ?? 0,
-                wax: agent.wax ?? 0,
-                win_rate: agent.win_rate ?? 0,
-                confidence: agent.confidence ?? 0,
-                total_comments: agent.total_comments ?? 0,
-            });
-        }
-    }
-    catch {
-        // API unreachable — return empty map, CLI will show dashes
-    }
-    return statsMap;
-}
-async function detectProvider(agentDir) {
-    // Try old-style detection: check package.json dependencies
-    const pkgPath = path.join(agentDir, 'package.json');
-    const pkgExists = await fs.pathExists(pkgPath);
-    if (pkgExists) {
-        const pkg = await fs.readJson(pkgPath);
-        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-        for (const provider of AI_PROVIDERS) {
-            if (deps[provider.package]) {
-                return provider.label;
-            }
-        }
-    }
-    // New-style detection: check .env for provider API keys
-    const envPath = path.join(agentDir, '.env');
-    const envExists = await fs.pathExists(envPath);
-    if (envExists) {
-        const envContent = await fs.readFile(envPath, 'utf-8');
-        for (const provider of AI_PROVIDERS) {
-            const pattern = new RegExp(`^${provider.envVar}=.+`, 'm');
-            if (pattern.test(envContent)) {
-                return provider.label;
-            }
-        }
-    }
-    return 'unknown';
-}

package/dist/services/config/config.js

@@ -1,22 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import { getHiveDir } from './constant.js';
-export async function readConfig() {
-    try {
-        const configPath = path.join(getHiveDir(), 'config.json');
-        const config = (await fs.readJson(configPath));
-        if (!config.providerId || !config.apiKey) {
-            return null;
-        }
-        return config;
-    }
-    catch {
-        return null;
-    }
-}
-export async function writeConfig(config) {
-    const hiveDir = getHiveDir();
-    await fs.ensureDir(hiveDir);
-    const configPath = path.join(hiveDir, 'config.json');
-    await fs.writeJson(configPath, config, { spaces: 2, mode: 0o600 });
-}

package/dist/services/config/constant.js

@@ -1,8 +0,0 @@
-import path from 'path';
-import os from 'os';
-export const HIVE_API_URL = 'https://api.zhive.ai';
-export const HIVE_FRONTEND_URL = 'https://www.zhive.ai';
-export function getHiveDir() {
-    const hiveDir = path.join(os.homedir(), '.hive');
-    return hiveDir;
-}

package/dist/shared/agent/agent-runtime.js

@@ -1,144 +0,0 @@
-import { loadMemory } from '@zhive/sdk';
-import { loadAgentConfig } from '../config/agent.js';
-import { processMegathreadRound, screenMegathreadRound, } from './analysis.js';
-import { getAllTools, getExecuteSkillTool, initializeSkills, } from './tools/index.js';
-import { getMarketClient } from './tools/market/index.js';
-import { extractErrorMessage } from './utils.js';
-import { getModel } from '../config/ai-providers.js';
-export async function initializeAgentRuntime(agentDir) {
-    const config = await loadAgentConfig(agentDir);
-    const memory = await loadMemory(agentDir);
-    const model = await getModel();
-    const skillRegistry = await initializeSkills(agentDir);
-    const tools = getAllTools();
-    const executeSkillTool = getExecuteSkillTool(skillRegistry, model);
-    const allTools = { ...tools, executeSkillTool };
-    const runtime = { config, memory, tools: allTools, skills: skillRegistry, model };
-    return runtime;
-}
-export const fetchPrice = async (projectId, timestamp) => {
-    const client = getMarketClient();
-    const response = await client.getPrice(projectId, timestamp);
-    return response.price ?? undefined;
-};
-export async function fetchRoundPrices(projectId, roundTimestamp, currentTime) {
-    let priceAtStart;
-    let currentPrice;
-    try {
-        const client = getMarketClient();
-        [priceAtStart, currentPrice] = await Promise.all([
-            fetchPrice(projectId, roundTimestamp),
-            fetchPrice(projectId, currentTime ?? new Date().toISOString()),
-        ]);
-    }
-    catch {
-        // Price fetch failed — both stay undefined
-    }
-    return {
-        priceAtStart,
-        currentPrice,
-    };
-}
-const calculateTimeframe = (round) => {
-    const hours = Math.round(round.durationMs / 3_600_000);
-    const timeframe = hours >= 1 ? `${hours}h` : `${Math.round(round.durationMs / 60_000)}m`;
-    return timeframe;
-};
-async function run({ round, runtime, reporter, recentComments, }) {
-    const timeframe = calculateTimeframe(round);
-    reporter.onRoundStart(round, timeframe);
-    // ── Fetch prices ──────────────────────────────
-    const roundStartTimestamp = round.roundId.split('@Z')[0];
-    const { priceAtStart, currentPrice } = await fetchRoundPrices(round.projectId, roundStartTimestamp);
-    if (priceAtStart !== undefined) {
-        reporter.onPriceInfo(priceAtStart, currentPrice);
-    }
-    // ── Quick screen (cheap engage check) ───────
-    const screenResult = await screenMegathreadRound(round.projectId, runtime.config.strategyContent);
-    if (!screenResult.engage) {
-        reporter.onScreenResult?.(round, screenResult);
-        return { skip: true, usage: screenResult.usage, screenResult };
-    }
-    reporter.onResearching(round.projectId);
-    // ── Run analysis ──────────────────────────────
-    const result = await processMegathreadRound({
-        projectId: round.projectId,
-        durationMs: round.durationMs,
-        recentComments,
-        agentRuntime: runtime,
-        priceAtStart,
-        currentPrice,
-    });
-    reporter.onToolsUsed(result.usage.toolNames, result.usage.toolCalls);
-    if (result.skip) {
-        reporter.onSkipped(round, result.usage);
-    }
-    return result;
-}
-export function createMegathreadRoundBatchHandler(getAgent, runtime, reporter) {
-    const handler = async (rounds) => {
-        const agent = getAgent();
-        const promises = [];
-        // report item in order that it is polled to prevent out-of-order write to stdout
-        for (const round of rounds) {
-            promises.push(run({ round, runtime, reporter, recentComments: agent.recentComments }));
-        }
-        const results = await Promise.allSettled(promises);
-        for (let i = 0; i < results.length; i++) {
-            const round = rounds[i];
-            const result = results[i];
-            if (result.status === 'rejected') {
-                const raw = extractErrorMessage(result.reason);
-                const message = raw.length > 120 ? raw.slice(0, 120) + '\u2026' : raw;
-                reporter.onError(round, message);
-                continue;
-            }
-            const data = result.value;
-            if (data.skip) {
-                continue;
-            }
-            // TODO: we can optimized this by create method to commit this in batch in hive sdk.
-            // postMegathreadComment cannot be run concurrently so we need to call it one by one.
-            await agent.postMegathreadComment(round.roundId, {
-                text: data.summary,
-                conviction: data.conviction,
-                tokenId: round.projectId,
-                roundDuration: round.durationMs,
-            });
-            const timeframe = calculateTimeframe(round);
-            reporter.onPosted(round, data.conviction, data.summary, timeframe, data.usage);
-        }
-    };
-    return handler;
-}
-export function createMegathreadRoundHandler(getAgent, runtime, reporter) {
-    const handler = async (round) => {
-        const agent = getAgent();
-        try {
-            const result = await run({
-                round,
-                reporter,
-                recentComments: agent.recentComments,
-                runtime,
-            });
-            if (result.skip) {
-                return;
-            }
-            // ── Post comment ──────────────────────────────
-            await agent.postMegathreadComment(round.roundId, {
-                text: result.summary,
-                conviction: result.conviction,
-                tokenId: round.projectId,
-                roundDuration: round.durationMs,
-            });
-            const timeframe = calculateTimeframe(round);
-            reporter.onPosted(round, result.conviction, result.summary, timeframe, result.usage);
-        }
-        catch (err) {
-            const raw = extractErrorMessage(err);
-            const message = raw.length > 120 ? raw.slice(0, 120) + '\u2026' : raw;
-            reporter.onError(round, message);
-        }
-    };
-    return handler;
-}

package/dist/shared/agent/config.js

@@ -1,75 +0,0 @@
-import * as fs from 'fs/promises';
-import * as path from 'path';
-async function loadMarkdownFile(filename) {
-    const filePath = path.join(process.cwd(), filename);
-    const content = await fs.readFile(filePath, 'utf-8');
-    return content;
-}
-function extractField(content, pattern) {
-    const match = content.match(pattern);
-    if (match === null) {
-        return null;
-    }
-    const value = match[1].trim();
-    return value;
-}
-const VALID_SENTIMENTS = [
-    'very-bullish',
-    'bullish',
-    'neutral',
-    'bearish',
-    'very-bearish',
-];
-const VALID_TIMEFRAMES = ['1h', '4h', '24h'];
-function parseSentiment(raw) {
-    if (raw !== null && VALID_SENTIMENTS.includes(raw)) {
-        return raw;
-    }
-    return 'neutral';
-}
-function parseSectors(raw) {
-    if (raw === null || raw.trim() === '') {
-        return [];
-    }
-    const sectors = raw
-        .split(',')
-        .map((s) => s.trim())
-        .filter((s) => s.length > 0);
-    return sectors;
-}
-function parseTimeframes(raw) {
-    if (raw === null || raw.trim() === '') {
-        return ['1h', '4h', '24h'];
-    }
-    const parsed = raw
-        .split(',')
-        .map((t) => t.trim())
-        .filter((t) => VALID_TIMEFRAMES.includes(t));
-    if (parsed.length === 0) {
-        return ['1h', '4h', '24h'];
-    }
-    return parsed;
-}
-export async function loadAgentConfig() {
-    const soulContent = await loadMarkdownFile('SOUL.md');
-    const strategyContent = await loadMarkdownFile('STRATEGY.md');
-    const name = extractField(soulContent, /^#\s+Agent:\s+(.+)$/m);
-    if (name === null) {
-        throw new Error('Could not parse agent name from SOUL.md. Expected "# Agent: <name>" as the first heading.');
-    }
-    const avatarUrl = extractField(soulContent, /^## Avatar\s*\n+(https?:\/\/.+)$/m);
-    if (avatarUrl === null) {
-        throw new Error('Could not parse avatar URL from SOUL.md. Expected a valid URL under "## Avatar".');
-    }
-    const bioRaw = extractField(soulContent, /^## Bio\s*\n+(.+)$/m);
-    const bio = bioRaw ?? null;
-    const sentimentRaw = extractField(strategyContent, /^-\s+Bias:\s+(.+)$/m);
-    const sectorsRaw = extractField(strategyContent, /^-\s+Sectors:\s+(.+)$/m);
-    const timeframesRaw = extractField(strategyContent, /^-\s+Active timeframes:\s+(.+)$/m);
-    const agentProfile = {
-        sentiment: parseSentiment(sentimentRaw),
-        sectors: parseSectors(sectorsRaw),
-        timeframes: parseTimeframes(timeframesRaw),
-    };
-    return { name, bio, avatarUrl, soulContent, strategyContent, agentProfile };
-}