@zhive/cli 0.5.0

package/dist/shared/agent/tools/mindshare/client.js

@@ -0,0 +1,124 @@
+import { HIVE_API_URL } from '../../../config/constant.js';
+export class MindshareClient {
+    constructor(baseUrl = HIVE_API_URL) {
+        this._baseUrl = baseUrl;
+    }
+    async _fetch(path, params) {
+        const url = new URL(path, this._baseUrl);
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== undefined) {
+                    url.searchParams.set(key, String(value));
+                }
+            }
+        }
+        const response = await fetch(url.toString());
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Mindshare API request failed: ${response.status} - ${text}`);
+        }
+        const data = (await response.json());
+        return data;
+    }
+    async getProjectLeaderboard(timeframe, rankBy, limit) {
+        const result = await this._fetch('/mindshare/project/leaderboard', {
+            timeframe,
+            rankBy,
+            limit,
+        });
+        return result;
+    }
+    async getProjectMindshare(projectId, timeframe) {
+        const result = await this._fetch(`/mindshare/project/${encodeURIComponent(projectId)}`, {
+            timeframe,
+        });
+        return result;
+    }
+    async getProjectMindshareTimeseries(projectId, timeframe) {
+        const result = await this._fetch(`/mindshare/project/${encodeURIComponent(projectId)}/timeseries`, { timeframe });
+        return result;
+    }
+    async getProjectLeaderboardBySector(sectorId, timeframe, rankBy, limit, filterBy) {
+        const result = await this._fetch(`/mindshare/project/sector/${encodeURIComponent(sectorId)}/leaderboard`, { timeframe, rankBy, limit, filterBy });
+        return result;
+    }
+    async getSectorLeaderboard(timeframe, rankBy, limit) {
+        const result = await this._fetch('/mindshare/sector/leaderboard', {
+            timeframe,
+            rankBy,
+            limit,
+        });
+        return result;
+    }
+    async getSectorMindshare(sectorId, timeframe) {
+        const result = await this._fetch(`/mindshare/sector/${encodeURIComponent(sectorId)}`, {
+            timeframe,
+        });
+        return result;
+    }
+    async getSectorMindshareTimeseries(sectorId, timeframe) {
+        const result = await this._fetch(`/mindshare/sector/${encodeURIComponent(sectorId)}/timeseries`, { timeframe });
+        return result;
+    }
+    async getUserLeaderboard(timeframe, rankBy, limit, page) {
+        const result = await this._fetch('/mindshare/user/leaderboard', {
+            timeframe,
+            rankBy,
+            limit,
+            page,
+        });
+        return result;
+    }
+    async getUserLeaderboardByProject(projectId, timeframe, rankBy, limit, page) {
+        const result = await this._fetch(`/mindshare/user/project/${encodeURIComponent(projectId)}/leaderboard`, { timeframe, rankBy, limit, page });
+        return result;
+    }
+    async getUserMindshare(userId, timeframe, withTimeseries) {
+        const result = await this._fetch(`/mindshare/user/${encodeURIComponent(userId)}`, {
+            timeframe,
+            withTimeseries,
+        });
+        return result;
+    }
+    async getUserMindshareTimeseries(userId, timeframe) {
+        const result = await this._fetch(`/mindshare/user/${encodeURIComponent(userId)}/timeseries`, { timeframe });
+        return result;
+    }
+    async getMindshareDeltaSignals(projectId, minThreshold, limit, page, includeTrendingTopics) {
+        const result = await this._fetch('/signal/mindshare/delta', {
+            projectId,
+            minThreshold,
+            limit,
+            page,
+            includeTrendingTopics,
+        });
+        return result;
+    }
+    async getMindshareMASignals(projectId, minThreshold, limit, page, includeTrendingTopics) {
+        const result = await this._fetch('/signal/mindshare/ma', {
+            projectId,
+            minThreshold,
+            limit,
+            page,
+            includeTrendingTopics,
+        });
+        return result;
+    }
+    async getMindshareSMAZScoreSignals(projectId, limit, cursor, mode, includeSignalSummary) {
+        const result = await this._fetch('/signal/mindshare/sma-zscore', {
+            projectId,
+            limit,
+            cursor,
+            mode,
+            includeSignalSummary,
+        });
+        return result;
+    }
+}
+let clientInstance = null;
+export function getMindshareClient() {
+    if (clientInstance === null) {
+        clientInstance = new MindshareClient();
+    }
+    return clientInstance;
+}

package/dist/shared/agent/tools/mindshare/index.js

@@ -0,0 +1,3 @@
+export { mindshareTools } from './tools.js';
+export { getProjectLeaderboardTool, getProjectMindshareTool, getProjectMindshareTimeseriesTool, getProjectLeaderboardBySectorTool, } from './tools.js';
+export { MindshareClient, getMindshareClient } from './client.js';

package/dist/shared/agent/tools/mindshare/tools.js

@@ -0,0 +1,167 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { getMindshareClient, } from './client.js';
+import { formatToolError, signPrefix, truncateTimeseries, truncationLabel, formatPeriodChange, } from '../formatting.js';
+const timeframeSchema = z
+    .enum(['30m', '24h', '3D', '7D', '1M', '3M', 'YTD'])
+    .optional()
+    .describe('Timeframe for mindshare data. Defaults to 24h.');
+const rankBySchema = z
+    .enum(['delta', 'value'])
+    .optional()
+    .describe('Rank by "delta" (change) or "value" (absolute). Defaults to value.');
+const limitSchema = z
+    .number()
+    .int()
+    .min(1)
+    .max(100)
+    .optional()
+    .describe('Number of results to return (max 100). Defaults to 20.');
+function formatMindshare(ms) {
+    const value = ms?.value != null ? `${(ms.value * 100).toFixed(4)}%` : 'N/A';
+    const rawDelta = ms?.delta ?? 0;
+    const delta = `${signPrefix(rawDelta)}${(rawDelta * 100).toFixed(2)}%`;
+    const rank = ms?.rank != null ? `#${ms.rank}` : 'N/A';
+    return { value, delta, rank };
+}
+export const getProjectLeaderboardTool = tool({
+    description: 'Get the top trending projects by mindshare. Returns a ranked list of projects sorted by mindshare value or delta change. Use this to identify what projects are gaining attention.',
+    inputSchema: z.object({
+        timeframe: timeframeSchema,
+        rankBy: rankBySchema,
+        limit: limitSchema,
+    }),
+    execute: async ({ timeframe, rankBy, limit }) => {
+        try {
+            const client = getMindshareClient();
+            const data = await client.getProjectLeaderboard(timeframe, rankBy, limit);
+            if (data.length === 0) {
+                return 'No projects found in the mindshare leaderboard.';
+            }
+            const lines = [
+                `Top ${data.length} Projects by Mindshare (${timeframe ?? '24h'}, ranked by ${rankBy ?? 'value'}):`,
+                '',
+                'Rank | Project | Mindshare | Delta',
+                '--- | --- | --- | ---',
+            ];
+            for (const item of data) {
+                const ms = formatMindshare(item.mindshare);
+                lines.push(`${ms.rank} | ${item.name} | ${ms.value} | ${ms.delta}`);
+            }
+            const output = lines.join('\n');
+            return output;
+        }
+        catch (err) {
+            return formatToolError(err, 'fetching project leaderboard');
+        }
+    },
+});
+export const getProjectMindshareTool = tool({
+    description: 'Get the mindshare data for a specific project by ID. Returns current mindshare value, delta change, and ranking position.',
+    inputSchema: z.object({
+        projectId: z.string().describe('The project ID to look up.'),
+        timeframe: timeframeSchema,
+    }),
+    execute: async ({ projectId, timeframe }) => {
+        try {
+            const client = getMindshareClient();
+            const data = await client.getProjectMindshare(projectId, timeframe);
+            const ms = formatMindshare(data.mindshare);
+            const lines = [
+                `Mindshare for ${data.name ?? projectId} (${timeframe ?? '24h'}):`,
+                '',
+                `- Rank: ${ms.rank}`,
+                `- Mindshare Value: ${ms.value}`,
+                `- Delta Change: ${ms.delta}`,
+            ];
+            if (data.symbol) {
+                lines.push(`- Symbol: ${data.symbol}`);
+            }
+            const output = lines.join('\n');
+            return output;
+        }
+        catch (err) {
+            return formatToolError(err, 'fetching project mindshare');
+        }
+    },
+});
+export const getProjectMindshareTimeseriesTool = tool({
+    description: 'Get historical mindshare data for a specific project. Returns timeseries data points showing mindshare value over time.',
+    inputSchema: z.object({
+        projectId: z.string().describe('The project ID to look up.'),
+        timeframe: timeframeSchema,
+    }),
+    execute: async ({ projectId, timeframe }) => {
+        try {
+            const client = getMindshareClient();
+            const data = await client.getProjectMindshareTimeseries(projectId, timeframe);
+            if (!data.data_points || data.data_points.length === 0) {
+                return `No historical mindshare data available for project ${projectId}.`;
+            }
+            const points = data.data_points;
+            const lines = [
+                `Mindshare Timeseries for ${projectId} (${timeframe ?? '24h'}, ${points.length} data points):`,
+                '',
+            ];
+            const displayPoints = truncateTimeseries(points);
+            for (const point of displayPoints) {
+                if (point === null) {
+                    lines.push(truncationLabel(points.length, 15));
+                    continue;
+                }
+                const date = new Date(point.timestamp).toISOString();
+                lines.push(`${date}: ${(point.value * 100).toFixed(4)}%`);
+            }
+            lines.push('');
+            lines.push(formatPeriodChange(points[0].value, points[points.length - 1].value));
+            const output = lines.join('\n');
+            return output;
+        }
+        catch (err) {
+            return formatToolError(err, 'fetching project mindshare timeseries');
+        }
+    },
+});
+export const getProjectLeaderboardBySectorTool = tool({
+    description: 'Get the top projects within a specific sector by mindshare. Use this to analyze which projects are gaining attention in a particular market segment.',
+    inputSchema: z.object({
+        sectorId: z.string().describe('The sector ID to filter by.'),
+        timeframe: timeframeSchema,
+        rankBy: rankBySchema,
+        limit: limitSchema,
+        filterBy: z
+            .enum(['all', 'preTGE', 'nonePreTGE'])
+            .optional()
+            .describe('Filter by project stage: all, preTGE (pre-token launch), or nonePreTGE.'),
+    }),
+    execute: async ({ sectorId, timeframe, rankBy, limit, filterBy }) => {
+        try {
+            const client = getMindshareClient();
+            const data = await client.getProjectLeaderboardBySector(sectorId, timeframe, rankBy, limit, filterBy);
+            if (data.length === 0) {
+                return `No projects found in sector ${sectorId}.`;
+            }
+            const lines = [
+                `Top ${data.length} Projects in Sector "${sectorId}" (${timeframe ?? '24h'}, ranked by ${rankBy ?? 'value'}):`,
+                '',
+                'Rank | Project | Mindshare | Delta',
+                '--- | --- | --- | ---',
+            ];
+            for (const item of data) {
+                const ms = formatMindshare(item.mindshare);
+                lines.push(`${ms.rank} | ${item.name} | ${ms.value} | ${ms.delta}`);
+            }
+            const output = lines.join('\n');
+            return output;
+        }
+        catch (err) {
+            return formatToolError(err, 'fetching sector project leaderboard');
+        }
+    },
+});
+export const mindshareTools = {
+    getProjectLeaderboard: getProjectLeaderboardTool,
+    getProjectMindshare: getProjectMindshareTool,
+    getProjectMindshareTimeseries: getProjectMindshareTimeseriesTool,
+    getProjectLeaderboardBySector: getProjectLeaderboardBySectorTool,
+};

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

@@ -0,0 +1,30 @@
+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/shared/agent/tools/ta/index.js

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

package/dist/shared/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/shared/agent/types.js

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

package/dist/shared/agent/utils.js

@@ -0,0 +1,43 @@
+export function formatTime(date) {
+    const hours = String(date.getHours()).padStart(2, '0');
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    const seconds = String(date.getSeconds()).padStart(2, '0');
+    return `${hours}:${minutes}:${seconds}`;
+}
+export function convictionColor(conviction) {
+    if (conviction > 0)
+        return 'green';
+    if (conviction < 0)
+        return 'red';
+    return 'gray';
+}
+export function extractErrorMessage(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return message;
+}
+export function formatTokenCount(n) {
+    const formatted = n.toLocaleString('en-US');
+    return formatted;
+}
+export function formatTokenUsage(usage) {
+    let input = `input: ${formatTokenCount(usage.inputTokens)}`;
+    if (usage.cacheReadTokens > 0) {
+        const newTokens = usage.inputTokens - usage.cacheReadTokens;
+        input += ` (${formatTokenCount(newTokens)} new, ${formatTokenCount(usage.cacheReadTokens)} cached)`;
+    }
+    else if (usage.cacheWriteTokens > 0) {
+        input += ` (${formatTokenCount(usage.cacheWriteTokens)} cache write)`;
+    }
+    const output = `output: ${formatTokenCount(usage.outputTokens)}`;
+    const tools = usage.toolCalls > 0 ? `tools: ${usage.toolNames.join(', ')}` : null;
+    return { input, output, tools };
+}
+export function stripCodeFences(text) {
+    const trimmed = text.trim();
+    const fencePattern = /^```(?:markdown|md)?\s*\n([\s\S]*?)\n```$/;
+    const match = trimmed.match(fencePattern);
+    if (match) {
+        return match[1].trim();
+    }
+    return trimmed;
+}