@zhive/cli 0.5.0

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

@@ -0,0 +1,87 @@
+import * as path from 'node:path';
+import { discoverSkills } from '../skills/skill-parser.js';
+import { marketTools } from './market/index.js';
+import { mindshareTools } from './mindshare/index.js';
+import { createExecuteSkillTool, clearSubagentUsage, getSubagentUsage, } from './execute-skill-tool.js';
+export { clearSubagentUsage, getSubagentUsage };
+/**
+ * Get all tools that are always available to agents.
+ * Tools are bundled with the CLI and don't require skill installation.
+ * Skills provide knowledge/guidance on when and how to use these tools.
+ */
+export function getAllTools() {
+    const tools = {};
+    for (const [name, tool] of Object.entries(marketTools)) {
+        const namespacedName = `market_${name}`;
+        tools[namespacedName] = tool;
+    }
+    for (const [name, tool] of Object.entries(mindshareTools)) {
+        const namespacedName = `mindshare_${name}`;
+        tools[namespacedName] = tool;
+    }
+    return tools;
+}
+/**
+ * Initialize skills from agent's skills/ directory.
+ * Skills are knowledge-only documents that help agents understand
+ * when and how to use the always-available tools.
+ * Returns a registry map that should be passed to other skill functions.
+ */
+export async function initializeSkills(agentPath) {
+    const skillRegistry = new Map();
+    const skillsPath = path.join(agentPath ?? process.cwd(), 'skills');
+    const agentSkills = await discoverSkills(skillsPath);
+    for (const skill of agentSkills) {
+        skillRegistry.set(skill.id, skill);
+    }
+    return skillRegistry;
+}
+/**
+ * Get a skill metadata list for prompt injection.
+ * Shows skill ID, description, and compatibility to help the agent decide what to use.
+ */
+export function getSkillMetadataList(skillRegistry) {
+    if (skillRegistry.size === 0) {
+        return '';
+    }
+    const entries = Array.from(skillRegistry.values()).map((s) => {
+        const lines = [`### ${s.id}`, s.metadata.description];
+        if (s.metadata.compatibility) {
+            lines.push(`**Compatibility:** ${s.metadata.compatibility}`);
+        }
+        const entry = lines.join('\n');
+        return entry;
+    });
+    const output = `Available skills:\n\n${entries.join('\n\n')}`;
+    return output;
+}
+/**
+ * Get the executeSkill tool for running skills as subagents.
+ * The subagent uses the skill's body as instructions and has access to all tools.
+ */
+export function getExecuteSkillTool(skillRegistry, model, subagentConfig) {
+    const config = {
+        model,
+        subagentConfig,
+    };
+    const executeSkillTool = createExecuteSkillTool(skillRegistry, config);
+    return executeSkillTool;
+}
+/**
+ * Get a skill definition by ID.
+ */
+export function getSkill(skillRegistry, id) {
+    return skillRegistry.get(id);
+}
+/**
+ * Get all registered skills.
+ */
+export function getAllSkills(skillRegistry) {
+    return Array.from(skillRegistry.values());
+}
+/**
+ * Check if any skills are registered.
+ */
+export function hasSkills(skillRegistry) {
+    return skillRegistry.size > 0;
+}

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

@@ -0,0 +1,41 @@
+import { HIVE_API_URL } from '../../../config/constant.js';
+/**
+ * Client for the backend Market API.
+ */
+export class MarketClient {
+    constructor(baseUrl = HIVE_API_URL) {
+        this._baseUrl = baseUrl;
+    }
+    async getPrice(projectId, timestamp) {
+        const url = `${this._baseUrl}/market/price/${encodeURIComponent(projectId)}?timestamp=${encodeURIComponent(timestamp)}`;
+        const response = await fetch(url);
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Market price request failed: ${response.status} - ${text}`);
+        }
+        const data = (await response.json());
+        return data;
+    }
+    async getOHLC(id, from, to, interval = 'daily') {
+        const params = new URLSearchParams({
+            from,
+            to,
+            interval,
+        });
+        const url = `${this._baseUrl}/market/ohlc/${encodeURIComponent(id)}?${params.toString()}`;
+        const response = await fetch(url);
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Market OHLC request failed: ${response.status} - ${text}`);
+        }
+        const data = (await response.json());
+        return data;
+    }
+}
+let clientInstance = null;
+export function getMarketClient() {
+    if (clientInstance === null) {
+        clientInstance = new MarketClient();
+    }
+    return clientInstance;
+}

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

@@ -0,0 +1,3 @@
+export { marketTools } from './tools.js';
+export { getPriceTool, getOHLCTool, getSMATool, getEMATool, getRSITool, getMACDTool, getBollingerTool, } from './tools.js';
+export { MarketClient, getMarketClient } from './client.js';

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

@@ -0,0 +1,497 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { getMarketClient } from './client.js';
+import { computeSMA, computeEMA, computeRSI, computeMACD, computeBollingerBands, } from '../ta/indicators.js';
+import { formatToolError, signPrefix, truncateTimeseries, truncationLabel } from '../formatting.js';
+/**
+ * Adjusts the 'from' date backwards to ensure sufficient data points are fetched
+ * for indicator calculation. Adds a 30% buffer for weekends/gaps in data.
+ */
+function adjustFromDate(from, minPoints, interval) {
+    const fromDate = new Date(from);
+    const buffer = Math.ceil(minPoints * 0.3);
+    const totalPoints = minPoints + buffer;
+    if (interval === 'hourly') {
+        fromDate.setTime(fromDate.getTime() - totalPoints * 60 * 60 * 1000);
+    }
+    else {
+        fromDate.setTime(fromDate.getTime() - totalPoints * 24 * 60 * 60 * 1000);
+    }
+    return fromDate.toISOString();
+}
+const timeRangeSchema = z.object({
+    from: z
+        .string()
+        .describe('Start date in ISO 8601 format. Use recent dates relative to the current date from context (e.g., "2024-01-01T00:00:00Z")'),
+    to: z
+        .string()
+        .describe('End date in ISO 8601 format. Use the current date from context as the end date. (e.g., "2024-01-01T00:00:00Z")'),
+});
+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) {
+            return formatToolError(err, 'fetching price');
+        }
+    },
+});
+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({
+        ...timeRangeSchema.shape,
+        id: z.string().describe('Coin ID (e.g., "bitcoin", "ethereum"). Use lowercase.'),
+        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 displayData = truncateTimeseries(ohlcData, 30, 10, 10);
+            for (const point of displayData) {
+                if (point === null) {
+                    lines.push(truncationLabel(ohlcData.length, 20));
+                    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;
+            lines.push('');
+            lines.push(`Period change: ${signPrefix(changePercent)}${changePercent.toFixed(2)}% ($${firstClose.toFixed(2)} → $${lastClose.toFixed(2)})`);
+            const output = lines.join('\n');
+            return output;
+        }
+        catch (err) {
+            return formatToolError(err, 'fetching OHLC data');
+        }
+    },
+});
+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({
+        ...timeRangeSchema.shape,
+        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).'),
+        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 adjustedFrom = adjustFromDate(from, period, effectiveInterval);
+            const ohlcData = await client.getOHLC(id, adjustedFrom, 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}.`;
+            }
+            // Filter results to original date range
+            const originalFromTime = new Date(from).getTime();
+            const filteredData = smaData.filter((point) => point.timestamp >= originalFromTime);
+            if (filteredData.length === 0) {
+                return `No SMA-${period} data available within the requested date range for ${id}.`;
+            }
+            const lines = [
+                `SMA-${period} for ${id} (${effectiveInterval}, ${filteredData.length} values):`,
+                '',
+            ];
+            for (const point of filteredData) {
+                const date = new Date(point.timestamp).toISOString().split('T')[0];
+                lines.push(`${date}: $${point.value.toFixed(2)}`);
+            }
+            const latestSMA = filteredData[filteredData.length - 1].value;
+            const latestPrice = ohlcData[ohlcData.length - 1][4];
+            const aboveBelow = latestPrice > latestSMA ? 'above' : 'below';
+            const diff = ((latestPrice - latestSMA) / latestSMA) * 100;
+            lines.push('');
+            lines.push(`Current price ($${latestPrice.toFixed(2)}) is ${aboveBelow} SMA-${period} ($${latestSMA.toFixed(2)}) by ${signPrefix(diff)}${diff.toFixed(2)}%`);
+            const output = lines.join('\n');
+            return output;
+        }
+        catch (err) {
+            return formatToolError(err, 'calculating SMA');
+        }
+    },
+});
+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({
+        ...timeRangeSchema.shape,
+        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).'),
+        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 adjustedFrom = adjustFromDate(from, period, effectiveInterval);
+            const ohlcData = await client.getOHLC(id, adjustedFrom, 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}.`;
+            }
+            // Filter results to original date range
+            const originalFromTime = new Date(from).getTime();
+            const filteredData = emaData.filter((point) => point.timestamp >= originalFromTime);
+            if (filteredData.length === 0) {
+                return `No EMA-${period} data available within the requested date range for ${id}.`;
+            }
+            const lines = [
+                `EMA-${period} for ${id} (${effectiveInterval}, ${filteredData.length} values):`,
+                '',
+            ];
+            for (const point of filteredData) {
+                const date = new Date(point.timestamp).toISOString().split('T')[0];
+                lines.push(`${date}: $${point.value.toFixed(2)}`);
+            }
+            const latestEMA = filteredData[filteredData.length - 1].value;
+            const latestPrice = ohlcData[ohlcData.length - 1][4];
+            const aboveBelow = latestPrice > latestEMA ? 'above' : 'below';
+            const diff = ((latestPrice - latestEMA) / latestEMA) * 100;
+            lines.push('');
+            lines.push(`Current price ($${latestPrice.toFixed(2)}) is ${aboveBelow} EMA-${period} ($${latestEMA.toFixed(2)}) by ${signPrefix(diff)}${diff.toFixed(2)}%`);
+            const output = lines.join('\n');
+            return output;
+        }
+        catch (err) {
+            return formatToolError(err, 'calculating EMA');
+        }
+    },
+});
+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({
+        ...timeRangeSchema.shape,
+        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.'),
+        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 minRequired = effectivePeriod + 1;
+            const client = getMarketClient();
+            const effectiveInterval = interval ?? 'daily';
+            const adjustedFrom = adjustFromDate(from, minRequired, effectiveInterval);
+            const ohlcData = await client.getOHLC(id, adjustedFrom, to, effectiveInterval);
+            if (ohlcData.length < minRequired) {
+                return `Insufficient data: got ${ohlcData.length} data points but need at least ${minRequired} for RSI-${effectivePeriod}.`;
+            }
+            const rsiData = computeRSI(ohlcData, effectivePeriod);
+            if (rsiData.length === 0) {
+                return `Could not compute RSI-${effectivePeriod} for ${id}.`;
+            }
+            // Filter results to original date range
+            const originalFromTime = new Date(from).getTime();
+            const filteredData = rsiData.filter((point) => point.timestamp >= originalFromTime);
+            if (filteredData.length === 0) {
+                return `No RSI-${effectivePeriod} data available within the requested date range for ${id}.`;
+            }
+            const lines = [
+                `RSI-${effectivePeriod} for ${id} (${effectiveInterval}, ${filteredData.length} values):`,
+                '',
+            ];
+            for (const point of filteredData) {
+                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 = filteredData[filteredData.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) {
+            return formatToolError(err, 'calculating RSI');
+        }
+    },
+});
+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({
+        ...timeRangeSchema.shape,
+        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.'),
+        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 minRequired = slow + signal;
+            const client = getMarketClient();
+            const effectiveInterval = interval ?? 'daily';
+            const adjustedFrom = adjustFromDate(from, minRequired, effectiveInterval);
+            const ohlcData = await client.getOHLC(id, adjustedFrom, to, effectiveInterval);
+            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}.`;
+            }
+            // Filter results to original date range
+            const originalFromTime = new Date(from).getTime();
+            const filteredData = macdData.filter((point) => point.timestamp >= originalFromTime);
+            if (filteredData.length === 0) {
+                return `No MACD(${fast},${slow},${signal}) data available within the requested date range for ${id}.`;
+            }
+            const lines = [
+                `MACD(${fast},${slow},${signal}) for ${id} (${effectiveInterval}, ${filteredData.length} values):`,
+                '',
+                'Date | MACD | Signal | Histogram',
+                '--- | --- | --- | ---',
+            ];
+            for (const point of filteredData) {
+                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);
+                lines.push(`${date} | ${macdVal} | ${signalVal} | ${signPrefix(point.histogram)}${histVal}`);
+            }
+            const latest = filteredData[filteredData.length - 1];
+            const previous = filteredData.length > 1 ? filteredData[filteredData.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) {
+            return formatToolError(err, 'calculating MACD');
+        }
+    },
+});
+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({
+        ...timeRangeSchema.shape,
+        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.'),
+        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 adjustedFrom = adjustFromDate(from, effectivePeriod, effectiveInterval);
+            const ohlcData = await client.getOHLC(id, adjustedFrom, 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}.`;
+            }
+            // Filter results to original date range
+            const originalFromTime = new Date(from).getTime();
+            const filteredData = bbData.filter((point) => point.timestamp >= originalFromTime);
+            if (filteredData.length === 0) {
+                return `No Bollinger Bands(${effectivePeriod},${effectiveStdDev}) data available within the requested date range for ${id}.`;
+            }
+            const lines = [
+                `Bollinger Bands(${effectivePeriod},${effectiveStdDev}) for ${id} (${effectiveInterval}, ${filteredData.length} values):`,
+                '',
+                'Date | Upper | Middle | Lower',
+                '--- | --- | --- | ---',
+            ];
+            for (const point of filteredData) {
+                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 = filteredData[filteredData.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) {
+            return formatToolError(err, 'calculating Bollinger Bands');
+        }
+    },
+});
+/**
+ * All market tools for export.
+ */
+export const marketTools = {
+    getPrice: getPriceTool,
+    getOHLC: getOHLCTool,
+    getSMA: getSMATool,
+    getEMA: getEMATool,
+    getRSI: getRSITool,
+    getMACD: getMACDTool,
+    getBollinger: getBollingerTool,
+};