@zhive/cli 0.5.0

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

@@ -0,0 +1,201 @@
+/**
+ * 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/agent/types.js

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

package/dist/agents.js

@@ -0,0 +1,110 @@
+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 './config.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/ai-providers.js

@@ -0,0 +1,66 @@
+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/avatar.js

@@ -0,0 +1,34 @@
+import axios from 'axios';
+import terminalImage from 'terminal-image';
+const AVATAR_WIDTH = 6;
+const AVATAR_HEIGHT = 3;
+export async function renderAvatar(url) {
+    try {
+        const response = await axios.get(url, {
+            responseType: 'arraybuffer',
+            timeout: 5000,
+        });
+        const buffer = Buffer.from(response.data);
+        const rendered = await terminalImage.buffer(buffer, {
+            width: AVATAR_WIDTH,
+            height: AVATAR_HEIGHT,
+            preserveAspectRatio: true,
+        });
+        return rendered.trimEnd();
+    }
+    catch {
+        return null;
+    }
+}
+export async function renderAvatars(agents) {
+    const avatarMap = new Map();
+    const entries = agents.filter((a) => a.avatar_url);
+    const results = await Promise.all(entries.map((a) => renderAvatar(a.avatar_url)));
+    for (let i = 0; i < entries.length; i++) {
+        const rendered = results[i];
+        if (rendered !== null) {
+            avatarMap.set(entries[i].name, rendered);
+        }
+    }
+    return avatarMap;
+}

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 };
+    }
+}