@zhive/cli 0.6.2 → 0.6.3

package/dist/{services/agent/prompts → agent}/prompt.js

@@ -1,4 +1,3 @@
-// ─── Shared Types ─────────────────────────────────
 function humanDuration(ms) {
     const hours = ms / 3_600_000;
     if (hours >= 24) {
@@ -80,8 +79,32 @@ Only skip if this project is outside the expertise list defined in your STRATEGY
 - Major protocol upgrade, big institutional entry, trend reversal → ±6.0 to ±12.0
 - Black swan, regulatory bombshell, massive exploit → ±12.0 to ±25.0
 
-IMPORTANT: Vary your conviction numbers. Do NOT reuse the same number across rounds. Each round has different context — your conviction should reflect that.`;
-    // ── Prompt (dynamic per signal — changes every call) ──
+IMPORTANT: Vary your conviction numbers. Do NOT reuse the same number across rounds. Each round has different context — your conviction should reflect that.
+
+## The prediction game
+
+This is a price prediction game for megathread rounds. Each round has a project, a duration, and a round-start baseline price. Your conviction = predicted TOTAL % change from the round-start price by end of the round.
+
+Key inputs for each round:
+- **Round-start price** — your scoring baseline. You predict % change from this.
+- **Current price** — how much has already moved from baseline. Your prediction should account for movement that already happened.
+- **Time remaining** — less time = less room for further movement. Late in the round, anchor your prediction close to where the price already is relative to baseline.
+- **Catalysts & momentum** — news, sentiment shifts, or technical setups that could move price in the remaining window.
+
+Scoring:
+- Correct direction + close to actual = max honey (up to +100)
+- Correct direction but far off = less honey
+- Wrong direction = -25 honey penalty
+- Skipping = no penalty, no reward
+- Earlier predictions earn dramatically more honey (cubic time decay)
+- Predicting late earns almost nothing even if correct
+
+## Using tools
+
+If you have tools available, use them to research current price, OHLC data, technical indicators, mindshare data, and social sentiment. When you use a tool, drop a specific number or fact from the result into your post. Not a data dump, just one concrete detail woven into your take. Examples: "mindshare down 40% this week and nobody cares", "rsi at 28 after that flush", "volume 3x'd overnight". If a tool returns bad data (NaN, null, zero, empty, errors), silently ignore it. Never mention NaN, missing data, "no data", or failed lookups in your post. Just use the tools that gave you something real, or post from instinct if none did.
+
+If your tools return nothing or you have limited data, just run with it. You know crypto. You know this space. Use your general knowledge, recent market conditions, and your trading instincts to form a directional lean. An imperfect prediction beats no prediction. Do NOT mention that you lack data. Never say "no data", "limited data", "couldn't find", "no tools", or anything that reveals you're operating without information. Just post with conviction like you always do. The only exception: if you're deliberately bluffing in character, that's a personality move, not a disclaimer.`;
+    // ── Prompt (dynamic per round — changes every call) ──
     let recentPostsSection = '';
     if (recentPosts && recentPosts.length > 0) {
         const listed = recentPosts.map((p) => `- "${p}"`).join('\n');
@@ -107,7 +130,6 @@ ${memory}
     const roundStartMs = Math.floor(now / durationMs) * durationMs;
     const timeRemainingMs = Math.max(0, roundStartMs + durationMs - now);
     const timeRemaining = humanDuration(timeRemainingMs);
-    const lateInRound = timeRemainingMs < durationMs * 0.25;
     const nowIso = new Date().toISOString();
     // ── Price context lines ──
     const hasBothPrices = priceAtStart !== undefined && currentPrice !== undefined;
@@ -119,33 +141,11 @@ ${memory}
     }
     let priceContextLines = '';
     if (hasBothPrices) {
-        priceContextLines = `- Round-start price: $${priceAtStart} (baseline for scoring)
+        priceContextLines = `- Round-start price: $${priceAtStart} (scoring baseline)
 - Current price: $${currentPrice} (${currentChangeStr} from round start)`;
     }
     else if (priceAtStart !== undefined) {
-        priceContextLines = `- Round-start price: $${priceAtStart} (baseline for scoring)`;
-    }
-    // ── What-matters block ──
-    let whatMattersBlock;
-    if (hasBothPrices) {
-        whatMattersBlock = `What matters:
-- **Round-start price** ($${priceAtStart}) — your baseline. Scoring measures % change from here.
-- **Current price** ($${currentPrice}, ${currentChangeStr} from baseline) — price has already moved this much. Your prediction should be close to this unless you expect further movement.
-- **Time remaining** (~${timeRemaining}) — less time = less room for further movement from current price.${lateInRound ? ' Almost no time left — anchor your prediction to the current change (' + currentChangeStr + ').' : ''}
-- **Catalysts & momentum** — news, sentiment shifts, or technical setups that could move price in the remaining window.`;
-    }
-    else if (priceAtStart !== undefined) {
-        whatMattersBlock = `What matters:
-- **Round-start price** ($${priceAtStart}) — your baseline. Scoring measures % change from here.
-- **Current price** — check with tools. Compare to $${priceAtStart} to see how much has already moved.
-- **Time remaining** (~${timeRemaining}) — less time = less room for further movement from current price.${lateInRound ? ' Almost no time left — anchor your prediction to where the price is NOW relative to $' + priceAtStart + '.' : ''}
-- **Catalysts & momentum** — news, sentiment shifts, or technical setups that could move price in the remaining window.`;
-    }
-    else {
-        whatMattersBlock = `What matters:
-- **Current price** — check with tools. This is the most important input to your prediction.
-- **Time remaining** (~${timeRemaining}) — the runway left for price movement. Less time = smaller realistic moves. Scale your conviction accordingly.${lateInRound ? ' Round is almost over — keep your conviction small.' : ''}
-- **Catalysts & momentum** — news, sentiment shifts, or technical setups that could move price in the remaining window.`;
+        priceContextLines = `- Round-start price: $${priceAtStart} (scoring baseline)`;
     }
     // ── Scoring & conviction lines ──
     let scoringLine;
@@ -173,36 +173,11 @@ ${memory}
 - Round duration: ${timeframe}
 - Time remaining: ~${timeRemaining}
 ${priceContextLines ? priceContextLines + '\n' : ''}
-## The game
-
-This is a price prediction game. You're predicting the % price change for c/${projectId} over this ${timeframe} round.
-
-${whatMattersBlock}
-
 ## Your task
 
-This is a **megathread round** for c/${projectId}. Form your price conviction for where c/${projectId} will be relative to ${taskBaseline} by end of this ${timeframe} round (~${timeRemaining} left).
-
-**If you have tools available**, use them to research:
-- Check current price, OHLC data, and technical indicators (RSI, MACD, volume, etc.)
-- Look at mindshare data and social sentiment
-- Use any available skills that help you gather market context
-
-**When you use a tool, drop a specific number or fact from the result into your post.** Not a data dump, just one concrete detail woven into your take. Examples: "mindshare down 40% this week and nobody cares", "rsi at 28 after that flush", "volume 3x'd overnight". If a tool returns bad data (NaN, null, zero, empty, errors), silently ignore it. Never mention NaN, missing data, "no data", or failed lookups in your post. Just use the tools that gave you something real, or post from instinct if none did.
-
-**If your tools return nothing or you have limited data**, just run with it. You know crypto. You know this space. Use your general knowledge of c/${projectId}, recent market conditions, and your trading instincts to form a directional lean. An imperfect prediction beats no prediction. Do NOT mention that you lack data, have no data, or couldn't find information. Never say "no data", "limited data", "couldn't find", "no tools", or anything that reveals you're operating without information. Just post with conviction like you always do. The only exception: if you're deliberately bluffing in character — pretending to reference data and then pulling the rug — that's a personality move, not a disclaimer.
-
-Form a thesis based on what you find or what you know.${thesisHint}
-
-## How scoring works
+This is a **megathread round** for c/${projectId}. Form your price conviction for where c/${projectId} will be relative to ${taskBaseline} by end of this ${timeframe} round (~${timeRemaining} left).${thesisHint}
 
 ${scoringLine}
-- Correct direction + close to actual = max honey (up to +100)
-- Correct direction but far off = less honey
-- Wrong direction = -25 honey penalty
-- Skipping = no penalty, no reward
-- Earlier predictions earn dramatically more honey (cubic time decay)
-- Predicting late earns almost nothing even if correct
 ${recentPostsSection}${memorySection}
 Give your take in character and a conviction number.
 ${convictionLine}`;
@@ -301,7 +276,28 @@ Set skip to true and set summary and conviction to null. Real people don't comme
 - Major protocol upgrade, big institutional entry, trend reversal → ±6.0 to ±12.0
 - 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.`;
+IMPORTANT: Vary your conviction numbers. Do NOT reuse the same number across signals. Each signal has different strength — your conviction should reflect that.
+
+## The prediction game
+
+This is a price prediction game. Each signal has a snapshot price captured at signal time and a 3-hour evaluation window. Your conviction = predicted % change from the snapshot price by evaluation time.
+
+Key inputs for each signal:
+- **Snapshot price** — your scoring baseline. You predict % change from this.
+- **Current price** — check with tools to see how much has already moved since the signal.
+- **Time left** — less time = less room for further movement. Late in the window, anchor your prediction close to where the price already is relative to the snapshot.
+
+Scoring:
+- Correct direction + close to actual = max honey (up to +100)
+- Correct direction but far off = less honey
+- Wrong direction = -25 honey penalty
+- Skipping = no penalty, no reward
+- Earlier predictions earn dramatically more honey (cubic time decay)
+- Predicting late earns almost nothing even if correct
+
+## Using tools
+
+If you have tools available, use them to check price action, technicals, or mindshare before forming your take. When you use a tool, drop a specific number or fact from the result into your post. Not a data dump, just one concrete detail woven into your take. Examples: "mindshare down 40% this week and nobody cares", "rsi at 28 after that flush", "volume 3x'd overnight". If a tool returns bad data (NaN, null, zero, empty, errors), silently ignore it. Never mention NaN, missing data, "no data", or failed lookups in your post. Just use the tools that gave you something real, or post from instinct if none did.`;
     // ── Prompt (dynamic per signal — changes every call) ──
     let citationsSection = '';
     if (citations.length > 0) {
@@ -338,42 +334,20 @@ ${memory}
     const signalTimeMs = new Date(timestamp).getTime();
     const timeRemainingMs = Math.max(0, signalTimeMs + EVAL_WINDOW_MS - Date.now());
     const timeRemaining = humanDuration(timeRemainingMs);
-    const lateWindow = timeRemainingMs < 45 * 60 * 1000;
     const userPrompt = `## Context
 
 - Project: c/${projectId}
 - Current date: ${currentDate}
 - Signal time: ${timestamp}
-- Snapshot price: $${priceOnFetch} (captured at signal time)
+- Snapshot price: $${priceOnFetch} (scoring baseline)
 - Time left: ~${timeRemaining}
-${citationsSection}
-## The game
-
-This is a price prediction game. Your conviction = predicted % change from the snapshot price ($${priceOnFetch}), evaluated 3 hours after signal time.
-
-What matters:
-- **Snapshot price** ($${priceOnFetch}) — your baseline. Scoring measures % change from here.
-- **Current price** — how much has already moved since the signal. Check with tools.
-- **Time left** (~${timeRemaining}) — less time = less room for further movement from current price.${lateWindow ? ' Almost no time left — anchor your prediction to where the price is NOW relative to the snapshot.' : ''}
-
-## How scoring works
-
-You are predicting the % price change from the snapshot price ($${priceOnFetch}) over 3 hours from signal time.
-- Correct direction + close to actual = max honey (up to +100)
-- Correct direction but far off = less honey
-- Wrong direction = -25 honey penalty
-- Skipping = no penalty, no reward
-- Earlier predictions earn dramatically more honey (cubic time decay)
-- Predicting late earns almost nothing even if correct
-${recentPostsSection}${memorySection}
+${citationsSection}${recentPostsSection}${memorySection}
 Signal/event to react to:
 """
 ${threadText}
 """
 
-**If you have tools available**, use them to check price action, technicals, or mindshare for c/${projectId} before forming your take. When you use a tool, drop a specific number or fact from the result into your post. Not a data dump, just one concrete detail woven into your take. Examples: "mindshare down 40% this week and nobody cares", "rsi at 28 after that flush", "volume 3x'd overnight". If the tool returned nothing useful, ignore it and post from instinct.
-
 Give your take in character and a conviction number.
-Conviction: predicted % price change from $${priceOnFetch} by evaluation time (~${timeRemaining} left), up to one decimal. Positive = up, negative = down. 0 = neutral.`;
+Conviction: predicted % price change from $${priceOnFetch} by evaluation time (~${timeRemaining} left), up to one decimal. Positive = up, negative = down.`;
     return { system, prompt: userPrompt };
 }

package/dist/agent/run-headless.js

@@ -0,0 +1,189 @@
+import { HiveAgent } from '@hive-org/sdk';
+import { loadMemory } from '@hive-org/sdk';
+import { loadAgentConfig } from './config.js';
+import { resolveModelInfo } from './model.js';
+import { HIVE_FRONTEND_URL } from '../config.js';
+import { processSignalAndSummarize, processMegathreadRound, } from './analysis.js';
+import { initializeSkills, getAllTools, getReadSkillTool, getSkillMetadataList, } from './tools/index.js';
+import { getMarketClient } from './tools/market/index.js';
+function formatTokens(n) {
+    const formatted = n.toLocaleString('en-US');
+    return formatted;
+}
+function formatUsageLine(usage) {
+    const cacheInfo = usage.cacheReadTokens > 0
+        ? ` (${formatTokens(usage.cacheReadTokens)} cached)`
+        : usage.cacheWriteTokens > 0
+            ? ` (${formatTokens(usage.cacheWriteTokens)} cache write)`
+            : '';
+    const toolInfo = usage.toolCalls > 0 ? ` \u00b7 tools: ${usage.toolNames.join(', ')}` : '';
+    const line = `  tokens: ${formatTokens(usage.inputTokens)} in${cacheInfo} \u00b7 ${formatTokens(usage.outputTokens)} out${toolInfo}`;
+    return line;
+}
+function logToolResults(results) {
+    for (const tr of results) {
+        const preview = tr.result.length > 200 ? tr.result.slice(0, 200) + '\u2026' : tr.result;
+        console.log(`    ${tr.toolName}: ${preview}`);
+    }
+}
+function timestamp() {
+    const now = new Date();
+    const hours = String(now.getHours()).padStart(2, '0');
+    const minutes = String(now.getMinutes()).padStart(2, '0');
+    const seconds = String(now.getSeconds()).padStart(2, '0');
+    const ts = `${hours}:${minutes}:${seconds}`;
+    return ts;
+}
+export async function runHeadless() {
+    const { HIVE_API_URL } = await import('../config.js');
+    const config = await loadAgentConfig();
+    const initialMemory = await loadMemory();
+    let memoryRef = initialMemory;
+    const soulContent = config.soulContent;
+    const strategyContent = config.strategyContent;
+    const skillRegistry = await initializeSkills(process.cwd());
+    const allTools = getAllTools();
+    const readSkillTool = getReadSkillTool(skillRegistry);
+    const skillTools = { ...allTools, readSkill: readSkillTool };
+    const skillMetadata = getSkillMetadataList(skillRegistry);
+    let predictionCount = 0;
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalToolCalls = 0;
+    const agent = new HiveAgent(HIVE_API_URL, {
+        name: config.name,
+        avatarUrl: config.avatarUrl,
+        bio: config.bio ?? undefined,
+        agentProfile: config.agentProfile,
+        pollIntervalMs: 30_000,
+        pollLimit: 5,
+        onPollEmpty: () => {
+            console.log(`[${timestamp()}] idle — no new threads`);
+        },
+        onStop: async () => { },
+        onNewThread: async (thread) => {
+            try {
+                const threadPreview = thread.text.length > 80 ? thread.text.slice(0, 80) + '\u2026' : thread.text;
+                console.log(`[${timestamp()}] signal c/${thread.project_id}`);
+                console.log(`  "${threadPreview}"`);
+                console.log(`[${timestamp()}] analyzing c/${thread.project_id}...`);
+                const result = await processSignalAndSummarize(thread, agent.recentComments, memoryRef, soulContent, strategyContent, skillTools, skillMetadata);
+                totalInputTokens += result.usage.inputTokens;
+                totalOutputTokens += result.usage.outputTokens;
+                totalToolCalls += result.usage.toolCalls;
+                if (result.usage.toolCalls > 0) {
+                    const toolNames = result.usage.toolNames.join(', ');
+                    console.log(`  tools: ${toolNames} (${result.usage.toolCalls} calls)`);
+                    // logToolResults(result.usage.toolResults);
+                }
+                else {
+                    console.log(`  tools: none`);
+                }
+                if (result.skip) {
+                    console.log(`[${timestamp()}] skipped c/${thread.project_id} — outside expertise`);
+                    console.log(formatUsageLine(result.usage));
+                    return;
+                }
+                await agent.postComment(thread.id, {
+                    thread_id: thread.id,
+                    text: result.summary,
+                    conviction: result.conviction,
+                }, thread.text);
+                predictionCount += 1;
+                const sign = result.conviction >= 0 ? '+' : '';
+                const threadUrl = `${HIVE_FRONTEND_URL}/c/${thread.project_id}/${thread.id}`;
+                console.log(`[${timestamp()}] signal c/${thread.project_id} [${sign}${result.conviction}%] "${result.summary}" (${predictionCount} total)`);
+                console.log(formatUsageLine(result.usage));
+                console.log(`  ${threadUrl}`);
+            }
+            catch (err) {
+                const raw = err instanceof Error ? err.message : String(err);
+                const message = raw.length > 120 ? raw.slice(0, 120) + '\u2026' : raw;
+                console.error(`[${timestamp()}] error c/${thread.project_id}: ${message}`);
+            }
+        },
+        onNewMegathreadRound: async (round) => {
+            try {
+                const hours = Math.round(round.durationMs / 3_600_000);
+                const timeframe = hours >= 1 ? `${hours}h` : `${Math.round(round.durationMs / 60_000)}m`;
+                console.log(`[${timestamp()}] megathread c/${round.projectId} · ${timeframe} round`);
+                let priceAtStart;
+                let currentPrice;
+                try {
+                    const client = getMarketClient();
+                    const roundStartTimestamp = round.roundId.split('@Z')[0];
+                    const [startResponse, nowResponse] = await Promise.all([
+                        client.getPrice(round.projectId, roundStartTimestamp),
+                        client.getPrice(round.projectId, new Date().toISOString()),
+                    ]);
+                    if (startResponse.price !== null) {
+                        priceAtStart = startResponse.price;
+                    }
+                    if (nowResponse.price !== null) {
+                        currentPrice = nowResponse.price;
+                    }
+                }
+                catch {
+                    // Price fetch failed — both stay undefined, prompt falls back to current behavior
+                }
+                if (priceAtStart !== undefined && currentPrice !== undefined) {
+                    const changePercent = ((currentPrice - priceAtStart) / priceAtStart) * 100;
+                    const sign = changePercent >= 0 ? '+' : '';
+                    console.log(`[${timestamp()}] round-start: $${priceAtStart} → current: $${currentPrice} (${sign}${changePercent.toFixed(2)}%)`);
+                }
+                else if (priceAtStart !== undefined) {
+                    console.log(`[${timestamp()}] round-start price: $${priceAtStart}`);
+                }
+                console.log(`[${timestamp()}] researching c/${round.projectId}...`);
+                const result = await processMegathreadRound(round.projectId, round.durationMs, agent.recentComments, memoryRef, soulContent, strategyContent, skillTools, skillMetadata, priceAtStart, currentPrice);
+                totalInputTokens += result.usage.inputTokens;
+                totalOutputTokens += result.usage.outputTokens;
+                totalToolCalls += result.usage.toolCalls;
+                if (result.usage.toolCalls > 0) {
+                    const toolNames = result.usage.toolNames.join(', ');
+                    console.log(`  tools: ${toolNames} (${result.usage.toolCalls} calls)`);
+                    // logToolResults(result.usage.toolResults);
+                }
+                else {
+                    console.log(`  tools: none`);
+                }
+                if (result.skip) {
+                    console.log(`[${timestamp()}] skipped c/${round.projectId} — outside expertise`);
+                    console.log(formatUsageLine(result.usage));
+                    return;
+                }
+                await agent.postMegathreadComment(round.roundId, {
+                    text: result.summary,
+                    conviction: result.conviction,
+                    tokenId: round.projectId,
+                    roundDuration: round.durationMs,
+                });
+                predictionCount += 1;
+                const sign = result.conviction >= 0 ? '+' : '';
+                const megathreadUrl = `${HIVE_FRONTEND_URL}/c/${round.projectId}/megathread/${timeframe}`;
+                console.log(`[${timestamp()}] megathread c/${round.projectId} [${sign}${result.conviction}%] "${result.summary}" (${predictionCount} total)`);
+                console.log(formatUsageLine(result.usage));
+                console.log(`  ${megathreadUrl}`);
+            }
+            catch (err) {
+                const raw = err instanceof Error ? err.message : String(err);
+                const message = raw.length > 120 ? raw.slice(0, 120) + '\u2026' : raw;
+                console.error(`[${timestamp()}] error c/${round.projectId}: ${message}`);
+            }
+        },
+    });
+    const shutdown = async () => {
+        console.log(`[${config.name}] shutting down...`);
+        const sessionTotal = totalInputTokens + totalOutputTokens;
+        const toolInfo = totalToolCalls > 0 ? ` \u00b7 ${totalToolCalls} tool calls` : '';
+        console.log(`[${config.name}] session tokens: ${formatTokens(totalInputTokens)} in \u00b7 ${formatTokens(totalOutputTokens)} out (${formatTokens(sessionTotal)} total)${toolInfo}`);
+        await agent.stop();
+        process.exit(0);
+    };
+    process.on('SIGINT', () => void shutdown());
+    process.on('SIGTERM', () => void shutdown());
+    await agent.start();
+    const modelInfoResult = resolveModelInfo();
+    console.log(`[${config.name}] ${modelInfoResult.modelId} \u00d7 zData`);
+    console.log(`[${config.name}] agent online \u2014 "${config.bio ?? ''}"`);
+}

package/dist/agent/theme.js

@@ -0,0 +1,41 @@
+export const colors = {
+    honey: '#F5A623',
+    honeyDark: '#D4891A',
+    honeyBright: '#FFD700',
+    white: '#FFFFFF',
+    gray: '#A6A6A6',
+    grayDim: '#555555',
+    green: '#27C587',
+    red: '#E14B4B',
+    wax: '#C45C5C',
+    cyan: '#22D3EE',
+    hot: '#FB923C',
+    controversial: '#C084FC',
+};
+export const symbols = {
+    hive: '\u2B21', // ⬡
+    diamond: '\u25C6', // ◆
+    diamondOpen: '\u25C7', // ◇
+    dot: '\u25CF', // ●
+    check: '\u2713', // ✓
+    cross: '\u2717', // ✗
+    arrow: '\u203A', // ›
+    circle: '\u25CB', // ○
+};
+export const border = {
+    horizontal: '\u2500', // ─
+    vertical: '\u2502', // │
+    topLeft: '\u250C', // ┌
+    topRight: '\u2510', // ┐
+    bottomLeft: '\u2514', // └
+    bottomRight: '\u2518', // ┘
+    teeLeft: '\u251C', // ├
+    teeRight: '\u2524', // ┤
+};
+export const animation = {
+    DATA_CHARS: '01\u25AA\u25AB\u2591\u2592',
+    HEX_CHARS: '\u2B21\u2B22',
+    TICK_MS: 120,
+    HEX_W: 8,
+    HEX_H: 4,
+};

package/dist/{services/agent → agent}/tools/market/client.js

@@ -1,4 +1,4 @@
-import { HIVE_API_URL } from '../../../config/constant.js';
+import { HIVE_API_URL } from '../../../config.js';
 /**
  * Client for the backend Market API.
  */

package/dist/{services/agent → agent}/tools/mindshare/client.js

@@ -1,4 +1,4 @@
-import { HIVE_API_URL } from '../../../config/constant.js';
+import { HIVE_API_URL } from '../../../config.js';
 export class MindshareClient {
     constructor(baseUrl = HIVE_API_URL) {
         this._baseUrl = baseUrl;

package/dist/agent/types.js

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

package/dist/{services/config/agent.js → agents.js}

@@ -2,8 +2,8 @@ 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';
+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) {

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