@zhive/cli 0.6.2 → 0.6.3

package/dist/backtest/default-backtest-data.js

@@ -0,0 +1,200 @@
+/**
+ * Default backtest dataset bundled with the CLI.
+ * Contains 10 threads from Bitcoin, Ethereum, Solana, and Dogecoin.
+ */
+export const DEFAULT_BACKTEST_DATA = {
+    metadata: {
+        id: 'default',
+        name: 'Default Backtest Dataset',
+        created_at: '2026-02-26T00:00:00Z',
+    },
+    threads: [
+        {
+            project_id: 'ethereum',
+            project_name: 'Ethereum',
+            project_symbol: '$ETH',
+            project_categories: [
+                'smart-contract-platform',
+                'layer-1',
+                'ethereum-ecosystem',
+                'proof-of-stake-pos',
+                'world-liberty-financial-portfolio',
+            ],
+            project_description: 'Ethereum is a global, open-source platform for decentralized applications.',
+            text: 'Balaji Srinivasan describes a "Global Privacy Era" as crypto\'s third phase, where the next decade of Web3 focuses on protecting user data and financial sovereignty through strong encryption rather than scalability or speed. Ethereum is highlighted as part of this shift from fully transparent ledgers to more confidential, programmable computation.',
+            timestamp: '2025-12-31T20:00:00Z',
+            price_on_fetch: 2969.01,
+            price_on_eval: 2971.55,
+            citations: [{ title: '2006719380713869499' }, { title: '2006683920881037680' }],
+        },
+        {
+            project_id: 'solana',
+            project_name: 'Solana',
+            project_symbol: '$SOL',
+            project_categories: [
+                'smart-contract-platform',
+                'solana-ecosystem',
+                'layer-1',
+                'alleged-sec-securities',
+                'proof-of-stake-pos',
+                'made-in-usa',
+                'coinlist-launchpad',
+            ],
+            project_description: 'Solana is a high-performance Layer 1 blockchain designed for mass adoption by providing a fast, secure, and low-cost environment for decentralized applications.',
+            text: 'ORE partners with PrivacyCash to launch an official shielded pool on Solana, enabling live private transfers of ORE as a native store-of-value token. Builders also announce Pandora OS v2.0 with stealth transfers and one-time unlinkable addresses on Solana mainnet, signaling major new privacy initiatives on the network.',
+            timestamp: '2026-01-01T01:00:00Z',
+            price_on_fetch: 124.98,
+            price_on_eval: 124.94,
+            citations: [{ title: '2006787547519918102' }, { title: '2006787600028410119' }],
+        },
+        {
+            project_id: 'solana',
+            project_name: 'Solana',
+            project_symbol: '$SOL',
+            project_categories: [
+                'smart-contract-platform',
+                'solana-ecosystem',
+                'layer-1',
+                'alleged-sec-securities',
+                'proof-of-stake-pos',
+                'made-in-usa',
+                'coinlist-launchpad',
+            ],
+            project_description: 'Solana is a high-performance Layer 1 blockchain designed for mass adoption by providing a fast, secure, and low-cost environment for decentralized applications.',
+            text: 'Solana is introducing the c-spl confidential token standard in Q1 2026, enabling encrypted balances and native private transfers. This privacy infrastructure targets institutional adoption by allowing banks and enterprises to conduct confidential onchain transactions, potentially unlocking complex financial instruments for the $16B in Solana stablecoins.',
+            timestamp: '2026-01-01T06:00:00Z',
+            price_on_fetch: 125.06,
+            price_on_eval: 124.43,
+            citations: [{ title: '2006857900543848485' }, { title: '2006862849327435958' }],
+        },
+        {
+            project_id: 'bitcoin',
+            project_name: 'Bitcoin',
+            project_symbol: '$BTC',
+            project_categories: [
+                'smart-contract-platform',
+                'layer-1',
+                'proof-of-work-pow',
+                'bitcoin-ecosystem',
+            ],
+            project_description: "Bitcoin is the world's first decentralized cryptocurrency, created in 2009 by the pseudonymous Satoshi Nakamoto.",
+            text: 'BlackRock transferred 1,134 BTC (~$101.4M) and 7,255 ETH (~$22.1M) to Coinbase/ Coinbase Prime and is described as selling millions in crypto ahead of a key PMI data release. The move coincides with $2.2B in BTC and ETH options expiry, drawing market attention to potential selling pressure on Bitcoin and Ethereum.',
+            timestamp: '2026-01-01T19:00:00Z',
+            price_on_fetch: 88053,
+            price_on_eval: 88266,
+            citations: [{ title: '2007064336708354389' }, { title: '2007066963671924967' }],
+        },
+        {
+            project_id: 'solana',
+            project_name: 'Solana',
+            project_symbol: '$SOL',
+            project_categories: [
+                'smart-contract-platform',
+                'solana-ecosystem',
+                'layer-1',
+                'alleged-sec-securities',
+                'proof-of-stake-pos',
+                'made-in-usa',
+                'coinlist-launchpad',
+            ],
+            project_description: 'Solana is a high-performance Layer 1 blockchain designed for mass adoption by providing a fast, secure, and low-cost environment for decentralized applications.',
+            text: 'Tweets highlight Solana\'s active memecoin culture, with users trading and promoting tokens like $KITKAT, $wif, SolanaWhale, and Epileptic, and tools such as MemeMax and 24/7 "Solana Memecoin Hunting" communities emerging. References to Trump\'s 2025 Solana memecoin and expectations for 2026 ("Make Solana Memecoins great again") show sustained speculative interest and growing infrastructure around Solana memecoin trading.',
+            timestamp: '2026-01-02T01:00:00Z',
+            price_on_fetch: 126.59,
+            price_on_eval: 127.47,
+            citations: [{ title: '2007142205451055298' }, { title: '2007150298876522740' }],
+        },
+        {
+            project_id: 'dogecoin',
+            project_name: 'Dogecoin',
+            project_symbol: '$DOGE',
+            project_categories: [
+                'smart-contract-platform',
+                'meme-token',
+                'dog-themed-coins',
+                'elon-musk-inspired-coins',
+                'proof-of-work-pow',
+                '4chan-themed',
+            ],
+            project_description: 'Dogecoin is a cryptocurrency based on the popular "Doge" Internet meme and features a Shiba Inu on its logo.',
+            text: 'Tweets highlight growing focus on a proposed Bitwise Dogecoin ETF (ticker "BWOW"), emphasizing that it carries high risk, significant volatility, and potential for complete loss of investment, and is not registered under the 1940 Act. Market chatter also notes a January 9 final decision deadline for a Dogecoin ETF and rising Dogecoin price and open interest into 2026.',
+            timestamp: '2026-01-02T07:00:00Z',
+            price_on_fetch: 0.128493,
+            price_on_eval: 0.132792,
+            citations: [{ title: '2007168051129840065' }, { title: '2007118652018196634' }],
+        },
+        {
+            project_id: 'bitcoin',
+            project_name: 'Bitcoin',
+            project_symbol: '$BTC',
+            project_categories: [
+                'smart-contract-platform',
+                'layer-1',
+                'proof-of-work-pow',
+                'bitcoin-ecosystem',
+            ],
+            project_description: "Bitcoin is the world's first decentralized cryptocurrency, created in 2009 by the pseudonymous Satoshi Nakamoto.",
+            text: 'Bitcoin users mark Proof of Keys Day, coinciding with the 17th anniversary of the Genesis Block, by urging holders to withdraw BTC from exchanges into cold storage and verify self-custody. Tweets emphasize the slogan "Not your keys, not your coins" and frame the day as a security checkup for Bitcoin holdings.',
+            timestamp: '2026-01-02T15:00:00Z',
+            price_on_fetch: 89551,
+            price_on_eval: 90310,
+            citations: [{ title: '2007362498282901908' }, { title: '2007373924133417089' }],
+        },
+        {
+            project_id: 'solana',
+            project_name: 'Solana',
+            project_symbol: '$SOL',
+            project_categories: [
+                'smart-contract-platform',
+                'solana-ecosystem',
+                'layer-1',
+                'alleged-sec-securities',
+                'proof-of-stake-pos',
+                'made-in-usa',
+                'coinlist-launchpad',
+            ],
+            project_description: 'Solana is a high-performance Layer 1 blockchain designed for mass adoption by providing a fast, secure, and low-cost environment for decentralized applications.',
+            text: "Circle mints $750M USDC on Solana, marking the first injection of fresh USDC stablecoin liquidity on the network in 2026. This follows $56.25B USDC minted on Solana in 2025, reinforcing Solana's growing role as a major stablecoin and DeFi liquidity hub.",
+            timestamp: '2026-01-02T17:00:00Z',
+            price_on_fetch: 130.55,
+            price_on_eval: 131.54,
+            citations: [{ title: '2007386708032270424' }, { title: '2007383683783963093' }],
+        },
+        {
+            project_id: 'ethereum',
+            project_name: 'Ethereum',
+            project_symbol: '$ETH',
+            project_categories: [
+                'smart-contract-platform',
+                'layer-1',
+                'ethereum-ecosystem',
+                'proof-of-stake-pos',
+                'world-liberty-financial-portfolio',
+            ],
+            project_description: 'Ethereum is a global, open-source platform for decentralized applications.',
+            text: 'Ethereum spot ETFs record $174M in net inflows on Jan. 2, their strongest day since early December, after about $2B in outflows from November through December. Products from Grayscale and BlackRock lead the renewed institutional demand, signaling a shift back to risk-on sentiment for ETH in early 2026.',
+            timestamp: '2026-01-03T02:00:00Z',
+            price_on_fetch: 3129.52,
+            price_on_eval: 3114.78,
+            citations: [{ title: '2007536719055167799' }, { title: '2007492243502858607' }],
+        },
+        {
+            project_id: 'ethereum',
+            project_name: 'Ethereum',
+            project_symbol: '$ETH',
+            project_categories: [
+                'smart-contract-platform',
+                'layer-1',
+                'ethereum-ecosystem',
+                'proof-of-stake-pos',
+                'world-liberty-financial-portfolio',
+            ],
+            project_description: 'Ethereum is a global, open-source platform for decentralized applications.',
+            text: 'Ethereum set a new all-time high with about 2.2-2.23 million transactions processed in a single day around Dec 29, 2025, with several subsequent days near that level. This record onchain activity indicates strong and growing network demand and utility across DeFi, NFTs, and emerging L2 ecosystems amid ongoing upgrades.',
+            timestamp: '2026-01-03T03:00:00Z',
+            price_on_fetch: 3125.17,
+            price_on_eval: 3110.91,
+            citations: [{ title: '2007529962350207036' }, { title: '2007525811075665958' }],
+        },
+    ],
+};

package/dist/backtest/fetch.js

@@ -0,0 +1,41 @@
+import { HiveClient } from '@hive-org/sdk';
+/**
+ * Fetches locked threads from the API and converts them to BacktestData format.
+ * Only threads with price_on_eval are included (guaranteed by the API).
+ */
+export async function fetchBacktestThreads(limit, baseUrl) {
+    try {
+        const client = new HiveClient(baseUrl);
+        const threads = await client.getLockedThreads(limit);
+        const backtestThreads = threads
+            .filter((t) => t.price_on_eval !== undefined && t.price_on_eval !== null)
+            .map((t) => ({
+            project_id: t.project_id,
+            project_name: t.project_name,
+            project_symbol: t.project_symbol,
+            project_categories: t.project_categories,
+            project_description: t.project_description,
+            text: t.text,
+            timestamp: t.timestamp,
+            price_on_fetch: t.price_on_fetch,
+            price_on_eval: t.price_on_eval,
+            citations: t.citations,
+        }));
+        if (backtestThreads.length === 0) {
+            return { success: false, error: 'No resolved threads with price data found' };
+        }
+        const data = {
+            metadata: {
+                id: `api-${Date.now()}`,
+                name: `API fetch (${backtestThreads.length} threads)`,
+                created_at: new Date().toISOString(),
+            },
+            threads: backtestThreads,
+        };
+        return { success: true, data };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { success: false, error: message };
+    }
+}

package/dist/backtest/import.js

@@ -0,0 +1,106 @@
+import fs from 'fs-extra';
+import { z } from 'zod';
+/**
+ * Schema for validating imported JSON file.
+ */
+const citationSchema = z.object({
+    url: z.string().optional(),
+    title: z.string(),
+});
+const importThreadSchema = z.object({
+    project_id: z.string().min(1, 'project_id is required'),
+    project_name: z.string().min(1, 'project_name is required'),
+    text: z.string().min(1, 'text is required'),
+    timestamp: z.string().optional(),
+    price_on_fetch: z.number().positive('price_on_fetch must be positive'),
+    price_on_eval: z.number().positive('price_on_eval must be positive'),
+    project_symbol: z.string().optional(),
+    project_categories: z.array(z.string()).optional(),
+    project_description: z.string().optional(),
+    citations: z.array(citationSchema).optional(),
+});
+const importFileSchema = z.object({
+    name: z.string().optional(),
+    threads: z.array(importThreadSchema).min(1, 'At least one thread is required'),
+});
+/**
+ * Import and validate a backtest JSON file.
+ */
+export async function importBacktestFile(filePath) {
+    // Check if file exists
+    const exists = await fs.pathExists(filePath);
+    if (!exists) {
+        return { success: false, error: `File not found: ${filePath}` };
+    }
+    // Read file content
+    let content;
+    try {
+        content = await fs.readJson(filePath);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { success: false, error: `Failed to parse JSON: ${message}` };
+    }
+    // Validate structure
+    const parseResult = importFileSchema.safeParse(content);
+    if (!parseResult.success) {
+        const issues = parseResult.error.issues
+            .map((issue) => `${issue.path.join('.')}: ${issue.message}`)
+            .join('; ');
+        return { success: false, error: `Validation failed: ${issues}` };
+    }
+    const importData = parseResult.data;
+    // Convert to BacktestThread format
+    const threads = importData.threads.map((t) => convertImportThread(t));
+    return {
+        success: true,
+        name: importData.name,
+        threads,
+    };
+}
+/**
+ * Convert an import thread to a BacktestThread.
+ */
+function convertImportThread(input) {
+    const thread = {
+        project_id: input.project_id,
+        project_name: input.project_name,
+        project_symbol: input.project_symbol,
+        project_categories: input.project_categories,
+        project_description: input.project_description,
+        text: input.text,
+        timestamp: input.timestamp ?? new Date().toISOString(),
+        price_on_fetch: input.price_on_fetch,
+        price_on_eval: input.price_on_eval,
+        citations: input.citations ?? [],
+    };
+    return thread;
+}
+/**
+ * Validate a single thread input (for interactive mode).
+ */
+export function validateThreadInput(input) {
+    const errors = [];
+    if (!input.project_id || input.project_id.trim() === '') {
+        errors.push('project_id is required');
+    }
+    if (!input.project_name || input.project_name.trim() === '') {
+        errors.push('project_name is required');
+    }
+    if (!input.text || input.text.trim() === '') {
+        errors.push('text is required');
+    }
+    if (typeof input.price_on_fetch !== 'number' || input.price_on_fetch <= 0) {
+        errors.push('price_on_fetch must be a positive number');
+    }
+    if (typeof input.price_on_eval !== 'number' || input.price_on_eval <= 0) {
+        errors.push('price_on_eval must be a positive number');
+    }
+    return errors;
+}
+/**
+ * Create a BacktestThread from validated input.
+ */
+export function createThread(input) {
+    return convertImportThread(input);
+}

package/dist/backtest/index.js

@@ -0,0 +1,10 @@
+// Import
+export { importBacktestFile, validateThreadInput, createThread } from './import.js';
+// Storage
+export { DEFAULT_BACKTEST_ID, loadDefaultBacktest } from './storage.js';
+// Fetch
+export { fetchBacktestThreads } from './fetch.js';
+// Runner
+export { runBacktest } from './runner.js';
+// Results
+export { formatConviction, formatPercentage, getDirectionIndicator, formatThreadResult, formatSummary, getAccuracyGrade, buildTextReport, } from './results.js';

package/dist/backtest/results.js

@@ -0,0 +1,113 @@
+/**
+ * Format a number with sign for display.
+ */
+export function formatConviction(value) {
+    const sign = value >= 0 ? '+' : '';
+    const formatted = `${sign}${value.toFixed(2)}%`;
+    return formatted;
+}
+/**
+ * Format a percentage for display.
+ */
+export function formatPercentage(value) {
+    const formatted = `${value.toFixed(1)}%`;
+    return formatted;
+}
+/**
+ * Get direction indicator.
+ */
+export function getDirectionIndicator(conviction) {
+    if (conviction > 0) {
+        return 'bullish';
+    }
+    if (conviction < 0) {
+        return 'bearish';
+    }
+    return 'neutral';
+}
+export function formatThreadResult(result) {
+    if (result.skipped) {
+        return {
+            index: result.thread_index + 1,
+            projectName: result.project_name,
+            predicted: 'SKIP',
+            actual: formatConviction(result.actual_price_change_percent),
+            direction: 'skipped',
+            error: '-',
+            summary: '(skipped)',
+            thread_text: result.thread_text,
+        };
+    }
+    const directionLabel = result.direction_correct ? 'correct' : 'incorrect';
+    return {
+        index: result.thread_index + 1,
+        projectName: result.project_name,
+        predicted: formatConviction(result.predicted_conviction),
+        actual: formatConviction(result.actual_price_change_percent),
+        direction: directionLabel,
+        error: result.absolute_error !== null ? result.absolute_error.toFixed(2) : '-',
+        summary: result.predicted_summary.slice(0, 200) + (result.predicted_summary.length > 200 ? '...' : ''),
+        thread_text: result.thread_text.slice(0, 100) + (result.thread_text.length > 100 ? '...' : ''),
+    };
+}
+export function formatSummary(result) {
+    return {
+        agentName: result.agent_name,
+        backtestId: result.backtest_id,
+        totalThreads: result.total_threads,
+        threadsPredicted: result.threads_predicted,
+        threadsSkipped: result.threads_skipped,
+        directionAccuracy: formatPercentage(result.direction_accuracy),
+        meanAbsoluteError: result.mean_absolute_error.toFixed(2),
+        runAt: new Date(result.run_at).toLocaleString(),
+    };
+}
+/**
+ * Get accuracy grade based on direction accuracy percentage.
+ */
+export function getAccuracyGrade(accuracy) {
+    if (accuracy >= 70) {
+        return { grade: 'A', color: 'green' };
+    }
+    if (accuracy >= 60) {
+        return { grade: 'B', color: 'green' };
+    }
+    if (accuracy >= 50) {
+        return { grade: 'C', color: 'honey' };
+    }
+    if (accuracy >= 40) {
+        return { grade: 'D', color: 'red' };
+    }
+    return { grade: 'F', color: 'red' };
+}
+/**
+ * Build a text report of the backtest results.
+ */
+export function buildTextReport(result) {
+    const lines = [];
+    const summary = formatSummary(result);
+    lines.push(`Backtest Results: ${summary.backtestId}`);
+    lines.push(`Agent: ${summary.agentName}`);
+    lines.push(`Run at: ${summary.runAt}`);
+    lines.push('');
+    lines.push('--- Summary ---');
+    lines.push(`Total threads: ${summary.totalThreads}`);
+    lines.push(`Predictions made: ${summary.threadsPredicted}`);
+    lines.push(`Skipped: ${summary.threadsSkipped}`);
+    lines.push(`Direction accuracy: ${summary.directionAccuracy}`);
+    lines.push(`Mean absolute error: ${summary.meanAbsoluteError}`);
+    lines.push('');
+    lines.push('--- Per-Thread Results ---');
+    for (const threadResult of result.thread_results) {
+        const formatted = formatThreadResult(threadResult);
+        const directionSymbol = formatted.direction === 'correct'
+            ? '[OK]'
+            : formatted.direction === 'skipped'
+                ? '[--]'
+                : '[XX]';
+        lines.push(`#${formatted.index} ${formatted.projectName}: Predicted ${formatted.predicted}, Actual ${formatted.actual} ${directionSymbol}`);
+        lines.push(`\tThread: ${formatted.thread_text}`);
+        lines.push(`\tSummary: ${formatted.summary}`);
+    }
+    return lines.join('\n');
+}

package/dist/backtest/runner.js

@@ -0,0 +1,134 @@
+import { processSignalAndSummarize } from '../agent/analysis.js';
+import { loadMemory } from '@hive-org/sdk';
+import { getAllTools, initializeSkills, getSkillMetadataList, getReadSkillTool, } from '../agent/tools/index.js';
+/**
+ * Run a backtest against an agent configuration.
+ */
+export async function runBacktest(backtest, config, callbacks) {
+    const { agentPath, soulContent, strategyContent, agentName } = config;
+    const threads = backtest.threads;
+    const results = [];
+    // Load agent tools and skills
+    const baseTools = getAllTools();
+    const skillRegistry = await initializeSkills(agentPath);
+    const tools = { ...baseTools };
+    if (skillRegistry.size > 0) {
+        tools['readSkill'] = getReadSkillTool(skillRegistry);
+    }
+    const availableSkills = getSkillMetadataList(skillRegistry) || undefined;
+    // Load memory once (static for backtest)
+    const memory = await loadMemory();
+    for (let i = 0; i < threads.length; i++) {
+        const thread = threads[i];
+        callbacks?.onThreadStart?.(i, threads.length, thread);
+        // Convert BacktestThread to ThreadDto format (without price_on_eval)
+        const threadDto = convertToThreadDto(thread, i);
+        // Run analysis
+        const analysisResult = await processSignalAndSummarize(threadDto, [], // No recent comments in backtest
+        memory, soulContent, strategyContent, tools, availableSkills);
+        // Calculate actual price change
+        const actualPriceChangePercent = calculatePriceChange(thread.price_on_fetch, thread.price_on_eval);
+        // Build result
+        const result = buildThreadResult(i, thread, analysisResult, actualPriceChangePercent);
+        results.push(result);
+        callbacks?.onThreadComplete?.(i, result);
+    }
+    // Calculate summary statistics
+    const runResult = buildRunResult(backtest.metadata.id, agentName, results);
+    return runResult;
+}
+/**
+ * Convert a BacktestThread to ThreadDto format for the agent.
+ * Strips price_on_eval since the agent shouldn't see the outcome.
+ */
+function convertToThreadDto(thread, index) {
+    const dto = {
+        id: `backtest-thread-${index}`,
+        pollen_id: `backtest-pollen-${index}`,
+        project_id: thread.project_id,
+        project_name: thread.project_name,
+        project_categories: thread.project_categories,
+        project_description: thread.project_description,
+        project_symbol: thread.project_symbol,
+        price_on_eval: thread.price_on_eval,
+        text: thread.text,
+        timestamp: thread.timestamp,
+        locked: false,
+        created_at: thread.timestamp,
+        updated_at: thread.timestamp,
+        price_on_fetch: thread.price_on_fetch,
+        // Intentionally omitting price_on_eval - agent should not see outcome
+        citations: thread.citations,
+    };
+    return dto;
+}
+/**
+ * Calculate percentage price change.
+ */
+function calculatePriceChange(priceOnFetch, priceOnEval) {
+    const change = ((priceOnEval - priceOnFetch) / priceOnFetch) * 100;
+    return change;
+}
+/**
+ * Build a thread result from analysis output.
+ */
+function buildThreadResult(index, thread, analysis, actualPriceChangePercent) {
+    if (analysis.skip) {
+        return {
+            thread_index: index,
+            project_id: thread.project_id,
+            project_name: thread.project_name,
+            thread_text: thread.text,
+            predicted_conviction: 0,
+            predicted_summary: '',
+            skipped: true,
+            actual_price_change_percent: actualPriceChangePercent,
+            direction_correct: null,
+            absolute_error: null,
+        };
+    }
+    // Determine direction correctness
+    const predictedDirection = Math.sign(analysis.conviction);
+    const actualDirection = Math.sign(actualPriceChangePercent);
+    const directionCorrect = predictedDirection === actualDirection;
+    // Calculate absolute error
+    const absoluteError = Math.abs(analysis.conviction - actualPriceChangePercent);
+    return {
+        thread_index: index,
+        project_id: thread.project_id,
+        project_name: thread.project_name,
+        thread_text: thread.text,
+        predicted_conviction: analysis.conviction,
+        predicted_summary: analysis.summary,
+        skipped: false,
+        actual_price_change_percent: actualPriceChangePercent,
+        direction_correct: directionCorrect,
+        absolute_error: absoluteError,
+    };
+}
+/**
+ * Build the final run result with summary statistics.
+ */
+function buildRunResult(backtestId, agentName, results) {
+    const totalThreads = results.length;
+    const predictedResults = results.filter((r) => !r.skipped);
+    const threadsPredicted = predictedResults.length;
+    const threadsSkipped = totalThreads - threadsPredicted;
+    // Calculate direction accuracy
+    const correctDirections = predictedResults.filter((r) => r.direction_correct === true).length;
+    const directionAccuracy = threadsPredicted > 0 ? (correctDirections / threadsPredicted) * 100 : 0;
+    // Calculate mean absolute error
+    const totalError = predictedResults.reduce((sum, r) => sum + (r.absolute_error ?? 0), 0);
+    const meanAbsoluteError = threadsPredicted > 0 ? totalError / threadsPredicted : 0;
+    return {
+        backtest_id: backtestId,
+        agent_name: agentName,
+        run_at: new Date().toISOString(),
+        thread_results: results,
+        total_threads: totalThreads,
+        threads_predicted: threadsPredicted,
+        threads_skipped: threadsSkipped,
+        direction_accuracy: directionAccuracy,
+        mean_absolute_error: meanAbsoluteError,
+    };
+}

package/dist/backtest/storage.js

@@ -0,0 +1,11 @@
+import { DEFAULT_BACKTEST_DATA } from './default-backtest-data.js';
+/**
+ * ID for the bundled default backtest dataset.
+ */
+export const DEFAULT_BACKTEST_ID = 'default';
+/**
+ * Load the bundled default backtest dataset.
+ */
+export function loadDefaultBacktest() {
+    return DEFAULT_BACKTEST_DATA;
+}

package/dist/backtest/types.js

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

package/dist/commands/install.js

@@ -0,0 +1,50 @@
+import chalk from 'chalk';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const execAsync = promisify(exec);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export async function install(targetDir = process.cwd(), options = {}) {
+    const packageJsonPath = path.join(targetDir, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        throw new Error('No package.json found. Please run this command in the root of your project.');
+    }
+    console.log(chalk.blue('Installing Hive bootstrap...'));
+    const dir = path.join(targetDir, 'hive');
+    await fs.ensureDir(dir);
+    const templatesDir = path.resolve(__dirname, '../../templates/hive');
+    if (!fs.existsSync(templatesDir)) {
+        throw new Error(`Templates directory not found at ${templatesDir}`);
+    }
+    await fs.copy(templatesDir, dir);
+    console.log(chalk.green('\u2713 Bootstrap code copied to hive/'));
+    // Hive dependencies: @hive-org/sdk (and dotenv if missing)
+    console.log(chalk.blue('Installing dependencies...'));
+    try {
+        const packageJson = await fs.readJson(packageJsonPath);
+        const deps = packageJson.dependencies ?? {};
+        const hasSdk = deps['@hive-org/sdk'];
+        const hasDotenv = deps['dotenv'];
+        const toInstall = [];
+        if (!hasSdk) {
+            toInstall.push('@hive-org/sdk@*');
+        }
+        if (!hasDotenv) {
+            toInstall.push('dotenv');
+        }
+        if (toInstall.length > 0) {
+            await execAsync(`pnpm add ${toInstall.join(' ')}`, { cwd: targetDir });
+            console.log(chalk.green('\u2713 Dependencies installed'));
+        }
+        else {
+            console.log(chalk.gray('Dependencies already installed.'));
+        }
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        console.error(chalk.yellow("Warning: Failed to install dependencies automatically. Please run 'pnpm add @hive-org/sdk dotenv' manually."));
+    }
+    console.log(chalk.green('\nHive installed successfully!'));
+}