@zhive/cli 0.6.7 → 0.6.9

package/dist/services/agent/tools/market/tools.js

@@ -0,0 +1,518 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { getMarketClient } from './client.js';
+import { computeSMA, computeEMA, computeRSI, computeMACD, computeBollingerBands, } from '../ta/indicators.js';
+export const getPriceTool = tool({
+    description: 'Get cryptocurrency price. Returns the current price by default, or the price at a specific timestamp if provided.',
+    inputSchema: z.object({
+        projectId: z
+            .string()
+            .describe('Project ID to get price for (e.g., "bitcoin", "ethereum"). Use lowercase.'),
+        timestamp: z
+            .string()
+            .optional()
+            .describe('Optional timestamp in ISO 8601 format. If omitted, returns the current price.'),
+    }),
+    execute: async ({ projectId, timestamp }) => {
+        try {
+            const effectiveTimestamp = timestamp ?? new Date().toISOString();
+            const client = getMarketClient();
+            const priceData = await client.getPrice(projectId, effectiveTimestamp);
+            if (priceData.price === null) {
+                return `No price data available for ${projectId} at ${effectiveTimestamp}.`;
+            }
+            const price = priceData.price;
+            const priceFormatted = price.toLocaleString('en-US', {
+                style: 'currency',
+                currency: 'USD',
+                minimumFractionDigits: 2,
+                maximumFractionDigits: price < 1 ? 6 : 2,
+            });
+            const timeLabel = timestamp ? `at ${timestamp}` : '(current)';
+            const output = `${projectId}: ${priceFormatted} ${timeLabel}`;
+            return output;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return `Error fetching price: ${message}`;
+        }
+    },
+});
+export const getOHLCTool = tool({
+    description: 'Get historical OHLC (Open, High, Low, Close) candlestick data for a cryptocurrency. Use this to analyze price history and patterns.',
+    inputSchema: z.object({
+        id: z.string().describe('Coin ID (e.g., "bitcoin", "ethereum"). Use lowercase.'),
+        from: z
+            .string()
+            .describe('Start date in ISO 8601 format. Use recent dates relative to the current date from context (e.g., 30 days ago).'),
+        to: z
+            .string()
+            .describe('End date in ISO 8601 format. Use the current date from context as the end date.'),
+        interval: z
+            .enum(['daily', 'hourly'])
+            .optional()
+            .describe('Data interval: "daily" or "hourly". Defaults to "daily".'),
+    }),
+    execute: async ({ id, from, to, interval }) => {
+        try {
+            const client = getMarketClient();
+            const effectiveInterval = interval ?? 'daily';
+            const ohlcData = await client.getOHLC(id, from, to, effectiveInterval);
+            if (ohlcData.length === 0) {
+                return `No OHLC data available for ${id} from ${from} to ${to}.`;
+            }
+            const lines = [
+                `OHLC data for ${id} (${effectiveInterval}, ${ohlcData.length} data points):`,
+                '',
+                'Date | Open | High | Low | Close',
+                '--- | --- | --- | --- | ---',
+            ];
+            const maxPoints = 30;
+            const displayData = ohlcData.length > maxPoints
+                ? [...ohlcData.slice(0, 10), null, ...ohlcData.slice(-10)]
+                : ohlcData;
+            for (const point of displayData) {
+                if (point === null) {
+                    lines.push(`... (${ohlcData.length - 20} more rows) ...`);
+                    continue;
+                }
+                const date = new Date(point[0]).toISOString().split('T')[0];
+                const open = point[1].toFixed(2);
+                const high = point[2].toFixed(2);
+                const low = point[3].toFixed(2);
+                const close = point[4].toFixed(2);
+                lines.push(`${date} | $${open} | $${high} | $${low} | $${close}`);
+            }
+            const firstClose = ohlcData[0][4];
+            const lastClose = ohlcData[ohlcData.length - 1][4];
+            const changePercent = ((lastClose - firstClose) / firstClose) * 100;
+            const sign = changePercent >= 0 ? '+' : '';
+            lines.push('');
+            lines.push(`Period change: ${sign}${changePercent.toFixed(2)}% ($${firstClose.toFixed(2)} → $${lastClose.toFixed(2)})`);
+            const output = lines.join('\n');
+            return output;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return `Error fetching OHLC data: ${message}`;
+        }
+    },
+});
+export const getSMATool = tool({
+    description: 'Calculate Simple Moving Average (SMA) for a cryptocurrency. SMA smooths price data by averaging prices over a specified period. Commonly used periods: 20 (short-term), 50 (medium-term), 200 (long-term).',
+    inputSchema: z.object({
+        id: z.string().describe('Coin ID (e.g., "bitcoin", "ethereum"). Use lowercase.'),
+        period: z
+            .number()
+            .int()
+            .min(2)
+            .max(200)
+            .describe('Number of periods for the SMA (e.g., 20, 50, 200).'),
+        from: z
+            .string()
+            .describe('Start date in ISO 8601 format. Use recent dates relative to the current date from context (e.g., 30 days ago).'),
+        to: z
+            .string()
+            .describe('End date in ISO 8601 format. Use the current date from context as the end date.'),
+        interval: z
+            .enum(['daily', 'hourly'])
+            .optional()
+            .describe('Data interval: "daily" or "hourly". Defaults to "daily".'),
+    }),
+    execute: async ({ id, period, from, to, interval }) => {
+        try {
+            const client = getMarketClient();
+            const effectiveInterval = interval ?? 'daily';
+            const ohlcData = await client.getOHLC(id, from, to, effectiveInterval);
+            if (ohlcData.length < period) {
+                return `Insufficient data: got ${ohlcData.length} data points but need at least ${period} for SMA-${period}.`;
+            }
+            const smaData = computeSMA(ohlcData, period);
+            if (smaData.length === 0) {
+                return `Could not compute SMA-${period} for ${id}.`;
+            }
+            const lines = [
+                `SMA-${period} for ${id} (${effectiveInterval}, ${smaData.length} values):`,
+                '',
+            ];
+            const maxPoints = 20;
+            const displayData = smaData.length > maxPoints
+                ? [...smaData.slice(0, 5), null, ...smaData.slice(-10)]
+                : smaData;
+            for (const point of displayData) {
+                if (point === null) {
+                    lines.push(`... (${smaData.length - 15} more values) ...`);
+                    continue;
+                }
+                const date = new Date(point.timestamp).toISOString().split('T')[0];
+                lines.push(`${date}: $${point.value.toFixed(2)}`);
+            }
+            const latestSMA = smaData[smaData.length - 1].value;
+            const latestPrice = ohlcData[ohlcData.length - 1][4];
+            const aboveBelow = latestPrice > latestSMA ? 'above' : 'below';
+            const diff = ((latestPrice - latestSMA) / latestSMA) * 100;
+            const sign = diff >= 0 ? '+' : '';
+            lines.push('');
+            lines.push(`Current price ($${latestPrice.toFixed(2)}) is ${aboveBelow} SMA-${period} ($${latestSMA.toFixed(2)}) by ${sign}${diff.toFixed(2)}%`);
+            const output = lines.join('\n');
+            return output;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return `Error calculating SMA: ${message}`;
+        }
+    },
+});
+export const getEMATool = tool({
+    description: 'Calculate Exponential Moving Average (EMA) for a cryptocurrency. EMA gives more weight to recent prices, making it more responsive than SMA. Common periods: 12, 26 (for MACD), 9 (signal line), 20, 50, 200.',
+    inputSchema: z.object({
+        id: z.string().describe('Coin ID (e.g., "bitcoin", "ethereum"). Use lowercase.'),
+        period: z
+            .number()
+            .int()
+            .min(2)
+            .max(200)
+            .describe('Number of periods for the EMA (e.g., 12, 26, 50, 200).'),
+        from: z
+            .string()
+            .describe('Start date in ISO 8601 format. Use recent dates relative to the current date from context (e.g., 30 days ago).'),
+        to: z
+            .string()
+            .describe('End date in ISO 8601 format. Use the current date from context as the end date.'),
+        interval: z
+            .enum(['daily', 'hourly'])
+            .optional()
+            .describe('Data interval: "daily" or "hourly". Defaults to "daily".'),
+    }),
+    execute: async ({ id, period, from, to, interval }) => {
+        try {
+            const client = getMarketClient();
+            const effectiveInterval = interval ?? 'daily';
+            const ohlcData = await client.getOHLC(id, from, to, effectiveInterval);
+            if (ohlcData.length < period) {
+                return `Insufficient data: got ${ohlcData.length} data points but need at least ${period} for EMA-${period}.`;
+            }
+            const emaData = computeEMA(ohlcData, period);
+            if (emaData.length === 0) {
+                return `Could not compute EMA-${period} for ${id}.`;
+            }
+            const lines = [
+                `EMA-${period} for ${id} (${effectiveInterval}, ${emaData.length} values):`,
+                '',
+            ];
+            const maxPoints = 20;
+            const displayData = emaData.length > maxPoints
+                ? [...emaData.slice(0, 5), null, ...emaData.slice(-10)]
+                : emaData;
+            for (const point of displayData) {
+                if (point === null) {
+                    lines.push(`... (${emaData.length - 15} more values) ...`);
+                    continue;
+                }
+                const date = new Date(point.timestamp).toISOString().split('T')[0];
+                lines.push(`${date}: $${point.value.toFixed(2)}`);
+            }
+            const latestEMA = emaData[emaData.length - 1].value;
+            const latestPrice = ohlcData[ohlcData.length - 1][4];
+            const aboveBelow = latestPrice > latestEMA ? 'above' : 'below';
+            const diff = ((latestPrice - latestEMA) / latestEMA) * 100;
+            const sign = diff >= 0 ? '+' : '';
+            lines.push('');
+            lines.push(`Current price ($${latestPrice.toFixed(2)}) is ${aboveBelow} EMA-${period} ($${latestEMA.toFixed(2)}) by ${sign}${diff.toFixed(2)}%`);
+            const output = lines.join('\n');
+            return output;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return `Error calculating EMA: ${message}`;
+        }
+    },
+});
+export const getRSITool = tool({
+    description: 'Calculate Relative Strength Index (RSI) for a cryptocurrency. RSI measures momentum on a 0-100 scale. Readings above 70 suggest overbought conditions; below 30 suggests oversold. Standard period is 14.',
+    inputSchema: z.object({
+        id: z.string().describe('Coin ID (e.g., "bitcoin", "ethereum"). Use lowercase.'),
+        period: z.number().int().min(2).max(50).optional().describe('RSI period. Defaults to 14.'),
+        from: z
+            .string()
+            .describe('Start date in ISO 8601 format. Use recent dates relative to the current date from context (e.g., 30 days ago).'),
+        to: z
+            .string()
+            .describe('End date in ISO 8601 format. Use the current date from context as the end date.'),
+        interval: z
+            .enum(['daily', 'hourly'])
+            .optional()
+            .describe('Data interval: "daily" or "hourly". Defaults to "daily".'),
+    }),
+    execute: async ({ id, period, from, to, interval }) => {
+        try {
+            const effectivePeriod = period ?? 14;
+            const client = getMarketClient();
+            const effectiveInterval = interval ?? 'daily';
+            const ohlcData = await client.getOHLC(id, from, to, effectiveInterval);
+            if (ohlcData.length < effectivePeriod + 1) {
+                return `Insufficient data: got ${ohlcData.length} data points but need at least ${effectivePeriod + 1} for RSI-${effectivePeriod}.`;
+            }
+            const rsiData = computeRSI(ohlcData, effectivePeriod);
+            if (rsiData.length === 0) {
+                return `Could not compute RSI-${effectivePeriod} for ${id}.`;
+            }
+            const lines = [
+                `RSI-${effectivePeriod} for ${id} (${effectiveInterval}, ${rsiData.length} values):`,
+                '',
+            ];
+            const maxPoints = 20;
+            const displayData = rsiData.length > maxPoints
+                ? [...rsiData.slice(0, 5), null, ...rsiData.slice(-10)]
+                : rsiData;
+            for (const point of displayData) {
+                if (point === null) {
+                    lines.push(`... (${rsiData.length - 15} more values) ...`);
+                    continue;
+                }
+                const date = new Date(point.timestamp).toISOString().split('T')[0];
+                const rsiValue = point.value.toFixed(2);
+                let status = '';
+                if (point.value >= 70) {
+                    status = ' [OVERBOUGHT]';
+                }
+                else if (point.value <= 30) {
+                    status = ' [OVERSOLD]';
+                }
+                lines.push(`${date}: ${rsiValue}${status}`);
+            }
+            const latestRSI = rsiData[rsiData.length - 1].value;
+            let interpretation = '';
+            if (latestRSI >= 70) {
+                interpretation =
+                    'The RSI is in overbought territory (>=70), which may indicate the asset is overvalued and could see a pullback.';
+            }
+            else if (latestRSI <= 30) {
+                interpretation =
+                    'The RSI is in oversold territory (<=30), which may indicate the asset is undervalued and could see a bounce.';
+            }
+            else if (latestRSI >= 50) {
+                interpretation = 'The RSI shows bullish momentum (above 50).';
+            }
+            else {
+                interpretation = 'The RSI shows bearish momentum (below 50).';
+            }
+            lines.push('');
+            lines.push(`Current RSI: ${latestRSI.toFixed(2)}`);
+            lines.push(interpretation);
+            const output = lines.join('\n');
+            return output;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return `Error calculating RSI: ${message}`;
+        }
+    },
+});
+export const getMACDTool = tool({
+    description: 'Calculate MACD (Moving Average Convergence Divergence) for a cryptocurrency. MACD is a trend-following momentum indicator. Standard settings: fast=12, slow=26, signal=9. Bullish when MACD crosses above signal line; bearish when below.',
+    inputSchema: z.object({
+        id: z.string().describe('Coin ID (e.g., "bitcoin", "ethereum"). Use lowercase.'),
+        fastPeriod: z
+            .number()
+            .int()
+            .min(2)
+            .max(50)
+            .optional()
+            .describe('Fast EMA period. Defaults to 12.'),
+        slowPeriod: z
+            .number()
+            .int()
+            .min(2)
+            .max(100)
+            .optional()
+            .describe('Slow EMA period. Defaults to 26.'),
+        signalPeriod: z
+            .number()
+            .int()
+            .min(2)
+            .max(50)
+            .optional()
+            .describe('Signal line EMA period. Defaults to 9.'),
+        from: z
+            .string()
+            .describe('Start date in ISO 8601 format. Use recent dates relative to the current date from context (e.g., 30 days ago).'),
+        to: z
+            .string()
+            .describe('End date in ISO 8601 format. Use the current date from context as the end date.'),
+        interval: z
+            .enum(['daily', 'hourly'])
+            .optional()
+            .describe('Data interval: "daily" or "hourly". Defaults to "daily".'),
+    }),
+    execute: async ({ id, fastPeriod, slowPeriod, signalPeriod, from, to, interval }) => {
+        try {
+            const fast = fastPeriod ?? 12;
+            const slow = slowPeriod ?? 26;
+            const signal = signalPeriod ?? 9;
+            const client = getMarketClient();
+            const effectiveInterval = interval ?? 'daily';
+            const ohlcData = await client.getOHLC(id, from, to, effectiveInterval);
+            const minRequired = slow + signal;
+            if (ohlcData.length < minRequired) {
+                return `Insufficient data: got ${ohlcData.length} data points but need at least ${minRequired} for MACD(${fast},${slow},${signal}).`;
+            }
+            const macdData = computeMACD(ohlcData, fast, slow, signal);
+            if (macdData.length === 0) {
+                return `Could not compute MACD(${fast},${slow},${signal}) for ${id}.`;
+            }
+            const lines = [
+                `MACD(${fast},${slow},${signal}) for ${id} (${effectiveInterval}, ${macdData.length} values):`,
+                '',
+                'Date | MACD | Signal | Histogram',
+                '--- | --- | --- | ---',
+            ];
+            const maxPoints = 20;
+            const displayData = macdData.length > maxPoints
+                ? [...macdData.slice(0, 5), null, ...macdData.slice(-10)]
+                : macdData;
+            for (const point of displayData) {
+                if (point === null) {
+                    lines.push(`... (${macdData.length - 15} more values) ...`);
+                    continue;
+                }
+                const date = new Date(point.timestamp).toISOString().split('T')[0];
+                const macdVal = point.macd.toFixed(4);
+                const signalVal = point.signal.toFixed(4);
+                const histVal = point.histogram.toFixed(4);
+                const histSign = point.histogram >= 0 ? '+' : '';
+                lines.push(`${date} | ${macdVal} | ${signalVal} | ${histSign}${histVal}`);
+            }
+            const latest = macdData[macdData.length - 1];
+            const previous = macdData.length > 1 ? macdData[macdData.length - 2] : null;
+            let crossover = '';
+            if (previous !== null) {
+                if (previous.macd <= previous.signal && latest.macd > latest.signal) {
+                    crossover = 'BULLISH CROSSOVER detected (MACD crossed above Signal line)!';
+                }
+                else if (previous.macd >= previous.signal && latest.macd < latest.signal) {
+                    crossover = 'BEARISH CROSSOVER detected (MACD crossed below Signal line)!';
+                }
+            }
+            const trend = latest.macd > latest.signal ? 'bullish (MACD above signal)' : 'bearish (MACD below signal)';
+            const momentum = latest.histogram > 0 ? 'positive' : 'negative';
+            lines.push('');
+            lines.push(`Current trend: ${trend}`);
+            lines.push(`Histogram momentum: ${momentum}`);
+            if (crossover) {
+                lines.push(crossover);
+            }
+            const output = lines.join('\n');
+            return output;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return `Error calculating MACD: ${message}`;
+        }
+    },
+});
+export const getBollingerTool = tool({
+    description: 'Calculate Bollinger Bands for a cryptocurrency. Bollinger Bands consist of a middle SMA band with upper and lower bands based on standard deviation. Price near upper band may indicate overbought; near lower band may indicate oversold. Standard settings: period=20, stdDev=2.',
+    inputSchema: z.object({
+        id: z.string().describe('Coin ID (e.g., "bitcoin", "ethereum"). Use lowercase.'),
+        period: z
+            .number()
+            .int()
+            .min(2)
+            .max(100)
+            .optional()
+            .describe('SMA period for the middle band. Defaults to 20.'),
+        stdDev: z
+            .number()
+            .min(0.5)
+            .max(5)
+            .optional()
+            .describe('Standard deviation multiplier for bands. Defaults to 2.'),
+        from: z
+            .string()
+            .describe('Start date in ISO 8601 format. Use recent dates relative to the current date from context (e.g., 30 days ago).'),
+        to: z
+            .string()
+            .describe('End date in ISO 8601 format. Use the current date from context as the end date.'),
+        interval: z
+            .enum(['daily', 'hourly'])
+            .optional()
+            .describe('Data interval: "daily" or "hourly". Defaults to "daily".'),
+    }),
+    execute: async ({ id, period, stdDev, from, to, interval }) => {
+        try {
+            const effectivePeriod = period ?? 20;
+            const effectiveStdDev = stdDev ?? 2;
+            const client = getMarketClient();
+            const effectiveInterval = interval ?? 'daily';
+            const ohlcData = await client.getOHLC(id, from, to, effectiveInterval);
+            if (ohlcData.length < effectivePeriod) {
+                return `Insufficient data: got ${ohlcData.length} data points but need at least ${effectivePeriod} for Bollinger Bands(${effectivePeriod},${effectiveStdDev}).`;
+            }
+            const bbData = computeBollingerBands(ohlcData, effectivePeriod, effectiveStdDev);
+            if (bbData.length === 0) {
+                return `Could not compute Bollinger Bands(${effectivePeriod},${effectiveStdDev}) for ${id}.`;
+            }
+            const lines = [
+                `Bollinger Bands(${effectivePeriod},${effectiveStdDev}) for ${id} (${effectiveInterval}, ${bbData.length} values):`,
+                '',
+                'Date | Upper | Middle | Lower',
+                '--- | --- | --- | ---',
+            ];
+            const maxPoints = 20;
+            const displayData = bbData.length > maxPoints ? [...bbData.slice(0, 5), null, ...bbData.slice(-10)] : bbData;
+            for (const point of displayData) {
+                if (point === null) {
+                    lines.push(`... (${bbData.length - 15} more values) ...`);
+                    continue;
+                }
+                const date = new Date(point.timestamp).toISOString().split('T')[0];
+                lines.push(`${date} | $${point.upper.toFixed(2)} | $${point.middle.toFixed(2)} | $${point.lower.toFixed(2)}`);
+            }
+            const latest = bbData[bbData.length - 1];
+            const latestPrice = ohlcData[ohlcData.length - 1][4];
+            const bandwidth = ((latest.upper - latest.lower) / latest.middle) * 100;
+            let position = '';
+            const percentB = (latestPrice - latest.lower) / (latest.upper - latest.lower);
+            if (latestPrice > latest.upper) {
+                position = 'ABOVE upper band (potential overbought)';
+            }
+            else if (latestPrice < latest.lower) {
+                position = 'BELOW lower band (potential oversold)';
+            }
+            else if (percentB > 0.8) {
+                position = 'near upper band (approaching overbought)';
+            }
+            else if (percentB < 0.2) {
+                position = 'near lower band (approaching oversold)';
+            }
+            else {
+                position = 'within bands (neutral zone)';
+            }
+            lines.push('');
+            lines.push(`Current price: $${latestPrice.toFixed(2)}`);
+            lines.push(`Bands: Upper $${latest.upper.toFixed(2)} | Middle $${latest.middle.toFixed(2)} | Lower $${latest.lower.toFixed(2)}`);
+            lines.push(`Bandwidth: ${bandwidth.toFixed(2)}%`);
+            lines.push(`%B (position within bands): ${(percentB * 100).toFixed(1)}%`);
+            lines.push(`Price position: ${position}`);
+            const output = lines.join('\n');
+            return output;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return `Error calculating Bollinger Bands: ${message}`;
+        }
+    },
+});
+/**
+ * All market tools for export.
+ */
+export const marketTools = {
+    getPrice: getPriceTool,
+    getOHLC: getOHLCTool,
+    getSMA: getSMATool,
+    getEMA: getEMATool,
+    getRSI: getRSITool,
+    getMACD: getMACDTool,
+    getBollinger: getBollingerTool,
+};

package/dist/services/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/services/agent/tools/mindshare/index.js

@@ -0,0 +1,3 @@
+export { mindshareTools } from './tools.js';
+export { getProjectLeaderboardTool, getProjectMindshareTool, getProjectMindshareTimeseriesTool, getProjectLeaderboardBySectorTool, getSectorLeaderboardTool, getSectorMindshareTool, getSectorMindshareTimeseriesTool, getUserLeaderboardTool, getUserLeaderboardByProjectTool, getUserMindshareTool, getUserMindshareTimeseriesTool, getMindshareDeltaSignalsTool, getMindshareMASignalsTool, getMindshareSMAZScoreSignalsTool, } from './tools.js';
+export { MindshareClient, getMindshareClient } from './client.js';