mcp-crypto-price 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Tracey Russell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,146 @@
+# Crypto Price & Market Analysis MCP Server
+
+A Model Context Protocol (MCP) server that provides comprehensive cryptocurrency analysis using the CoinCap API. This server offers real-time price data, market analysis, and historical trends through an easy-to-use interface.
+
+## 🚀 Quick Start
+
+First, clone and build the repository:
+
+```bash
+git clone https://github.com/truss44/mcp-crypto-price.git
+cd mcp-crypto-price
+npm install
+npm run build
+```
+
+Then add this configuration to your Claude Desktop config file:
+
+- **MacOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`  
+- **Windows**: `%APPDATA%/Claude/claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "mcp-crypto-price": {
+      "command": "node",
+      "args": ["/ABSOLUTE/PATH/TO/mcp-crypto-price/build/index.js"]
+    }
+  }
+}
+```
+
+### Prerequisites
+
+- Node.js 18+
+- npm
+- Claude for Desktop or another MCP client
+
+Then, launch Claude Desktop and you're ready to go!
+
+## Sample Prompts
+
+- "What's the current price of Bitcoin?"
+- "Show me market analysis for ETH"
+- "Give me the 7-day price history for DOGE"
+- "What are the top exchanges trading BTC?"
+- "Show me the price trends for SOL with 1-hour intervals"
+
+## Tools
+
+#### get-crypto-price
+
+Gets current price and 24h stats for any cryptocurrency, including:
+- Current price in USD
+- 24-hour price change
+- Trading volume
+- Market cap
+- Market rank
+
+#### get-market-analysis
+
+Provides detailed market analysis including:
+- Top 5 exchanges by volume
+- Price variations across exchanges
+- Volume distribution analysis
+- VWAP (Volume Weighted Average Price)
+
+#### get-historical-analysis
+
+Analyzes historical price data with:
+- Customizable time intervals (5min to 1 day)
+- Support for up to 30 days of historical data
+- Price trend analysis
+- Volatility metrics
+- High/low price ranges
+
+## Development - local build
+
+To build it locally:
+
+- **MacOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Windows**: `%APPDATA%/Claude/claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "mcp-crypto-price": {
+      "command": "node",
+      "args": ["/ABSOLUTE/PATH/TO/mcp-crypto-price/build/index.js"]
+    }
+  }
+}
+```
+
+## Development
+
+Install dependencies:
+
+```bash
+npm install
+```
+
+Build the server:
+
+```bash
+npm run build
+```
+
+For development with auto-rebuild:
+
+```bash
+npm run watch
+```
+
+Run test suite:
+
+```bash
+npm test
+```
+
+## Optional: CoinCap API Key
+
+While not required, you can add an API key for higher rate limits:
+
+```json
+{
+  "mcpServers": {
+    "mcp-crypto-price": {
+      "command": "node",
+      "args": [
+          "/ABSOLUTE/PATH/TO/mcp-crypto-price/build/index.js"
+      ],
+      "env": {
+        "COINCAP_API_KEY": "YOUR_API_KEY_HERE"
+      }
+    }
+  }
+}
+```
+
+## Project Inspiration
+
+This project was inspired by Alex Andru's [coincap-mcp](https://github.com/QuantGeekDev/coincap-mcp) project.
+
+## 📜 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/dist/config/index.js

@@ -0,0 +1,6 @@
+export const COINCAP_API_BASE = "https://api.coincap.io/v2";
+export const SERVER_CONFIG = {
+    name: "mcp-crypto-price",
+    version: "1.0.0",
+};
+export const CACHE_TTL = 60000; // 1 minute cache

package/dist/index.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { SERVER_CONFIG } from './config/index.js';
+import { handleGetPrice, handleGetMarketAnalysis, handleGetHistoricalAnalysis } from './tools/index.js';
+// Create server instance
+const server = new Server(SERVER_CONFIG, {
+    capabilities: {
+        tools: {},
+    },
+});
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "get-crypto-price",
+                description: "Get current price and 24h stats for a cryptocurrency",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        symbol: {
+                            type: "string",
+                            description: "Cryptocurrency symbol (e.g., BTC, ETH)",
+                        },
+                    },
+                    required: ["symbol"],
+                },
+            },
+            {
+                name: "get-market-analysis",
+                description: "Get detailed market analysis including top exchanges and volume distribution",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        symbol: {
+                            type: "string",
+                            description: "Cryptocurrency symbol (e.g., BTC, ETH)",
+                        },
+                    },
+                    required: ["symbol"],
+                },
+            },
+            {
+                name: "get-historical-analysis",
+                description: "Get historical price analysis with customizable timeframe",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        symbol: {
+                            type: "string",
+                            description: "Cryptocurrency symbol (e.g., BTC, ETH)",
+                        },
+                        interval: {
+                            type: "string",
+                            description: "Time interval (m5, m15, m30, h1, h2, h6, h12, d1)",
+                            default: "h1",
+                        },
+                        days: {
+                            type: "number",
+                            description: "Number of days to analyze (1-30)",
+                            default: 7,
+                        },
+                    },
+                    required: ["symbol"],
+                },
+            },
+        ],
+    };
+});
+// Handle execution
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case "get-crypto-price":
+                return await handleGetPrice(args);
+            case "get-market-analysis":
+                return await handleGetMarketAnalysis(args);
+            case "get-historical-analysis":
+                return await handleGetHistoricalAnalysis(args);
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Tool execution failed: ${error.message}`);
+        }
+        throw error;
+    }
+});
+// Start the server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Crypto Price MCP Server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+});

package/dist/services/__tests__/coincap.test.js

@@ -0,0 +1,107 @@
+import { jest } from '@jest/globals';
+import { getAssets, getMarkets, getHistoricalData, clearCache } from '../coincap.js';
+// Mock global fetch
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+// Suppress console.error during tests
+console.error = jest.fn();
+describe('CoinCap Service', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFetch.mockReset();
+        clearCache();
+    });
+    afterEach(() => {
+        clearCache();
+    });
+    describe('getAssets', () => {
+        it('should fetch assets successfully', async () => {
+            const mockResponse = {
+                data: [
+                    {
+                        id: 'bitcoin',
+                        rank: '1',
+                        symbol: 'BTC',
+                        name: 'Bitcoin',
+                        priceUsd: '50000.00'
+                    }
+                ]
+            };
+            mockFetch.mockImplementationOnce(() => Promise.resolve({
+                ok: true,
+                json: () => Promise.resolve(mockResponse)
+            }));
+            const result = await getAssets();
+            expect(result).toEqual(mockResponse);
+            expect(mockFetch).toHaveBeenCalledWith('https://api.coincap.io/v2/assets', expect.any(Object));
+        });
+        it('should handle fetch errors', async () => {
+            mockFetch.mockImplementationOnce(() => Promise.reject(new Error('Network error')));
+            const result = await getAssets();
+            expect(result).toBeNull();
+            expect(console.error).toHaveBeenCalled();
+        });
+        it('should handle non-ok response', async () => {
+            mockFetch.mockImplementationOnce(() => Promise.resolve({
+                ok: false,
+                status: 500,
+                statusText: 'Internal Server Error'
+            }));
+            const result = await getAssets();
+            expect(result).toBeNull();
+            expect(console.error).toHaveBeenCalled();
+        });
+    });
+    describe('getMarkets', () => {
+        it('should fetch markets successfully', async () => {
+            const mockResponse = {
+                data: [
+                    {
+                        exchangeId: 'binance',
+                        baseSymbol: 'BTC',
+                        priceUsd: '50000.00'
+                    }
+                ]
+            };
+            mockFetch.mockImplementationOnce(() => Promise.resolve({
+                ok: true,
+                json: () => Promise.resolve(mockResponse)
+            }));
+            const result = await getMarkets('bitcoin');
+            expect(result).toEqual(mockResponse);
+            expect(mockFetch).toHaveBeenCalledWith('https://api.coincap.io/v2/assets/bitcoin/markets', expect.any(Object));
+        });
+        it('should handle fetch errors for markets', async () => {
+            mockFetch.mockImplementationOnce(() => Promise.reject(new Error('Network error')));
+            const result = await getMarkets('bitcoin');
+            expect(result).toBeNull();
+            expect(console.error).toHaveBeenCalled();
+        });
+    });
+    describe('getHistoricalData', () => {
+        it('should fetch historical data successfully', async () => {
+            const mockResponse = {
+                data: [
+                    {
+                        time: 1609459200000,
+                        priceUsd: '45000.00',
+                        date: '2021-01-01'
+                    }
+                ]
+            };
+            mockFetch.mockImplementationOnce(() => Promise.resolve({
+                ok: true,
+                json: () => Promise.resolve(mockResponse)
+            }));
+            const result = await getHistoricalData('bitcoin', 'h1', 1609459200000, 1609545600000);
+            expect(result).toEqual(mockResponse);
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('https://api.coincap.io/v2/assets/bitcoin/history'), expect.any(Object));
+        });
+        it('should handle fetch errors for historical data', async () => {
+            mockFetch.mockImplementationOnce(() => Promise.reject(new Error('Network error')));
+            const result = await getHistoricalData('bitcoin', 'h1', 1609459200000, 1609545600000);
+            expect(result).toBeNull();
+            expect(console.error).toHaveBeenCalled();
+        });
+    });
+});

package/dist/services/__tests__/formatters.test.js

@@ -0,0 +1,113 @@
+import { formatPriceInfo, formatMarketAnalysis, formatHistoricalAnalysis } from '../formatters.js';
+describe('Formatters', () => {
+    describe('formatPriceInfo', () => {
+        it('should format price info correctly', () => {
+            const asset = {
+                id: 'bitcoin',
+                rank: '1',
+                symbol: 'BTC',
+                name: 'Bitcoin',
+                priceUsd: '50000.00',
+                changePercent24Hr: '5.25',
+                volumeUsd24Hr: '30000000000',
+                marketCapUsd: '1000000000000',
+                supply: '19000000',
+                maxSupply: '21000000',
+                vwap24Hr: '49500.00'
+            };
+            const formatted = formatPriceInfo(asset);
+            expect(formatted).toContain('Bitcoin (BTC)');
+            expect(formatted).toContain('Price: $50000.00');
+            expect(formatted).toContain('24h Change: 5.25%');
+            expect(formatted).toContain('24h Volume: $30000.00M');
+            expect(formatted).toContain('Market Cap: $1000.00B');
+            expect(formatted).toContain('Rank: #1');
+        });
+    });
+    describe('formatMarketAnalysis', () => {
+        it('should format market analysis correctly', () => {
+            const asset = {
+                id: 'bitcoin',
+                rank: '1',
+                symbol: 'BTC',
+                name: 'Bitcoin',
+                priceUsd: '50000.00',
+                changePercent24Hr: '5.25',
+                volumeUsd24Hr: '30000000000',
+                marketCapUsd: '1000000000000',
+                supply: '19000000',
+                maxSupply: '21000000',
+                vwap24Hr: '49500.00'
+            };
+            const markets = [
+                {
+                    exchangeId: 'binance',
+                    baseSymbol: 'BTC',
+                    quoteSymbol: 'USD',
+                    priceUsd: '50100.00',
+                    volumeUsd24Hr: '10000000000',
+                    percentExchangeVolume: '33.33'
+                },
+                {
+                    exchangeId: 'coinbase',
+                    baseSymbol: 'BTC',
+                    quoteSymbol: 'USD',
+                    priceUsd: '50000.00',
+                    volumeUsd24Hr: '8000000000',
+                    percentExchangeVolume: '26.67'
+                }
+            ];
+            const formatted = formatMarketAnalysis(asset, markets);
+            expect(formatted).toContain('Market Analysis for Bitcoin (BTC)');
+            expect(formatted).toContain('Current Price: $50000.00');
+            expect(formatted).toContain('24h Volume: $30000.00M');
+            expect(formatted).toContain('VWAP (24h): $49500.00');
+            expect(formatted).toContain('binance: $50100.00');
+            expect(formatted).toContain('coinbase: $50000.00');
+        });
+    });
+    describe('formatHistoricalAnalysis', () => {
+        it('should format historical analysis correctly', () => {
+            const asset = {
+                id: 'bitcoin',
+                rank: '1',
+                symbol: 'BTC',
+                name: 'Bitcoin',
+                priceUsd: '50000.00',
+                changePercent24Hr: '5.25',
+                volumeUsd24Hr: '30000000000',
+                marketCapUsd: '1000000000000',
+                supply: '19000000',
+                maxSupply: '21000000',
+                vwap24Hr: '49500.00'
+            };
+            const history = [
+                {
+                    time: 1609459200000,
+                    priceUsd: '45000.00',
+                    circulatingSupply: '18500000',
+                    date: '2021-01-01'
+                },
+                {
+                    time: 1609545600000,
+                    priceUsd: '48000.00',
+                    circulatingSupply: '18500000',
+                    date: '2021-01-02'
+                },
+                {
+                    time: 1609632000000,
+                    priceUsd: '50000.00',
+                    circulatingSupply: '18500000',
+                    date: '2021-01-03'
+                }
+            ];
+            const formatted = formatHistoricalAnalysis(asset, history);
+            expect(formatted).toContain('Historical Analysis for Bitcoin (BTC)');
+            expect(formatted).toContain('Period High: $50000.00');
+            expect(formatted).toContain('Period Low: $45000.00');
+            expect(formatted).toContain('Price Change: 11.11%');
+            expect(formatted).toContain('Current Price: $50000.00');
+            expect(formatted).toContain('Starting Price: $45000.00');
+        });
+    });
+});

package/dist/services/coincap.js

@@ -0,0 +1,60 @@
+import { COINCAP_API_BASE, CACHE_TTL } from '../config/index.js';
+const cache = new Map();
+// Expose cache clear function for testing
+export function clearCache() {
+    cache.clear();
+}
+function getCachedData(key) {
+    const entry = cache.get(key);
+    if (!entry)
+        return null;
+    const now = Date.now();
+    if (now - entry.timestamp > CACHE_TTL) {
+        cache.delete(key);
+        return null;
+    }
+    return entry.data;
+}
+function setCacheData(key, data) {
+    cache.set(key, {
+        data,
+        timestamp: Date.now()
+    });
+}
+async function makeCoinCapRequest(endpoint) {
+    // Check cache first
+    const cachedData = getCachedData(endpoint);
+    if (cachedData) {
+        return cachedData;
+    }
+    const headers = {};
+    const apiKey = process.env.COINCAP_API_KEY;
+    if (apiKey) {
+        headers['Authorization'] = `Bearer ${apiKey}`;
+    }
+    try {
+        const response = await fetch(`${COINCAP_API_BASE}${endpoint}`, {
+            headers
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const data = await response.json();
+        // Cache the successful response
+        setCacheData(endpoint, data);
+        return data;
+    }
+    catch (error) {
+        console.error("Error making CoinCap request:", error);
+        return null;
+    }
+}
+export async function getAssets() {
+    return makeCoinCapRequest('/assets');
+}
+export async function getMarkets(assetId) {
+    return makeCoinCapRequest(`/assets/${assetId}/markets`);
+}
+export async function getHistoricalData(assetId, interval, start, end) {
+    return makeCoinCapRequest(`/assets/${assetId}/history?interval=${interval}&start=${start}&end=${end}`);
+}

package/dist/services/formatters.js

@@ -0,0 +1,51 @@
+export function formatPriceInfo(asset) {
+    const price = parseFloat(asset.priceUsd).toFixed(2);
+    const change = parseFloat(asset.changePercent24Hr).toFixed(2);
+    const volume = (parseFloat(asset.volumeUsd24Hr) / 1000000).toFixed(2);
+    const marketCap = (parseFloat(asset.marketCapUsd) / 1000000000).toFixed(2);
+    return [
+        `${asset.name} (${asset.symbol})`,
+        `Price: $${price}`,
+        `24h Change: ${change}%`,
+        `24h Volume: $${volume}M`,
+        `Market Cap: $${marketCap}B`,
+        `Rank: #${asset.rank}`,
+    ].join('\n');
+}
+export function formatMarketAnalysis(asset, markets) {
+    const totalVolume = markets.reduce((sum, market) => sum + parseFloat(market.volumeUsd24Hr), 0);
+    const topMarkets = markets
+        .sort((a, b) => parseFloat(b.volumeUsd24Hr) - parseFloat(a.volumeUsd24Hr))
+        .slice(0, 5);
+    const marketInfo = topMarkets.map(market => {
+        const volumePercent = (parseFloat(market.volumeUsd24Hr) / totalVolume * 100).toFixed(2);
+        const volume = (parseFloat(market.volumeUsd24Hr) / 1000000).toFixed(2);
+        return `${market.exchangeId}: $${market.priceUsd} (Volume: $${volume}M, ${volumePercent}% of total)`;
+    }).join('\n');
+    return [
+        `Market Analysis for ${asset.name} (${asset.symbol})`,
+        `Current Price: $${parseFloat(asset.priceUsd).toFixed(2)}`,
+        `24h Volume: $${(parseFloat(asset.volumeUsd24Hr) / 1000000).toFixed(2)}M`,
+        `VWAP (24h): $${parseFloat(asset.vwap24Hr || '0').toFixed(2)}`,
+        '\nTop 5 Markets by Volume:',
+        marketInfo
+    ].join('\n');
+}
+export function formatHistoricalAnalysis(asset, history) {
+    const currentPrice = parseFloat(asset.priceUsd);
+    const oldestPrice = parseFloat(history[0].priceUsd);
+    const highestPrice = Math.max(...history.map(h => parseFloat(h.priceUsd)));
+    const lowestPrice = Math.min(...history.map(h => parseFloat(h.priceUsd)));
+    const priceChange = ((currentPrice - oldestPrice) / oldestPrice * 100).toFixed(2);
+    return [
+        `Historical Analysis for ${asset.name} (${asset.symbol})`,
+        `Period High: $${highestPrice.toFixed(2)}`,
+        `Period Low: $${lowestPrice.toFixed(2)}`,
+        `Price Change: ${priceChange}%`,
+        `Current Price: $${currentPrice.toFixed(2)}`,
+        `Starting Price: $${oldestPrice.toFixed(2)}`,
+        '\nVolatility Analysis:',
+        `Price Range: $${(highestPrice - lowestPrice).toFixed(2)}`,
+        `Range Percentage: ${((highestPrice - lowestPrice) / lowestPrice * 100).toFixed(2)}%`
+    ].join('\n');
+}

package/dist/tools/historical.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { getAssets, getHistoricalData } from '../services/coincap.js';
+import { formatHistoricalAnalysis } from '../services/formatters.js';
+export const GetHistoricalAnalysisSchema = z.object({
+    symbol: z.string().min(1),
+    interval: z.enum(['m5', 'm15', 'm30', 'h1', 'h2', 'h6', 'h12', 'd1']).default('h1'),
+    days: z.number().min(1).max(30).default(7),
+});
+export async function handleGetHistoricalAnalysis(args) {
+    const { symbol, interval, days } = GetHistoricalAnalysisSchema.parse(args);
+    const upperSymbol = symbol.toUpperCase();
+    const assetsData = await getAssets();
+    if (!assetsData) {
+        return {
+            content: [{ type: "text", text: "Failed to retrieve cryptocurrency data" }],
+        };
+    }
+    const asset = assetsData.data.find((a) => a.symbol.toUpperCase() === upperSymbol);
+    if (!asset) {
+        return {
+            content: [{ type: "text", text: `Could not find cryptocurrency with symbol ${upperSymbol}` }],
+        };
+    }
+    const end = Date.now();
+    const start = end - (days * 24 * 60 * 60 * 1000);
+    const historyData = await getHistoricalData(asset.id, interval, start, end);
+    if (!historyData || !historyData.data.length) {
+        return {
+            content: [{ type: "text", text: "Failed to retrieve historical data" }],
+        };
+    }
+    return {
+        content: [{ type: "text", text: formatHistoricalAnalysis(asset, historyData.data) }],
+    };
+}

package/dist/tools/index.js

@@ -0,0 +1,3 @@
+export * from './price.js';
+export * from './market.js';
+export * from './historical.js';

package/dist/tools/market.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { getAssets, getMarkets } from '../services/coincap.js';
+import { formatMarketAnalysis } from '../services/formatters.js';
+export const GetMarketAnalysisSchema = z.object({
+    symbol: z.string().min(1),
+});
+export async function handleGetMarketAnalysis(args) {
+    const { symbol } = GetMarketAnalysisSchema.parse(args);
+    const upperSymbol = symbol.toUpperCase();
+    const assetsData = await getAssets();
+    if (!assetsData) {
+        return {
+            content: [{ type: "text", text: "Failed to retrieve cryptocurrency data" }],
+        };
+    }
+    const asset = assetsData.data.find((a) => a.symbol.toUpperCase() === upperSymbol);
+    if (!asset) {
+        return {
+            content: [{ type: "text", text: `Could not find cryptocurrency with symbol ${upperSymbol}` }],
+        };
+    }
+    const marketsData = await getMarkets(asset.id);
+    if (!marketsData) {
+        return {
+            content: [{ type: "text", text: "Failed to retrieve market data" }],
+        };
+    }
+    return {
+        content: [{ type: "text", text: formatMarketAnalysis(asset, marketsData.data) }],
+    };
+}

package/dist/tools/price.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { getAssets } from '../services/coincap.js';
+import { formatPriceInfo } from '../services/formatters.js';
+export const GetPriceArgumentsSchema = z.object({
+    symbol: z.string().min(1),
+});
+export async function handleGetPrice(args) {
+    const { symbol } = GetPriceArgumentsSchema.parse(args);
+    const upperSymbol = symbol.toUpperCase();
+    const assetsData = await getAssets();
+    if (!assetsData) {
+        return {
+            content: [{ type: "text", text: "Failed to retrieve cryptocurrency data" }],
+        };
+    }
+    const asset = assetsData.data.find((a) => a.symbol.toUpperCase() === upperSymbol);
+    if (!asset) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Could not find cryptocurrency with symbol ${upperSymbol}`,
+                },
+            ],
+        };
+    }
+    return {
+        content: [{ type: "text", text: formatPriceInfo(asset) }],
+    };
+}

package/dist/types/index.js

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

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "mcp-crypto-price",
+  "version": "1.0.1",
+  "description": "A Model Context Protocol (MCP) server that provides real-time cryptocurrency data and analysis through CoinCap's API. Features include price tracking, market analysis, and historical trends.",
+  "license": "MIT",
+  "author": {
+    "name": "Tracey Russell"
+  },
+  "type": "module",
+  "bin": {
+    "mcp-crypto-price": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "dist/**/*"
+  ],
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsc && shx chmod +x dist/*.js",
+    "prepare": "npm run build",
+    "start": "node dist/index.js",
+    "watch": "tsc -w",
+    "inspector": "npx @modelcontextprotocol/inspector dist/index.js",
+    "test": "jest",
+    "test:coverage": "jest --coverage"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.4.1",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^20.11.0",
+    "jest": "^29.7.0",
+    "shx": "^0.3.4",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "mcp",
+    "modelcontextprotocol",
+    "claude",
+    "crypto",
+    "cryptocurrency",
+    "coincap",
+    "price",
+    "market-analysis",
+    "trading",
+    "finance"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/truss44/mcp-crypto-price.git"
+  },
+  "bugs": {
+    "url": "https://github.com/truss44/mcp-crypto-price/issues"
+  },
+  "homepage": "https://github.com/truss44/mcp-crypto-price#readme"
+}