crypull 1.0.0

package/dist/cli.mjs

@@ -0,0 +1,980 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import pc from 'picocolors';
+import * as asciichart from 'asciichart';
+
+// src/providers/coingecko.ts
+var CoinGeckoProvider = class {
+  name = "CoinGecko";
+  baseUrl = "https://api.coingecko.com/api/v3";
+  async search(query) {
+    try {
+      const res = await fetch(`${this.baseUrl}/search?query=${query}`);
+      if (!res.ok) return [];
+      const data = await res.json();
+      return (data.coins || []).slice(0, 10).map((coin) => ({
+        id: coin.id,
+        name: coin.name,
+        symbol: coin.symbol.toUpperCase(),
+        source: this.name
+      }));
+    } catch (e) {
+      return [];
+    }
+  }
+  async getPrice(symbolOrId) {
+    try {
+      let id = symbolOrId.toLowerCase();
+      const searchRes = await this.search(id);
+      const match = searchRes.find((s) => s.symbol.toLowerCase() === id || s.id === id);
+      if (match && match.id) {
+        id = match.id;
+      }
+      const res = await fetch(`${this.baseUrl}/simple/price?ids=${id}&vs_currencies=usd`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      if (!data[id] || typeof data[id].usd === "undefined") return null;
+      return {
+        symbol: match ? match.symbol : id.toUpperCase(),
+        priceUsd: data[id].usd,
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+  async getTokenInfo(id) {
+    try {
+      const res = await fetch(`${this.baseUrl}/coins/${id.toLowerCase()}?localization=false&tickers=false&market_data=true&community_data=false&developer_data=false&sparkline=false`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      if (data.error) return null;
+      return {
+        name: data.name,
+        symbol: data.symbol.toUpperCase(),
+        description: data.description?.en,
+        priceUsd: data.market_data?.current_price?.usd || 0,
+        marketCap: data.market_data?.market_cap?.usd,
+        marketCapRank: data.market_cap_rank,
+        fdv: data.market_data?.fully_diluted_valuation?.usd,
+        circulatingSupply: data.market_data?.circulating_supply,
+        totalSupply: data.market_data?.total_supply,
+        maxSupply: data.market_data?.max_supply,
+        volume24h: data.market_data?.total_volume?.usd,
+        priceChange24h: data.market_data?.price_change_24h,
+        priceChangePercentage24h: data.market_data?.price_change_percentage_24h,
+        priceChangePercentage7d: data.market_data?.price_change_percentage_7d,
+        ath: data.market_data?.ath?.usd,
+        athDate: data.market_data?.ath_date?.usd,
+        atl: data.market_data?.atl?.usd,
+        atlDate: data.market_data?.atl_date?.usd,
+        links: {
+          website: data.links?.homepage?.[0],
+          twitter: data.links?.twitter_screen_name ? `https://twitter.com/${data.links.twitter_screen_name}` : void 0,
+          telegram: data.links?.telegram_channel_identifier ? `https://t.me/${data.links.telegram_channel_identifier}` : void 0,
+          discord: data.links?.chat_url?.find((url) => url.includes("discord")),
+          github: data.links?.repos_url?.github?.[0]
+        },
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+};
+
+// src/providers/dexscreener.ts
+var DexScreenerProvider = class {
+  name = "DexScreener";
+  baseUrl = "https://api.dexscreener.com/latest/dex";
+  async search(query) {
+    try {
+      const res = await fetch(`${this.baseUrl}/search?q=${query}`);
+      if (!res.ok) return [];
+      const data = await res.json();
+      return (data.pairs || []).slice(0, 10).map((pair) => ({
+        id: pair.baseToken.address,
+        name: pair.baseToken.name,
+        symbol: pair.baseToken.symbol.toUpperCase(),
+        network: pair.chainId,
+        source: this.name
+      }));
+    } catch (e) {
+      return [];
+    }
+  }
+  async getPrice(address) {
+    const info = await this.getTokenInfo(address);
+    if (!info) return null;
+    return {
+      symbol: info.symbol,
+      priceUsd: info.priceUsd,
+      source: this.name,
+      lastUpdated: info.lastUpdated
+    };
+  }
+  async getTokenInfo(address) {
+    try {
+      const res = await fetch(`${this.baseUrl}/tokens/${address}`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      if (!data.pairs || data.pairs.length === 0) return null;
+      const pair = data.pairs[0];
+      const mappedPairs = data.pairs.slice(0, 10).map((p) => ({
+        dexId: p.dexId,
+        url: p.url,
+        pairAddress: p.pairAddress,
+        baseTokenSymbol: p.baseToken.symbol,
+        quoteTokenSymbol: p.quoteToken.symbol,
+        priceUsd: parseFloat(p.priceUsd) || 0,
+        volume24h: p.volume?.h24,
+        liquidityUsd: p.liquidity?.usd
+      }));
+      return {
+        name: pair.baseToken.name,
+        symbol: pair.baseToken.symbol.toUpperCase(),
+        address: pair.baseToken.address,
+        network: pair.chainId,
+        priceUsd: parseFloat(pair.priceUsd) || 0,
+        fdv: pair.fdv,
+        volume24h: pair.volume?.h24,
+        liquidityUsd: pair.liquidity?.usd,
+        priceChangePercentage24h: pair.priceChange?.h24,
+        pairs: mappedPairs,
+        links: {
+          website: pair.info?.websites?.[0]?.url,
+          twitter: pair.info?.socials?.find((s) => s.type === "twitter")?.url,
+          telegram: pair.info?.socials?.find((s) => s.type === "telegram")?.url,
+          discord: pair.info?.socials?.find((s) => s.type === "discord")?.url
+        },
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+};
+
+// src/providers/geckoterminal.ts
+var GeckoTerminalProvider = class {
+  name = "GeckoTerminal";
+  baseUrl = "https://api.geckoterminal.com/api/v2";
+  async search(query) {
+    try {
+      const res = await fetch(`${this.baseUrl}/search/pools?query=${query}`);
+      if (!res.ok) return [];
+      const data = await res.json();
+      const pools = data.data || [];
+      return pools.slice(0, 10).map((pool) => {
+        const attributes = pool.attributes;
+        const baseToken = attributes.name.split(" / ")[0];
+        return {
+          id: pool.id,
+          // e.g. "eth_0x..."
+          name: attributes.name,
+          symbol: baseToken,
+          network: pool.relationships.network.data.id,
+          source: this.name
+        };
+      });
+    } catch (e) {
+      return [];
+    }
+  }
+  async getPrice(address, network = "eth") {
+    const info = await this.getTokenInfo(address, network);
+    if (!info) return null;
+    return {
+      symbol: info.symbol,
+      priceUsd: info.priceUsd,
+      source: this.name,
+      lastUpdated: info.lastUpdated
+    };
+  }
+  async getTokenInfo(address, network = "eth") {
+    try {
+      const res = await fetch(`${this.baseUrl}/networks/${network}/tokens/${address}`);
+      if (!res.ok) return null;
+      const json = await res.json();
+      if (!json.data || !json.data.attributes) return null;
+      const attrs = json.data.attributes;
+      return {
+        name: attrs.name,
+        symbol: attrs.symbol.toUpperCase(),
+        address: attrs.address,
+        network,
+        priceUsd: parseFloat(attrs.price_usd) || 0,
+        fdv: parseFloat(attrs.fdv_usd),
+        volume24h: parseFloat(attrs.volume_usd?.h24 || 0),
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+};
+
+// src/providers/binance.ts
+var BinanceProvider = class {
+  name = "Binance";
+  baseUrl = "https://api.binance.com/api/v3";
+  async search(query) {
+    try {
+      const symbol = query.toUpperCase();
+      const res = await fetch(`${this.baseUrl}/ticker/price?symbol=${symbol}USDT`);
+      if (res.ok) {
+        return [{
+          id: `${symbol}USDT`,
+          name: symbol,
+          symbol,
+          source: this.name
+        }];
+      }
+      return [];
+    } catch (e) {
+      return [];
+    }
+  }
+  async getPrice(symbol) {
+    try {
+      let querySymbol = symbol.toUpperCase();
+      if (!querySymbol.endsWith("USDT") && !querySymbol.endsWith("BUSD") && !querySymbol.endsWith("BTC")) {
+        querySymbol += "USDT";
+      }
+      const res = await fetch(`${this.baseUrl}/ticker/price?symbol=${querySymbol}`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      return {
+        symbol: symbol.toUpperCase(),
+        priceUsd: parseFloat(data.price) || 0,
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+  async getTokenInfo(symbol) {
+    try {
+      let querySymbol = symbol.toUpperCase();
+      if (!querySymbol.endsWith("USDT") && !querySymbol.endsWith("BUSD") && !querySymbol.endsWith("BTC")) {
+        querySymbol += "USDT";
+      }
+      const res = await fetch(`${this.baseUrl}/ticker/24hr?symbol=${querySymbol}`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      return {
+        name: symbol.toUpperCase(),
+        symbol: symbol.toUpperCase(),
+        priceUsd: parseFloat(data.lastPrice) || 0,
+        volume24h: parseFloat(data.quoteVolume) || 0,
+        // Quote volume in USDT roughly = USD volume
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+};
+
+// src/providers/coinpaprika.ts
+var CoinpaprikaProvider = class {
+  name = "Coinpaprika";
+  baseUrl = "https://api.coinpaprika.com/v1";
+  async search(query) {
+    try {
+      const res = await fetch(`${this.baseUrl}/search?q=${query}&c=currencies&limit=10`);
+      if (!res.ok) return [];
+      const data = await res.json();
+      return (data.currencies || []).map((coin) => ({
+        id: coin.id,
+        name: coin.name,
+        symbol: coin.symbol.toUpperCase(),
+        source: this.name
+      }));
+    } catch (e) {
+      return [];
+    }
+  }
+  async getPrice(symbolOrId) {
+    const info = await this.getTokenInfo(symbolOrId);
+    if (!info) return null;
+    return {
+      symbol: info.symbol,
+      priceUsd: info.priceUsd,
+      source: this.name,
+      lastUpdated: info.lastUpdated
+    };
+  }
+  async getTokenInfo(symbolOrId) {
+    try {
+      let id = symbolOrId.toLowerCase();
+      if (!id.includes("-")) {
+        const searchRes = await this.search(id);
+        const match = searchRes.find((s) => s.symbol.toLowerCase() === id || s.id === id);
+        if (match && match.id) {
+          id = match.id;
+        } else if (searchRes.length > 0 && searchRes[0].id) {
+          id = searchRes[0].id;
+        }
+      }
+      const res = await fetch(`${this.baseUrl}/tickers/${id}`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      return {
+        name: data.name,
+        symbol: data.symbol.toUpperCase(),
+        description: data.description,
+        priceUsd: data.quotes?.USD?.price || 0,
+        marketCap: data.quotes?.USD?.market_cap,
+        marketCapRank: data.rank,
+        circulatingSupply: data.circulating_supply,
+        totalSupply: data.total_supply,
+        maxSupply: data.max_supply,
+        volume24h: data.quotes?.USD?.volume_24h,
+        priceChangePercentage24h: data.quotes?.USD?.percent_change_24h,
+        priceChangePercentage7d: data.quotes?.USD?.percent_change_7d,
+        ath: data.quotes?.USD?.ath_price,
+        athDate: data.quotes?.USD?.ath_date,
+        links: {
+          website: data.links?.website?.[0],
+          twitter: data.links?.twitter?.[0],
+          discord: data.links?.discord?.[0],
+          github: data.links?.source_code?.[0]
+        },
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+};
+
+// src/providers/coincap.ts
+var CoinCapProvider = class {
+  name = "CoinCap";
+  baseUrl = "https://api.coincap.io/v2";
+  async search(query) {
+    try {
+      const res = await fetch(`${this.baseUrl}/assets?search=${query}&limit=10`);
+      if (!res.ok) return [];
+      const data = await res.json();
+      return (data.data || []).map((coin) => ({
+        id: coin.id,
+        name: coin.name,
+        symbol: coin.symbol.toUpperCase(),
+        source: this.name
+      }));
+    } catch (e) {
+      return [];
+    }
+  }
+  async getPrice(symbolOrId) {
+    const info = await this.getTokenInfo(symbolOrId);
+    if (!info) return null;
+    return {
+      symbol: info.symbol,
+      priceUsd: info.priceUsd,
+      source: this.name,
+      lastUpdated: info.lastUpdated
+    };
+  }
+  async getTokenInfo(symbolOrId) {
+    try {
+      let id = symbolOrId.toLowerCase();
+      const searchRes = await this.search(id);
+      const match = searchRes.find((s) => s.symbol.toLowerCase() === id || s.id === id);
+      if (match && match.id) {
+        id = match.id;
+      }
+      const res = await fetch(`${this.baseUrl}/assets/${id}`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      const asset = data.data;
+      if (!asset) return null;
+      return {
+        name: asset.name,
+        symbol: asset.symbol.toUpperCase(),
+        priceUsd: parseFloat(asset.priceUsd) || 0,
+        marketCap: parseFloat(asset.marketCapUsd),
+        volume24h: parseFloat(asset.volumeUsd24Hr),
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+};
+
+// src/providers/cryptocompare.ts
+var CryptoCompareProvider = class {
+  name = "CryptoCompare";
+  baseUrl = "https://min-api.cryptocompare.com/data";
+  async search(query) {
+    return [];
+  }
+  async getPrice(symbol) {
+    try {
+      const sym = symbol.toUpperCase();
+      const res = await fetch(`${this.baseUrl}/price?fsym=${sym}&tsyms=USD`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      if (data.Response === "Error" || !data.USD) return null;
+      return {
+        symbol: sym,
+        priceUsd: data.USD,
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+  async getTokenInfo(symbol) {
+    try {
+      const sym = symbol.toUpperCase();
+      const res = await fetch(`${this.baseUrl}/pricemultifull?fsyms=${sym}&tsyms=USD`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      if (!data.RAW || !data.RAW[sym] || !data.RAW[sym].USD) return null;
+      const raw = data.RAW[sym].USD;
+      return {
+        name: sym,
+        // CryptoCompare doesn't give full name in this endpoint
+        symbol: sym,
+        priceUsd: raw.PRICE || 0,
+        marketCap: raw.MKTCAP,
+        volume24h: raw.TOTALVOLUME24HTO,
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+};
+
+// src/Crypull.ts
+var Crypull = class {
+  providers;
+  // Standard free providers
+  coinGecko = new CoinGeckoProvider();
+  dexScreener = new DexScreenerProvider();
+  geckoTerminal = new GeckoTerminalProvider();
+  binance = new BinanceProvider();
+  coinpaprika = new CoinpaprikaProvider();
+  coincap = new CoinCapProvider();
+  cryptoCompare = new CryptoCompareProvider();
+  constructor(options) {
+    this.providers = options?.providers || [
+      this.binance,
+      this.coinGecko,
+      this.coinpaprika,
+      this.coincap,
+      this.dexScreener,
+      this.geckoTerminal,
+      this.cryptoCompare
+    ];
+  }
+  isAddress(query) {
+    return query.startsWith("0x") && query.length === 42 || query.length > 30;
+  }
+  /**
+   * Search for a token or coin across multiple providers in parallel
+   */
+  async search(query) {
+    const promises = [
+      this.coinGecko.search(query),
+      this.dexScreener.search(query),
+      this.coinpaprika.search(query),
+      this.coincap.search(query)
+    ];
+    const results = await Promise.allSettled(promises);
+    const combined = [];
+    for (const res of results) {
+      if (res.status === "fulfilled" && res.value) {
+        combined.push(...res.value);
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    return combined.filter((item) => {
+      const key = `${item.symbol}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+  /**
+   * Get the current price of a cryptocurrency
+   * @param query Can be a symbol (e.g., 'BTC') or a contract address
+   * @param network Optional network for DEX addresses (e.g., 'eth', 'bsc')
+   */
+  async price(query, network) {
+    if (this.isAddress(query)) {
+      let res = await this.dexScreener.getPrice(query);
+      if (res) return res;
+      if (network) {
+        res = await this.geckoTerminal.getPrice(query, network);
+        if (res) return res;
+      }
+    } else {
+      let res = await this.binance.getPrice(query);
+      if (res) return res;
+      res = await this.coincap.getPrice(query);
+      if (res) return res;
+      res = await this.coinGecko.getPrice(query);
+      if (res) return res;
+      res = await this.coinpaprika.getPrice(query);
+      if (res) return res;
+      res = await this.cryptoCompare.getPrice(query);
+      if (res) return res;
+    }
+    return null;
+  }
+  /**
+   * Get detailed token info (market cap, volume, liquidity, etc.)
+   * @param query Can be a symbol (e.g., 'BTC') or a contract address
+   * @param network Optional network for DEX addresses
+   */
+  async info(query, network) {
+    if (this.isAddress(query)) {
+      let res = await this.dexScreener.getTokenInfo(query);
+      if (res) return res;
+      if (network) {
+        res = await this.geckoTerminal.getTokenInfo(query, network);
+        if (res) return res;
+      }
+    } else {
+      let res = await this.coinGecko.getTokenInfo(query);
+      if (res) return res;
+      res = await this.coinpaprika.getTokenInfo(query);
+      if (res) return res;
+      res = await this.coincap.getTokenInfo(query);
+      if (res) return res;
+      res = await this.binance.getTokenInfo(query);
+      if (res) return res;
+      res = await this.cryptoCompare.getTokenInfo(query);
+      if (res) return res;
+    }
+    return null;
+  }
+  /**
+   * Get global market data
+   */
+  async market() {
+    try {
+      const res = await fetch(`https://api.coingecko.com/api/v3/global`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      const d = data.data;
+      return {
+        totalMarketCapUsd: d.total_market_cap.usd,
+        totalVolume24hUsd: d.total_volume.usd,
+        bitcoinDominancePercentage: d.market_cap_percentage.btc,
+        ethereumDominancePercentage: d.market_cap_percentage.eth,
+        activeCryptocurrencies: d.active_cryptocurrencies,
+        lastUpdated: d.updated_at * 1e3
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+  /**
+   * Get trending coins
+   */
+  async trending() {
+    try {
+      const res = await fetch(`https://api.coingecko.com/api/v3/search/trending`);
+      if (!res.ok) return [];
+      const data = await res.json();
+      return data.coins.slice(0, 10).map((c) => ({
+        id: c.item.id,
+        name: c.item.name,
+        symbol: c.item.symbol.toUpperCase(),
+        marketCapRank: c.item.market_cap_rank,
+        priceUsd: c.item.data?.price,
+        priceChange24h: c.item.data?.price_change_percentage_24h?.usd,
+        volume24h: c.item.data?.total_volume
+      }));
+    } catch (e) {
+      return [];
+    }
+  }
+  /**
+   * Get top 50 coins by market cap
+   */
+  async top() {
+    try {
+      const res = await fetch(`https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&order=market_cap_desc&per_page=50&page=1&sparkline=false`);
+      if (!res.ok) return [];
+      const data = await res.json();
+      return data.map((c) => ({
+        id: c.id,
+        name: c.name,
+        symbol: c.symbol.toUpperCase(),
+        marketCapRank: c.market_cap_rank,
+        priceUsd: c.current_price,
+        marketCap: c.market_cap,
+        volume24h: c.total_volume,
+        priceChange24h: c.price_change_percentage_24h
+      }));
+    } catch (e) {
+      return [];
+    }
+  }
+  /**
+   * Get fear and greed index
+   */
+  async sentiment() {
+    try {
+      const res = await fetch(`https://api.alternative.me/fng/?limit=1`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      const item = data.data[0];
+      return {
+        value: parseInt(item.value),
+        classification: item.value_classification,
+        lastUpdated: parseInt(item.timestamp) * 1e3
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+  /**
+   * Get current ethereum gas prices (in Gwei)
+   */
+  async gas() {
+    try {
+      const res = await fetch(`https://api.etherscan.io/api?module=gastracker&action=gasoracle`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      if (data.status !== "1") return null;
+      return {
+        network: "Ethereum",
+        low: parseFloat(data.result.SafeGasPrice),
+        average: parseFloat(data.result.ProposeGasPrice),
+        high: parseFloat(data.result.FastGasPrice),
+        baseFee: parseFloat(data.result.suggestBaseFee)
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+  /**
+   * Get historical chart data for a coin
+   * @param query Coin symbol or ID
+   * @param days Number of days (e.g. 1, 7, 30)
+   */
+  async chart(query, days = 7) {
+    try {
+      let id = query.toLowerCase();
+      const searchRes = await this.coinGecko.search(id);
+      const match = searchRes.find((s) => s.symbol.toLowerCase() === id || s.id === id);
+      if (match && match.id) {
+        id = match.id;
+      }
+      const res = await fetch(`https://api.coingecko.com/api/v3/coins/${id}/market_chart?vs_currency=usd&days=${days}`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      if (!data.prices || data.prices.length === 0) return null;
+      const prices = data.prices.map((p) => p[1]);
+      const timestamps = data.prices.map((p) => p[0]);
+      return {
+        prices,
+        timestamps,
+        minPrice: Math.min(...prices),
+        maxPrice: Math.max(...prices)
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+};
+
+// src/index.ts
+var crypull = new Crypull();
+
+// src/cli.ts
+var program = new Command();
+program.name("crypull").description("A human-friendly CLI to fetch crypto prices and info from multiple providers").version("1.0.0");
+program.command("price <query>").description("Get the current price of a cryptocurrency (symbol or contract address)").action(async (query) => {
+  console.log(pc.cyan(`
+Fetching price for ${pc.bold(query)}...`));
+  const data = await crypull.price(query);
+  if (!data) {
+    console.log(pc.red(`
+\u2716 Could not find price for "${query}".`));
+    return;
+  }
+  console.log(pc.green(`
+\u2714 Success! Found via ${pc.bold(data.source)}`));
+  console.log(pc.white(`----------------------------------------`));
+  console.log(`${pc.gray("Symbol:")}    ${pc.yellow(pc.bold(data.symbol))}`);
+  console.log(`${pc.gray("Price:")}     ${pc.green("$" + data.priceUsd.toLocaleString(void 0, { maximumFractionDigits: 6 }))}`);
+  console.log(`${pc.gray("Updated:")}   ${new Date(data.lastUpdated).toLocaleTimeString()}`);
+  console.log(pc.white(`----------------------------------------
+`));
+});
+program.command("info <query>").description("Get detailed info about a cryptocurrency (market cap, volume, FDV, etc.)").action(async (query) => {
+  console.log(pc.cyan(`
+Fetching detailed info for ${pc.bold(query)}...`));
+  const data = await crypull.info(query);
+  if (!data) {
+    console.log(pc.red(`
+\u2716 Could not find info for "${query}".`));
+    return;
+  }
+  console.log(pc.green(`
+\u2714 Success! Found via ${pc.bold(data.source)}`));
+  console.log(pc.white(`----------------------------------------`));
+  console.log(`${pc.gray("Name:")}      ${pc.white(pc.bold(data.name))}`);
+  console.log(`${pc.gray("Symbol:")}    ${pc.yellow(pc.bold(data.symbol))}`);
+  console.log(`${pc.gray("Price:")}     ${pc.green("$" + data.priceUsd.toLocaleString(void 0, { maximumFractionDigits: 6 }))}`);
+  if (data.marketCap) {
+    console.log(`${pc.gray("MarketCap:")} ${pc.white("$" + data.marketCap.toLocaleString())}`);
+  }
+  if (data.marketCapRank) {
+    console.log(`${pc.gray("Rank:")}      ${pc.magenta("#" + data.marketCapRank)}`);
+  }
+  if (data.fdv) {
+    console.log(`${pc.gray("FDV:")}       ${pc.white("$" + data.fdv.toLocaleString())}`);
+  }
+  if (data.circulatingSupply) {
+    console.log(`${pc.gray("Circ. Sup:")} ${pc.white(data.circulatingSupply.toLocaleString())}`);
+  }
+  if (data.totalSupply) {
+    console.log(`${pc.gray("Total Sup:")} ${pc.white(data.totalSupply.toLocaleString())}`);
+  }
+  if (data.maxSupply) {
+    console.log(`${pc.gray("Max Sup:")}   ${pc.white(data.maxSupply.toLocaleString())}`);
+  }
+  if (data.volume24h) {
+    console.log(`${pc.gray("24h Vol:")}   ${pc.white("$" + data.volume24h.toLocaleString())}`);
+  }
+  if (data.priceChangePercentage24h !== void 0) {
+    const pc24 = data.priceChangePercentage24h;
+    const color = pc24 >= 0 ? pc.green : pc.red;
+    console.log(`${pc.gray("24h %:")}     ${color(pc24.toFixed(2) + "%")}`);
+  }
+  if (data.liquidityUsd) {
+    console.log(`${pc.gray("Liquidity:")} ${pc.white("$" + data.liquidityUsd.toLocaleString())}`);
+  }
+  if (data.ath) {
+    console.log(`${pc.gray("ATH:")}       ${pc.green("$" + data.ath.toLocaleString())} ${data.athDate ? pc.gray(`(${new Date(data.athDate).toLocaleDateString()})`) : ""}`);
+  }
+  if (data.atl) {
+    console.log(`${pc.gray("ATL:")}       ${pc.red("$" + data.atl.toLocaleString())} ${data.atlDate ? pc.gray(`(${new Date(data.atlDate).toLocaleDateString()})`) : ""}`);
+  }
+  if (data.network) {
+    console.log(`${pc.gray("Network:")}   ${pc.magenta(data.network)}`);
+  }
+  if (data.address) {
+    console.log(`${pc.gray("Address:")}   ${pc.gray(data.address)}`);
+  }
+  if (data.links && Object.values(data.links).some((l) => !!l)) {
+    console.log(pc.white(`
+--- Links ---`));
+    if (data.links.website) console.log(`${pc.gray("Website:")}   ${pc.blue(data.links.website)}`);
+    if (data.links.twitter) console.log(`${pc.gray("Twitter:")}   ${pc.blue(data.links.twitter)}`);
+    if (data.links.telegram) console.log(`${pc.gray("Telegram:")}  ${pc.blue(data.links.telegram)}`);
+    if (data.links.discord) console.log(`${pc.gray("Discord:")}   ${pc.blue(data.links.discord)}`);
+    if (data.links.github) console.log(`${pc.gray("GitHub:")}    ${pc.blue(data.links.github)}`);
+  }
+  if (data.description && data.description.length > 0) {
+    console.log(pc.white(`
+--- Description ---`));
+    const desc = data.description.replace(/(<([^>]+)>)/gi, "");
+    const truncated = desc.length > 300 ? desc.substring(0, 300) + "..." : desc;
+    console.log(pc.gray(truncated));
+  }
+  if (data.pairs && data.pairs.length > 0) {
+    console.log(pc.white(`
+--- Top Trading Pairs ---`));
+    data.pairs.slice(0, 5).forEach((p, i) => {
+      const title = `${p.baseTokenSymbol}/${p.quoteTokenSymbol}`;
+      const priceStr = p.priceUsd ? `$${p.priceUsd.toLocaleString(void 0, { maximumFractionDigits: 6 })}` : "N/A";
+      const volStr = p.volume24h ? `$${p.volume24h.toLocaleString(void 0, { maximumFractionDigits: 0 })}` : "N/A";
+      console.log(`${pc.blue(String(i + 1) + ".")} ${pc.yellow(title.padEnd(12, " "))} | ${pc.green(priceStr.padEnd(12, " "))} | Vol: ${pc.white(volStr)} | DEX: ${pc.magenta(p.dexId)}`);
+    });
+  }
+  console.log(pc.white(`
+----------------------------------------`));
+  console.log(`${pc.gray("Updated:")}   ${new Date(data.lastUpdated).toLocaleTimeString()}`);
+  console.log(pc.white(`----------------------------------------
+`));
+});
+program.command("top").description("Show top 50 cryptocurrencies by market cap").action(async () => {
+  console.log(pc.cyan(`
+Fetching top 50 cryptocurrencies...`));
+  const results = await crypull.top();
+  if (!results || results.length === 0) {
+    console.log(pc.red(`
+\u2716 Could not fetch top coins at this time.`));
+    return;
+  }
+  console.log(pc.green(`
+\u2714 Top 50 Cryptocurrencies:`));
+  console.log(pc.white(`----------------------------------------`));
+  results.forEach((res, i) => {
+    const priceStr = res.priceUsd ? `$${res.priceUsd.toLocaleString(void 0, { maximumFractionDigits: 6 })}` : "N/A";
+    const mcapStr = res.marketCap ? `$${res.marketCap.toLocaleString()}` : "N/A";
+    let changeStr = "";
+    if (res.priceChange24h !== void 0 && res.priceChange24h !== null) {
+      const color = res.priceChange24h >= 0 ? pc.green : pc.red;
+      changeStr = color(`(${res.priceChange24h >= 0 ? "+" : ""}${res.priceChange24h.toFixed(2)}%)`);
+    }
+    console.log(`${pc.blue(String(i + 1).padStart(2, " "))}. ${pc.yellow(pc.bold(res.symbol.padEnd(8, " ")))} | ${pc.green(priceStr.padEnd(12, " "))} ${changeStr.padEnd(15, " ")} | Mcap: ${pc.white(mcapStr)}`);
+  });
+  console.log(pc.white(`----------------------------------------
+`));
+});
+program.command("search <query>").description("Search for tokens or coins across multiple providers").action(async (query) => {
+  console.log(pc.cyan(`
+Searching for ${pc.bold(query)}...`));
+  const results = await crypull.search(query);
+  if (!results || results.length === 0) {
+    console.log(pc.red(`
+\u2716 No results found for "${query}".`));
+    return;
+  }
+  console.log(pc.green(`
+\u2714 Found ${results.length} results:`));
+  console.log(pc.white(`----------------------------------------`));
+  results.forEach((res, i) => {
+    console.log(`${pc.blue(String(i + 1).padStart(2, " "))}. ${pc.yellow(pc.bold(res.symbol.padEnd(8, " ")))} | ${pc.white(res.name)} ${pc.gray(`(via ${res.source})`)}`);
+    if (res.network) {
+      console.log(`    ${pc.gray("Network:")} ${pc.magenta(res.network)}`);
+    }
+    if (res.id && res.id.length > 20) {
+      console.log(`    ${pc.gray("Address:")} ${pc.gray(res.id)}`);
+    }
+  });
+  console.log(pc.white(`----------------------------------------
+`));
+});
+program.command("trending").description("Show top 10 trending coins/tokens right now").action(async () => {
+  console.log(pc.cyan(`
+Fetching top trending coins...`));
+  const results = await crypull.trending();
+  if (!results || results.length === 0) {
+    console.log(pc.red(`
+\u2716 Could not fetch trending data at this time.`));
+    return;
+  }
+  console.log(pc.green(`
+\u2714 Top 10 Trending Coins:`));
+  console.log(pc.white(`----------------------------------------`));
+  results.forEach((res, i) => {
+    const priceStr = res.priceUsd ? `$${res.priceUsd.toLocaleString(void 0, { maximumFractionDigits: 6 })}` : "N/A";
+    let changeStr = "";
+    if (res.priceChange24h !== void 0) {
+      const color = res.priceChange24h >= 0 ? pc.green : pc.red;
+      changeStr = color(`(${res.priceChange24h >= 0 ? "+" : ""}${res.priceChange24h.toFixed(2)}%)`);
+    }
+    const rankStr = res.marketCapRank ? pc.magenta(`#${res.marketCapRank}`) : "";
+    console.log(`${pc.blue(String(i + 1).padStart(2, " "))}. ${pc.yellow(pc.bold(res.symbol.padEnd(8, " ")))} | ${pc.green(priceStr.padEnd(12, " "))} ${changeStr.padEnd(15, " ")} | ${rankStr}`);
+  });
+  console.log(pc.white(`----------------------------------------
+`));
+});
+program.command("market").description("Show global cryptocurrency market overview").action(async () => {
+  console.log(pc.cyan(`
+Fetching global market data...`));
+  const data = await crypull.market();
+  if (!data) {
+    console.log(pc.red(`
+\u2716 Could not fetch global market data at this time.`));
+    return;
+  }
+  console.log(pc.green(`
+\u2714 Global Market Overview:`));
+  console.log(pc.white(`----------------------------------------`));
+  console.log(`${pc.gray("Total Market Cap:")} ${pc.white("$" + data.totalMarketCapUsd.toLocaleString())}`);
+  console.log(`${pc.gray("24h Volume:")}       ${pc.white("$" + data.totalVolume24hUsd.toLocaleString())}`);
+  console.log(`${pc.gray("BTC Dominance:")}    ${pc.yellow(data.bitcoinDominancePercentage.toFixed(2) + "%")}`);
+  console.log(`${pc.gray("ETH Dominance:")}    ${pc.blue(data.ethereumDominancePercentage.toFixed(2) + "%")}`);
+  console.log(`${pc.gray("Active Coins:")}     ${pc.white(data.activeCryptocurrencies.toLocaleString())}`);
+  console.log(pc.white(`----------------------------------------`));
+  console.log(`${pc.gray("Updated:")}          ${new Date(data.lastUpdated).toLocaleTimeString()}`);
+  console.log(pc.white(`----------------------------------------
+`));
+});
+program.command("sentiment").description("Show current Crypto Fear & Greed Index").action(async () => {
+  console.log(pc.cyan(`
+Fetching Fear & Greed Index...`));
+  const data = await crypull.sentiment();
+  if (!data) {
+    console.log(pc.red(`
+\u2716 Could not fetch sentiment data at this time.`));
+    return;
+  }
+  const value = data.value;
+  let color = pc.white;
+  if (value <= 25) color = pc.red;
+  else if (value <= 45) color = pc.yellow;
+  else if (value <= 55) color = pc.white;
+  else if (value <= 75) color = pc.green;
+  else color = pc.blue;
+  console.log(pc.green(`
+\u2714 Current Market Sentiment:`));
+  console.log(pc.white(`----------------------------------------`));
+  console.log(`${pc.gray("Score:")}          ${color(pc.bold(value.toString()) + " / 100")}`);
+  console.log(`${pc.gray("Classification:")} ${color(pc.bold(data.classification))}`);
+  console.log(pc.white(`----------------------------------------
+`));
+});
+program.command("gas").description("Show current Ethereum network gas prices").action(async () => {
+  console.log(pc.cyan(`
+Fetching network gas prices...`));
+  const data = await crypull.gas();
+  if (!data) {
+    console.log(pc.red(`
+\u2716 Could not fetch gas prices at this time.`));
+    return;
+  }
+  console.log(pc.green(`
+\u2714 ${data.network} Gas Tracker (Gwei):`));
+  console.log(pc.white(`----------------------------------------`));
+  console.log(`${pc.gray("Low (Safe):")}     ${pc.green(data.low + " gwei")}`);
+  console.log(`${pc.gray("Average:")}        ${pc.yellow(data.average + " gwei")}`);
+  console.log(`${pc.gray("High (Fast):")}    ${pc.red(data.high + " gwei")}`);
+  if (data.baseFee) {
+    console.log(`${pc.gray("Base Fee:")}       ${pc.white(data.baseFee + " gwei")}`);
+  }
+  console.log(pc.white(`----------------------------------------
+`));
+});
+program.command("chart <query>").description("Draw a terminal ASCII chart of historical prices").option("-d, --days <days>", "Number of days to chart", "7").action(async (query, options) => {
+  const days = parseInt(options.days) || 7;
+  console.log(pc.cyan(`
+Fetching ${days}-day chart data for ${pc.bold(query)}...`));
+  const data = await crypull.chart(query, days);
+  if (!data || !data.prices || data.prices.length === 0) {
+    console.log(pc.red(`
+\u2716 Could not fetch chart data for "${query}". Note: Charts may only be available for major coins.`));
+    return;
+  }
+  const firstPrice = data.prices[0];
+  const lastPrice = data.prices[data.prices.length - 1];
+  const isUp = lastPrice >= firstPrice;
+  const chartConfig = {
+    colors: [isUp ? asciichart.lightgreen : asciichart.lightred],
+    height: 10
+  };
+  console.log(pc.green(`
+\u2714 ${days}-Day Chart for ${query.toUpperCase()}:`));
+  console.log(pc.gray(`Min: $${data.minPrice.toLocaleString(void 0, { maximumFractionDigits: 6 })} | Max: $${data.maxPrice.toLocaleString(void 0, { maximumFractionDigits: 6 })}`));
+  console.log(pc.white(`
+` + asciichart.plot(data.prices, chartConfig) + `
+`));
+});
+program.parse(process.argv);
+//# sourceMappingURL=cli.mjs.map
+//# sourceMappingURL=cli.mjs.map