stock-scanner-mcp 1.16.2 → 1.16.3

package/dist/chunk-5IWY6HOQ.js

@@ -0,0 +1,3995 @@
+// src/modules/tradingview/index.ts
+import { z } from "zod";
+
+// src/shared/types.ts
+var SEC_USER_AGENT = "StockScanner contact@example.com";
+function errorResult(message, code = "INTERNAL_ERROR") {
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        error: true,
+        code,
+        message
+      }, null, 2)
+    }],
+    isError: true
+  };
+}
+function successResult(text) {
+  return {
+    content: [{ type: "text", text }]
+  };
+}
+
+// src/shared/http.ts
+var DEFAULT_TIMEOUT_MS = 1e4;
+var SENSITIVE_PARAMS = /([?&])(apikey|api_key|token|secret|key)=[^&]*/gi;
+var DEFAULT_HEADERS = {
+  "User-Agent": "stock-scanner-mcp/0.1.0 (+https://github.com/yyordanov-tradu/stock-scanner-mcp)"
+};
+function sanitizeUrl(url) {
+  return url.replace(SENSITIVE_PARAMS, "$1$2=REDACTED");
+}
+function sanitizeError(err) {
+  if (err instanceof Error) {
+    const sanitized = new Error(sanitizeUrl(err.message));
+    sanitized.stack = err.stack;
+    return sanitized;
+  }
+  return new Error(sanitizeUrl(String(err)));
+}
+async function httpPost(url, body, options = {}) {
+  const { timeoutMs = DEFAULT_TIMEOUT_MS, headers = {} } = options;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...DEFAULT_HEADERS,
+        ...headers
+      },
+      body: JSON.stringify(body),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new Error(
+        `HTTP ${response.status}: ${response.statusText} -- ${text.slice(0, 200)}`
+      );
+    }
+    return await response.json();
+  } catch (err) {
+    throw sanitizeError(err);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function httpGet(url, options = {}) {
+  const {
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    headers = {},
+    responseType = "json"
+  } = options;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        ...DEFAULT_HEADERS,
+        ...headers
+      },
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new Error(
+        `HTTP ${response.status}: ${response.statusText} -- ${text.slice(0, 200)}`
+      );
+    }
+    if (responseType === "text") {
+      return await response.text();
+    }
+    return await response.json();
+  } catch (err) {
+    throw sanitizeError(err);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function httpFetch(url, init) {
+  return fetch(url, init);
+}
+
+// src/modules/tradingview/columns.ts
+var STOCK_COLUMNS = [
+  "close",
+  "change",
+  "change_abs",
+  "volume",
+  "market_cap_basic",
+  "price_earnings_ttm",
+  "earnings_per_share_basic_ttm",
+  "number_of_employees",
+  "sector",
+  "description",
+  "name",
+  "type",
+  "subtype",
+  "update_mode",
+  "exchange",
+  "pricescale",
+  "minmov",
+  "fractional",
+  "minmove2",
+  "premarket_close",
+  "premarket_change",
+  "premarket_change_abs",
+  "premarket_volume",
+  "postmarket_close",
+  "postmarket_change",
+  "postmarket_change_abs",
+  "postmarket_volume",
+  "earnings_release_date",
+  "earnings_release_next_date",
+  "dividend_yield_recent",
+  "return_on_equity_fq",
+  "total_revenue_fq",
+  "net_income_fq",
+  "total_assets_fq",
+  "total_debt_fq",
+  "Recommend.All",
+  "Recommend.MA",
+  "Recommend.Other",
+  "RSI",
+  "RSI[1]",
+  "Stoch.K",
+  "Stoch.D",
+  "Stoch.K[1]",
+  "Stoch.D[1]",
+  "CCI20",
+  "CCI20[1]",
+  "ADX",
+  "ADX+DI",
+  "ADX-DI",
+  "ADX+DI[1]",
+  "ADX-DI[1]",
+  "AO",
+  "AO[1]",
+  "AO[2]",
+  "Mom",
+  "Mom[1]",
+  "MACD.macd",
+  "MACD.signal",
+  "BB.lower",
+  "BB.upper",
+  "Pivot.M.Classic.S3",
+  "Pivot.M.Classic.S2",
+  "Pivot.M.Classic.S1",
+  "Pivot.M.Classic.Middle",
+  "Pivot.M.Classic.R1",
+  "Pivot.M.Classic.R2",
+  "Pivot.M.Classic.R3",
+  "EMA5",
+  "EMA10",
+  "EMA20",
+  "EMA30",
+  "EMA50",
+  "EMA100",
+  "EMA200",
+  "SMA5",
+  "SMA10",
+  "SMA20",
+  "SMA30",
+  "SMA50",
+  "SMA100",
+  "SMA200"
+];
+var STOCK_TIMEFRAMES = {
+  "1m": "|1",
+  "5m": "|5",
+  "15m": "|15",
+  "1h": "|60",
+  "4h": "|240",
+  "1W": "|1W",
+  "1M": "|1M",
+  "1d": ""
+};
+
+// src/modules/tradingview/scanner.ts
+var BASE_URL = "https://scanner.tradingview.com";
+var META_COLUMNS = /* @__PURE__ */ new Set([
+  "name",
+  "description",
+  "type",
+  "subtype",
+  "exchange",
+  "sector",
+  "update_mode",
+  "pricescale",
+  "minmov",
+  "fractional",
+  "minmove2",
+  "number_of_employees",
+  "market_cap_basic",
+  "premarket_close",
+  "premarket_change",
+  "premarket_change_abs",
+  "premarket_volume",
+  "postmarket_close",
+  "postmarket_change",
+  "postmarket_change_abs",
+  "postmarket_volume",
+  "earnings_release_date",
+  "earnings_release_next_date",
+  "dividend_yield_recent",
+  "return_on_equity_fq",
+  "total_revenue_fq",
+  "net_income_fq",
+  "total_assets_fq",
+  "total_debt_fq"
+]);
+function applyTimeframeSuffix(columns, timeframe) {
+  const suffix = STOCK_TIMEFRAMES[timeframe] ?? "";
+  if (!suffix) return columns;
+  return columns.map((col) => META_COLUMNS.has(col) ? col : col + suffix);
+}
+async function scanStocks(request) {
+  const rawColumns = request.columns ?? STOCK_COLUMNS;
+  const timeframe = request.timeframe ?? "1d";
+  const columns = applyTimeframeSuffix(rawColumns, timeframe);
+  const body = {
+    columns,
+    options: { lang: "en" },
+    range: [0, request.limit ?? 50],
+    sort: request.sort ?? { sortBy: columns[0], sortOrder: "desc" }
+  };
+  if (request.tickers) {
+    body.symbols = { tickers: request.tickers };
+  } else {
+    if (request.filters && request.filters.length > 0) {
+      body.filter = request.filters.map((f) => ({
+        left: f.left,
+        operation: f.operation,
+        right: f.right
+      }));
+    }
+    if (request.exchange) {
+      body.markets = [request.exchange];
+    }
+  }
+  const market = request.market ?? "america";
+  const response = await httpPost(
+    `${BASE_URL}/${market}/scan`,
+    body
+  );
+  return response.data.map((row) => {
+    const data = {};
+    rawColumns.forEach((col, i) => {
+      data[col] = row.d[i] ?? null;
+    });
+    return { symbol: row.s, data };
+  });
+}
+
+// src/shared/resolver.ts
+function resolveTicker(input, defaultExchange = "NASDAQ") {
+  const cleaned = input.trim().toUpperCase();
+  if (cleaned.includes(":")) {
+    const [ex, tick] = cleaned.split(":");
+    return {
+      ticker: tick,
+      exchange: ex,
+      full: cleaned,
+      isCrypto: ex === "BINANCE" || ex === "COINBASE" || ex === "KRAKEN"
+      // Simple heuristic
+    };
+  }
+  const commonCrypto = /* @__PURE__ */ new Set(["BTC", "ETH", "SOL", "XRP", "ADA", "DOGE", "DOT"]);
+  if (commonCrypto.has(cleaned)) {
+    return {
+      ticker: cleaned,
+      full: cleaned,
+      isCrypto: true
+    };
+  }
+  return {
+    ticker: cleaned,
+    exchange: defaultExchange,
+    full: `${defaultExchange}:${cleaned}`,
+    isCrypto: false
+  };
+}
+
+// src/shared/utils.ts
+function withMetadata(handler, options) {
+  return async (args) => {
+    try {
+      const result = await handler(args);
+      result._meta = {
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+        source: options.source,
+        dataDelay: options.dataDelay
+      };
+      return result;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      let code = "INTERNAL_ERROR";
+      if (message.includes("HTTP 429")) code = "RATE_LIMITED";
+      if (message.includes("HTTP 403")) code = "FORBIDDEN";
+      if (message.includes("fetch failed")) code = "FETCH_FAILED";
+      if (message.includes("not found")) code = "NOT_FOUND";
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: true,
+            code,
+            message,
+            retryable: code === "RATE_LIMITED" || code === "FETCH_FAILED"
+          }, null, 2)
+        }],
+        isError: true,
+        _meta: {
+          lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+          source: options.source
+        }
+      };
+    }
+  };
+}
+
+// src/modules/tradingview/index.ts
+function createTradingviewModule() {
+  const metadata3 = { source: "tradingview", dataDelay: "15min" };
+  return {
+    name: "tradingview",
+    description: "TradingView stock scanner \u2014 prices, technicals, and screener filters for US equities",
+    requiredEnvVars: [],
+    tools: [
+      {
+        name: "tradingview_scan",
+        description: "Scan US stocks with custom filters (price > X, RSI < 30, etc.). Returns up to `limit` rows with the requested columns.",
+        inputSchema: z.object({
+          exchange: z.string().optional().describe("Exchange filter, e.g. NASDAQ, NYSE, AMEX"),
+          filters: z.array(z.object({
+            left: z.string(),
+            operation: z.enum(["greater", "less", "equal", "in_range", "not_in_range", "crosses", "crosses_above", "crosses_below"]),
+            right: z.union([z.number(), z.string(), z.array(z.number())])
+          })).optional().describe("Scanner filters"),
+          columns: z.array(z.string()).optional().describe("Columns to return (default: all 66)"),
+          timeframe: z.string().optional().describe("Timeframe: 1m, 5m, 15m, 1h, 4h, 1d (default), 1W, 1M"),
+          limit: z.number().int().optional().describe("Max rows (default 50)")
+        }),
+        readOnly: true,
+        handler: withMetadata(async (input) => {
+          const rows = await scanStocks(input);
+          return successResult(JSON.stringify(rows, null, 2));
+        }, metadata3)
+      },
+      {
+        name: "tradingview_compare_stocks",
+        description: "Returns price, change, market cap, P/E, EPS, revenue, dividend yield, RSI, and analyst recommendation rating (-1 sell to +1 buy) for 2-5 stocks. Revenue growth rate and analyst price targets are not available.",
+        inputSchema: z.object({
+          tickers: z.array(z.string()).min(2).max(5).describe("2-5 stock tickers to compare (e.g. AAPL, MSFT)")
+        }),
+        readOnly: true,
+        handler: withMetadata(async (input) => {
+          const resolvedTickers = input.tickers.map((t) => resolveTicker(t).full);
+          const columns = [
+            "name",
+            "description",
+            "close",
+            "change",
+            "market_cap_basic",
+            "price_earnings_ttm",
+            "earnings_per_share_basic_ttm",
+            "total_revenue_fq",
+            "dividend_yield_recent",
+            "RSI",
+            "Recommend.All"
+          ];
+          const rows = await scanStocks({
+            tickers: resolvedTickers,
+            columns
+          });
+          return successResult(JSON.stringify(rows, null, 2));
+        }, metadata3)
+      },
+      {
+        name: "tradingview_quote",
+        description: "Get a 15-minute delayed quote for one or more stock tickers (e.g. 'AAPL' or 'NASDAQ:AAPL'). Returns price, change, volume, market cap, and pre-market/after-hours data when available. Data is delayed ~15 minutes during market hours \u2014 use finnhub_quote for real-time prices if available. If a ticker returns empty results, retry with the correct exchange prefix (e.g. 'NYSE:CDE', 'AMEX:XYZ').",
+        inputSchema: z.object({
+          tickers: z.array(z.string()).describe("Stock tickers, e.g. ['AAPL', 'MSFT']")
+        }),
+        readOnly: true,
+        handler: withMetadata(async (input) => {
+          const resolvedTickers = input.tickers.map((t) => resolveTicker(t).full);
+          const rows = await scanStocks({
+            tickers: resolvedTickers,
+            columns: [
+              "close",
+              "change",
+              "change_abs",
+              "volume",
+              "market_cap_basic",
+              "name",
+              "description",
+              "premarket_close",
+              "premarket_change",
+              "premarket_change_abs",
+              "premarket_volume",
+              "postmarket_close",
+              "postmarket_change",
+              "postmarket_change_abs",
+              "postmarket_volume"
+            ]
+          });
+          return successResult(JSON.stringify(rows, null, 2));
+        }, metadata3)
+      },
+      {
+        name: "tradingview_technicals",
+        description: "Get technical indicators (RSI, MACD, moving averages, pivot points, etc.) for one or more stock tickers. If a ticker returns empty results, retry with the correct exchange prefix (e.g. 'NYSE:CDE', 'AMEX:XYZ').",
+        inputSchema: z.object({
+          tickers: z.array(z.string()).describe("Stock tickers, e.g. ['AAPL', 'IBM']"),
+          timeframe: z.string().optional().describe("Timeframe (default: 1d)")
+        }),
+        readOnly: true,
+        handler: withMetadata(async (input) => {
+          const technicalCols = [
+            "Recommend.All",
+            "Recommend.MA",
+            "Recommend.Other",
+            "RSI",
+            "Stoch.K",
+            "Stoch.D",
+            "CCI20",
+            "ADX",
+            "ADX+DI",
+            "ADX-DI",
+            "AO",
+            "Mom",
+            "MACD.macd",
+            "MACD.signal",
+            "BB.lower",
+            "BB.upper",
+            "EMA20",
+            "EMA50",
+            "EMA200",
+            "SMA20",
+            "SMA50",
+            "SMA200",
+            "Pivot.M.Classic.S1",
+            "Pivot.M.Classic.Middle",
+            "Pivot.M.Classic.R1"
+          ];
+          const resolvedTickers = input.tickers.map((t) => resolveTicker(t).full);
+          const rows = await scanStocks({
+            tickers: resolvedTickers,
+            columns: technicalCols,
+            timeframe: input.timeframe
+          });
+          return successResult(JSON.stringify(rows, null, 2));
+        }, metadata3)
+      },
+      {
+        name: "tradingview_top_gainers",
+        description: "Get today's top gaining stocks by percentage change on a given exchange. Defaults to major US exchanges (NYSE, NASDAQ, AMEX) with market cap > $100M. OTC penny stocks excluded by default.",
+        inputSchema: z.object({
+          exchange: z.string().optional().describe("Exchange (default: all US)"),
+          include_otc: z.boolean().optional().describe("Whether to include OTC penny stocks (default: false)"),
+          limit: z.number().int().optional().describe("Max results (default 20)")
+        }),
+        readOnly: true,
+        handler: withMetadata(async (input) => {
+          const filters = [];
+          if (!input.include_otc) {
+            filters.push({ left: "market_cap_basic", operation: "greater", right: 1e8 });
+            filters.push({ left: "volume", operation: "greater", right: 1e5 });
+          }
+          const rows = await scanStocks({
+            exchange: input.exchange,
+            columns: ["close", "change", "change_abs", "volume", "name", "description", "market_cap_basic"],
+            filters,
+            limit: input.limit ?? 20
+          });
+          return successResult(JSON.stringify(rows, null, 2));
+        }, metadata3)
+      },
+      {
+        name: "tradingview_top_losers",
+        description: "Get today's top losing stocks by percentage change on a given exchange. Defaults to major US exchanges (NYSE, NASDAQ, AMEX) with market cap > $100M. OTC penny stocks excluded by default.",
+        inputSchema: z.object({
+          exchange: z.string().optional().describe("Exchange (default: all US)"),
+          include_otc: z.boolean().optional().describe("Whether to include OTC penny stocks (default: false)"),
+          limit: z.number().int().optional().describe("Max results (default 20)")
+        }),
+        readOnly: true,
+        handler: withMetadata(async (input) => {
+          const filters = [];
+          if (!input.include_otc) {
+            filters.push({ left: "market_cap_basic", operation: "greater", right: 1e8 });
+            filters.push({ left: "volume", operation: "greater", right: 1e5 });
+          }
+          const rows = await scanStocks({
+            exchange: input.exchange,
+            columns: ["close", "change", "change_abs", "volume", "name", "description", "market_cap_basic"],
+            filters,
+            limit: input.limit ?? 20,
+            sort: { sortBy: "change", sortOrder: "asc" }
+          });
+          return successResult(JSON.stringify(rows, null, 2));
+        }, metadata3)
+      },
+      {
+        name: "tradingview_top_volume",
+        description: "Get stocks with the highest trading volume today. Defaults to major US exchanges.",
+        inputSchema: z.object({
+          exchange: z.string().optional().describe("Exchange (default: all US)"),
+          include_otc: z.boolean().optional().describe("Whether to include OTC penny stocks (default: false)"),
+          limit: z.number().int().optional().describe("Max results (default 20)")
+        }),
+        readOnly: true,
+        handler: withMetadata(async (input) => {
+          const filters = [];
+          if (!input.include_otc) {
+            filters.push({ left: "market_cap_basic", operation: "greater", right: 1e8 });
+          }
+          const rows = await scanStocks({
+            exchange: input.exchange,
+            columns: ["volume", "close", "change", "name", "description", "market_cap_basic"],
+            filters,
+            limit: input.limit ?? 20
+          });
+          return successResult(JSON.stringify(rows, null, 2));
+        }, metadata3)
+      },
+      {
+        name: "tradingview_market_indices",
+        description: "Get real-time values for major market indices: VIX (volatility), S&P 500, NASDAQ Composite, and Dow Jones. Essential for gauging broad market conditions, risk sentiment, and options pricing context.",
+        inputSchema: z.object({}),
+        readOnly: true,
+        handler: withMetadata(async () => {
+          const tickers = ["CBOE:VIX", "SP:SPX", "NASDAQ:NDX", "TVC:DJI"];
+          const columns = [
+            "close",
+            "change",
+            "change_abs",
+            "high",
+            "low",
+            "open",
+            "name",
+            "description"
+          ];
+          const rows = await scanStocks({ tickers, columns, market: "global" });
+          return successResult(JSON.stringify(rows, null, 2));
+        }, metadata3)
+      },
+      {
+        name: "tradingview_sector_performance",
+        description: "Get performance of S&P 500 sector ETFs (XLK, XLF, XLE, XLV, XLI, XLP, XLU, XLY, XLC, XLRE, XLB). Shows which sectors are leading or lagging today. Essential for sector rotation analysis.",
+        inputSchema: z.object({}),
+        readOnly: true,
+        handler: withMetadata(async () => {
+          const sectorEtfs = [
+            "AMEX:XLK",
+            "AMEX:XLF",
+            "AMEX:XLE",
+            "AMEX:XLV",
+            "AMEX:XLI",
+            "AMEX:XLP",
+            "AMEX:XLU",
+            "AMEX:XLY",
+            "AMEX:XLC",
+            "AMEX:XLRE",
+            "AMEX:XLB"
+          ];
+          const rows = await scanStocks({
+            tickers: sectorEtfs,
+            columns: [
+              "close",
+              "change",
+              "change_abs",
+              "volume",
+              "name",
+              "description",
+              "Perf.W",
+              "Perf.1M",
+              "Perf.3M",
+              "Perf.YTD"
+            ]
+          });
+          return successResult(JSON.stringify(rows, null, 2));
+        }, metadata3)
+      },
+      {
+        name: "tradingview_volume_breakout",
+        description: "Find stocks with unusual volume (current volume significantly above average). Defaults to major exchanges.",
+        inputSchema: z.object({
+          exchange: z.string().optional().describe("Exchange filter"),
+          limit: z.number().int().optional().describe("Max results (default 20)")
+        }),
+        readOnly: true,
+        handler: withMetadata(async (input) => {
+          const rows = await scanStocks({
+            exchange: input.exchange,
+            columns: ["volume", "relative_volume_10d_calc", "close", "change", "name", "description", "market_cap_basic", "RSI", "MACD.macd"],
+            filters: [
+              { left: "relative_volume_10d_calc", operation: "greater", right: 2 },
+              { left: "volume", operation: "greater", right: 1e6 },
+              { left: "market_cap_basic", operation: "greater", right: 1e8 }
+            ],
+            sort: { sortBy: "relative_volume_10d_calc", sortOrder: "desc" },
+            limit: input.limit ?? 20
+          });
+          return successResult(JSON.stringify(rows, null, 2));
+        }, metadata3)
+      }
+    ]
+  };
+}
+
+// src/modules/tradingview-crypto/index.ts
+import { z as z2 } from "zod";
+
+// src/modules/tradingview-crypto/columns.ts
+var CRYPTO_COLUMNS = [
+  "close",
+  "change",
+  "change_abs",
+  "volume",
+  "market_cap_calc",
+  "Recommend.All",
+  "Recommend.MA",
+  "Recommend.Other",
+  "RSI",
+  "MACD.macd",
+  "MACD.signal",
+  "Stoch.K",
+  "Stoch.D",
+  "BB.lower",
+  "BB.upper",
+  "EMA20",
+  "EMA50",
+  "EMA200",
+  "SMA20",
+  "SMA50",
+  "SMA200",
+  "description",
+  "name"
+];
+var CRYPTO_TIMEFRAMES = {
+  "1m": "|1",
+  "5m": "|5",
+  "15m": "|15",
+  "1h": "|60",
+  "4h": "|240",
+  "1W": "|1W",
+  "1M": "|1M",
+  "1d": ""
+};
+
+// src/modules/tradingview-crypto/scanner.ts
+var API_URL = "https://scanner.tradingview.com/crypto/scan";
+function applyTimeframeSuffix2(columns, timeframe) {
+  const suffix = CRYPTO_TIMEFRAMES[timeframe] ?? "";
+  if (!suffix) return columns;
+  const metaCols = ["name", "description"];
+  return columns.map((col) => metaCols.includes(col) ? col : col + suffix);
+}
+async function scanCrypto(request) {
+  const rawColumns = request.columns ?? CRYPTO_COLUMNS;
+  const timeframe = request.timeframe ?? "1d";
+  const columns = applyTimeframeSuffix2(rawColumns, timeframe);
+  const body = {
+    columns,
+    options: { lang: "en" },
+    range: [0, request.limit ?? 50],
+    sort: { sortBy: columns[0], sortOrder: "desc" }
+  };
+  if (request.tickers) {
+    body.symbols = { tickers: request.tickers };
+  } else {
+    if (request.filters && request.filters.length > 0) {
+      body.filter = request.filters.map((f) => ({
+        left: f.left,
+        operation: f.operation,
+        right: f.right
+      }));
+    }
+  }
+  const response = await httpPost(API_URL, body);
+  return response.data.map((row) => {
+    const data = {};
+    rawColumns.forEach((col, i) => {
+      data[col] = row.d[i] ?? null;
+    });
+    return { symbol: row.s, data };
+  });
+}
+
+// src/modules/tradingview-crypto/index.ts
+var MAJOR_EXCHANGES = ["BINANCE", "COINBASE", "KRAKEN", "OKX", "BYBIT", "BITSTAMP"];
+var MAJOR_ONLY_FILTERS = [
+  { left: "exchange", operation: "in_range", right: MAJOR_EXCHANGES },
+  { left: "volume", operation: "greater", right: 1e4 }
+  // $10k min volume to filter junk
+];
+function createTradingviewCryptoModule() {
+  const metadata3 = { source: "tradingview", dataDelay: "15min" };
+  return {
+    name: "tradingview-crypto",
+    description: "TradingView crypto scanner -- real-time quotes, technical analysis, and screening for cryptocurrency pairs",
+    requiredEnvVars: [],
+    tools: [
+      {
+        name: "crypto_scan",
+        description: "Scan cryptocurrency pairs using TradingView filters. Returns price, volume, and technical indicators.",
+        inputSchema: z2.object({
+          filters: z2.array(
+            z2.object({
+              left: z2.string().describe("Column name (e.g. 'close', 'RSI', 'volume')"),
+              operation: z2.string().describe("Comparison: 'greater', 'less', 'in_range', 'equal'"),
+              right: z2.union([z2.number(), z2.string(), z2.array(z2.number()), z2.array(z2.string())]).describe("Value to compare against")
+            })
+          ).optional().describe("Filter conditions combined with AND"),
+          major_only: z2.boolean().optional().describe("Only include major exchanges (default: true)"),
+          columns: z2.array(z2.string()).optional().describe("Columns to return (default: all 23)"),
+          timeframe: z2.string().optional().describe("Timeframe: '1m','5m','15m','1h','4h','1d','1W','1M'. Default: '1d'"),
+          limit: z2.number().optional().describe("Max results (default: 50, max: 200)")
+        }),
+        readOnly: true,
+        handler: withMetadata(async (params) => {
+          const majorOnly = params.major_only ?? true;
+          let filters = params.filters || [];
+          if (majorOnly) {
+            filters = [...MAJOR_ONLY_FILTERS, ...filters];
+          }
+          const rows = await scanCrypto({
+            filters,
+            columns: params.columns,
+            timeframe: params.timeframe,
+            limit: Math.min(params.limit ?? 50, 200)
+          });
+          return successResult(JSON.stringify(rows, null, 2));
+        }, metadata3)
+      },
+      {
+        name: "crypto_quote",
+        description: "Get real-time quotes for specific crypto pairs. Supports 'BTCUSDT' (defaults to BINANCE) or 'BINANCE:BTCUSDT'.",
+        inputSchema: z2.object({
+          symbols: z2.array(z2.string()).describe("Crypto pair symbols (e.g. ['BTCUSDT', 'ETHUSDT'])")
+        }),
+        readOnly: true,
+        handler: withMetadata(async (params) => {
+          const resolvedTickers = params.symbols.map((s) => {
+            const res = resolveTicker(s, "BINANCE");
+            return res.exchange ? `${res.exchange}:${res.ticker}` : `BINANCE:${res.ticker}`;
+          });
+          const rows = await scanCrypto({
+            tickers: resolvedTickers,
+            columns: [
+              "close",
+              "change",
+              "change_abs",
+              "volume",
+              "market_cap_calc",
+              "description"
+            ]
+          });
+          return successResult(JSON.stringify(rows, null, 2));
+        }, metadata3)
+      },
+      {
+        name: "crypto_technicals",
+        description: "Get technical analysis for crypto pairs. Supports 'BTCUSDT' or 'BINANCE:BTCUSDT'.",
+        inputSchema: z2.object({
+          symbols: z2.array(z2.string()).describe("Crypto symbols (e.g. ['BTCUSDT'])"),
+          timeframe: z2.string().optional().describe("Timeframe. Default: '1d'")
+        }),
+        readOnly: true,
+        handler: withMetadata(async (params) => {
+          const resolvedTickers = params.symbols.map((s) => {
+            const res = resolveTicker(s, "BINANCE");
+            return res.exchange ? `${res.exchange}:${res.ticker}` : `BINANCE:${res.ticker}`;
+          });
+          const rows = await scanCrypto({
+            tickers: resolvedTickers,
+            timeframe: params.timeframe,
+            columns: [
+              "Recommend.All",
+              "Recommend.MA",
+              "Recommend.Other",
+              "RSI",
+              "MACD.macd",
+              "MACD.signal",
+              "Stoch.K",
+              "Stoch.D",
+              "EMA20",
+              "EMA50",
+              "EMA200",
+              "SMA20",
+              "SMA50",
+              "SMA200",
+              "BB.lower",
+              "BB.upper",
+              "close"
+            ]
+          });
+          return successResult(JSON.stringify(rows, null, 2));
+        }, metadata3)
+      },
+      {
+        name: "crypto_top_gainers",
+        description: "Get top gaining cryptocurrency pairs by percentage change. Defaults to major exchanges and volume > $10k.",
+        inputSchema: z2.object({
+          exchange: z2.string().optional().describe("Specific exchange (e.g. BINANCE)"),
+          limit: z2.number().optional().describe("Number of results (default: 20, max: 50)")
+        }),
+        readOnly: true,
+        handler: withMetadata(async (params) => {
+          const filters = [{ left: "change", operation: "greater", right: 0 }];
+          if (params.exchange) {
+            filters.push({ left: "exchange", operation: "equal", right: params.exchange });
+          } else {
+            filters.push(...MAJOR_ONLY_FILTERS);
+          }
+          const rows = await scanCrypto({
+            filters,
+            columns: [
+              "close",
+              "change",
+              "change_abs",
+              "volume",
+              "market_cap_calc",
+              "description"
+            ],
+            limit: Math.min(params.limit ?? 20, 50)
+          });
+          return successResult(JSON.stringify(rows, null, 2));
+        }, metadata3)
+      }
+    ]
+  };
+}
+
+// src/modules/sec-edgar/index.ts
+import { z as z3 } from "zod";
+
+// src/shared/cache.ts
+var TtlCache = class {
+  store = /* @__PURE__ */ new Map();
+  ttlMs;
+  constructor(ttlMs) {
+    this.ttlMs = ttlMs;
+  }
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry) return void 0;
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return void 0;
+    }
+    return entry.value;
+  }
+  set(key, value) {
+    this.store.set(key, {
+      value,
+      expiresAt: Date.now() + this.ttlMs
+    });
+  }
+  async getOrFetch(key, fetcher) {
+    const cached = this.get(key);
+    if (cached !== void 0) return cached;
+    const value = await fetcher();
+    this.set(key, value);
+    return value;
+  }
+};
+
+// src/modules/sec-edgar/cik-mapper.ts
+var TICKER_MAP_URL = "https://www.sec.gov/files/company_tickers.json";
+var tickerToCik = null;
+var initPromise = null;
+async function initTickerMap() {
+  if (tickerToCik) return;
+  if (initPromise) return initPromise;
+  initPromise = (async () => {
+    try {
+      const data = await httpGet(TICKER_MAP_URL, {
+        headers: { "User-Agent": SEC_USER_AGENT }
+      });
+      tickerToCik = /* @__PURE__ */ new Map();
+      for (const entry of Object.values(data)) {
+        const cik = String(entry.cik_str).padStart(10, "0");
+        tickerToCik.set(entry.ticker.toUpperCase(), cik);
+      }
+    } catch (err) {
+      initPromise = null;
+      throw err;
+    }
+  })();
+  return initPromise;
+}
+async function getCikForTicker(ticker) {
+  await initTickerMap();
+  return tickerToCik?.get(ticker.toUpperCase()) ?? null;
+}
+
+// src/modules/sec-edgar/client.ts
+var EFTS_BASE = "https://efts.sec.gov/LATEST/search-index";
+var DATA_BASE = "https://data.sec.gov/api/xbrl/companyfacts";
+var CACHE_TTL = 5 * 60 * 1e3;
+var cache = new TtlCache(CACHE_TTL);
+async function searchFilings(params) {
+  const searchParams = new URLSearchParams();
+  searchParams.set("q", params.query);
+  if (params.dateRange) searchParams.set("dateRange", params.dateRange);
+  if (params.forms?.length)
+    searchParams.set("forms", params.forms.join(","));
+  if (params.tickers?.length)
+    searchParams.set("tickers", params.tickers.join(","));
+  searchParams.set("from", "0");
+  searchParams.set("size", String(params.limit ?? 20));
+  const url = `${EFTS_BASE}?${searchParams.toString()}`;
+  const cached = cache.get(url);
+  if (cached) return cached;
+  const response = await httpGet(url, {
+    headers: { "User-Agent": SEC_USER_AGENT }
+  });
+  const filings = response.hits.hits.map((hit) => {
+    const cik = hit._id.replace(/-/g, "").slice(0, 10);
+    return {
+      accessionNumber: hit._id,
+      filedAt: hit._source.file_date,
+      formType: hit._source.form_type,
+      entityName: hit._source.entity_name,
+      ticker: hit._source.tickers ?? "",
+      description: hit._source.file_description ?? "",
+      documentUrl: `https://www.sec.gov/Archives/edgar/data/${cik}/${hit._id}.txt`
+    };
+  });
+  filings.sort((a, b) => b.filedAt.localeCompare(a.filedAt));
+  cache.set(url, filings);
+  return filings;
+}
+async function getCompanyFilings(params) {
+  const filings = await searchFilings({
+    query: params.ticker,
+    forms: params.forms,
+    limit: params.limit
+  });
+  const ticker = params.ticker.toUpperCase();
+  for (const f of filings) {
+    if (!f.ticker) f.ticker = ticker;
+  }
+  return filings;
+}
+async function getCompanyFacts(ticker) {
+  const cik = await getCikForTicker(ticker);
+  if (!cik) throw new Error(`Could not find CIK for ticker ${ticker}`);
+  const cacheKey = `facts-summary:${cik}`;
+  const cached = cache.get(cacheKey);
+  if (cached) return cached;
+  const url = `${DATA_BASE}/CIK${cik}.json`;
+  const data = await httpGet(url, {
+    headers: { "User-Agent": SEC_USER_AGENT }
+  });
+  const usGaap = data.facts["us-gaap"] || {};
+  const keyMetricsMap = {
+    Revenue: [
+      "SalesRevenueNet",
+      "Revenues",
+      "TotalRevenues",
+      "RevenueFromContractWithCustomerExcludingAssessedTax",
+      "NetRevenueV2"
+    ],
+    NetIncome: [
+      "NetIncomeLoss",
+      "NetIncomeLossAvailableToCommonStockholdersBasic",
+      "ProfitLoss"
+    ],
+    Assets: ["Assets"],
+    Liabilities: ["Liabilities"],
+    EPS: ["EarningsPerShareBasic", "EarningsPerShareDiluted"],
+    Cash: [
+      "CashAndCashEquivalentsAtCarryingValue",
+      "CashCashEquivalentsRestrictedCashAndRestrictedCashEquivalents"
+    ]
+  };
+  const summarizedMetrics = {};
+  for (const [label, names] of Object.entries(keyMetricsMap)) {
+    for (const name of names) {
+      if (usGaap[name]) {
+        const units = usGaap[name].units;
+        const unitKey = Object.keys(units)[0];
+        const values = [...units[unitKey]];
+        values.sort((a, b) => b.end.localeCompare(a.end));
+        summarizedMetrics[label] = values[0];
+        break;
+      }
+    }
+  }
+  const result = {
+    ticker: ticker.toUpperCase(),
+    cik,
+    entityName: data.entityName,
+    metrics: summarizedMetrics
+  };
+  cache.set(cacheKey, result);
+  return result;
+}
+function mapTransactionCode(code) {
+  switch (code) {
+    case "P":
+      return "BUY";
+    case "S":
+      return "SELL";
+    case "M":
+      return "OPTION_EXERCISE";
+    case "A":
+      return "GRANT";
+    case "F":
+      return "TAX_WITHHOLDING";
+    default:
+      return "OTHER";
+  }
+}
+async function parseForm4Filing(filing) {
+  try {
+    const docContent = await httpGet(filing.documentUrl, {
+      headers: { "User-Agent": SEC_USER_AGENT },
+      responseType: "text"
+    });
+    if (!docContent.includes("<ownershipDocument")) return [];
+    const reporter = docContent.match(/<rptOwnerName>([^<]+)<\/rptOwnerName>/)?.[1] ?? "Unknown";
+    const title = docContent.match(/<rptOwnerOfficerTitle>([^<]+)<\/rptOwnerOfficerTitle>/)?.[1] ?? "N/A";
+    const transactions = [];
+    const transRegex = /<(non)?DerivativeTransaction>([\s\S]*?)<\/(non)?DerivativeTransaction>/g;
+    let match;
+    while ((match = transRegex.exec(docContent)) !== null) {
+      const trans = match[2];
+      const security = trans.match(/<securityTitle>\s*<value>([^<]+)<\/value>/)?.[1] ?? "Unknown";
+      const transDate = trans.match(/<transactionDate>\s*<value>([^<]+)<\/value>/)?.[1] ?? filing.filedAt;
+      const transCode = trans.match(/<transactionCode>([^<]+)<\/transactionCode>/)?.[1] ?? trans.match(/<transactionAcquiredDisposedCode>\s*<value>([^<]+)<\/value>/)?.[1] ?? "";
+      const shares = trans.match(/<transactionShares>\s*<value>([^<]+)<\/value>/)?.[1];
+      const price = trans.match(/<transactionPricePerShare>\s*<value>([^<]+)<\/value>/)?.[1];
+      transactions.push({
+        reporter,
+        title,
+        date: transDate,
+        security,
+        type: mapTransactionCode(transCode),
+        shares: shares ? parseFloat(shares) : 0,
+        price: price ? parseFloat(price) : 0
+      });
+    }
+    if (transactions.length === 0) {
+      console.error(`Warning: No transactions parsed for Form 4 ${filing.accessionNumber}`);
+    }
+    return transactions;
+  } catch (err) {
+    console.error(`Failed to parse Form 4 ${filing.accessionNumber}:`, err);
+    return [];
+  }
+}
+async function getInsiderTrades(ticker, limit = 10) {
+  const cik = await getCikForTicker(ticker);
+  if (!cik) throw new Error(`Could not find CIK for ticker ${ticker}`);
+  const cacheKey = `insider-trades-v2:${cik}:${limit}`;
+  const cached = cache.get(cacheKey);
+  if (cached) return cached;
+  const url = `https://data.sec.gov/submissions/CIK${cik}.json`;
+  const data = await httpGet(url, {
+    headers: { "User-Agent": SEC_USER_AGENT }
+  });
+  const filings = [];
+  const recent = data.filings.recent;
+  const count = recent.form.length;
+  const thirtyDaysAgo = /* @__PURE__ */ new Date();
+  thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+  const cutoffStr = thirtyDaysAgo.toISOString().split("T")[0];
+  for (let i = 0; i < count && filings.length < limit; i++) {
+    const form = recent.form[i];
+    const filingDate = recent.filingDate[i];
+    if (filingDate < cutoffStr && filings.length > 0) break;
+    if (form === "3" || form === "4" || form === "5") {
+      const accession = recent.accessionNumber[i];
+      const primaryDoc = recent.primaryDocument[i];
+      const accNoDashes = accession.replace(/-/g, "");
+      const rawDoc = primaryDoc.replace(/^xsl[^/]+\//, "");
+      const docUrl = `https://www.sec.gov/Archives/edgar/data/${Number(cik)}/${accNoDashes}/${rawDoc}`;
+      filings.push({
+        accessionNumber: accession,
+        filedAt: filingDate,
+        formType: form,
+        entityName: data.name,
+        ticker: ticker.toUpperCase(),
+        description: recent.primaryDocDescription[i] || "",
+        documentUrl: docUrl
+      });
+    }
+  }
+  const form4s = filings.filter((f) => f.formType === "4");
+  const results = await Promise.allSettled(form4s.map((f) => parseForm4Filing(f)));
+  let form4Idx = 0;
+  for (let i = 0; i < filings.length; i++) {
+    if (filings[i].formType === "4") {
+      const result = results[form4Idx++];
+      if (result.status === "fulfilled") {
+        filings[i].parsedTransactions = result.value;
+      }
+    }
+  }
+  cache.set(cacheKey, filings);
+  return filings;
+}
+async function getInstitutionalHoldings(query, limit = 10) {
+  const filings = await searchFilings({
+    query,
+    forms: ["13F-HR", "13F-HR/A", "13F-NT", "13F-NT/A"],
+    limit
+  });
+  if (/^[A-Za-z]{1,5}$/.test(query.trim())) {
+    const ticker = query.trim().toUpperCase();
+    for (const f of filings) {
+      if (!f.ticker) f.ticker = ticker;
+    }
+  }
+  return filings;
+}
+async function getOwnershipFilings(ticker, limit = 10) {
+  const filings = await searchFilings({
+    query: ticker,
+    forms: ["SC 13D", "SC 13D/A", "SC 13G", "SC 13G/A"],
+    limit
+  });
+  const upperTicker = ticker.toUpperCase();
+  for (const f of filings) {
+    if (!f.ticker) f.ticker = upperTicker;
+  }
+  return filings;
+}
+
+// src/modules/sec-edgar/index.ts
+function createSecEdgarModule() {
+  const metadata3 = { source: "sec-edgar", dataDelay: "real-time" };
+  return {
+    name: "sec-edgar",
+    description: "SEC EDGAR filing search -- full-text search and company filing lookup via EFTS",
+    requiredEnvVars: [],
+    tools: [
+      {
+        name: "edgar_search",
+        description: "Search SEC EDGAR filings by keyword. Best for finding mentions of specific trends, technologies, or events across all companies. Returns metadata including accession numbers, form types, and direct sec.gov links.",
+        inputSchema: z3.object({
+          query: z3.string().describe(
+            "Keyword or phrase to search for (e.g. 'lithium mining', 'share repurchase program')"
+          ),
+          dateRange: z3.string().optional().describe("Date range as 'YYYY-MM-DD,YYYY-MM-DD'"),
+          forms: z3.array(z3.string()).optional().describe("Form types to filter (e.g. ['10-K', '10-Q', '8-K'])"),
+          tickers: z3.array(z3.string()).optional().describe("Company tickers to filter (e.g. ['AAPL', 'MSFT'])"),
+          limit: z3.number().optional().describe("Max results (default: 20, max: 50)")
+        }),
+        readOnly: true,
+        handler: withMetadata(async (params) => {
+          const resolvedTickers = params.tickers?.map((t) => resolveTicker(t).ticker);
+          const filings = await searchFilings({
+            query: params.query,
+            dateRange: params.dateRange,
+            forms: params.forms,
+            tickers: resolvedTickers,
+            limit: Math.min(params.limit ?? 20, 50)
+          });
+          return successResult(JSON.stringify(filings, null, 2));
+        }, metadata3)
+      },
+      {
+        name: "edgar_company_filings",
+        description: "Retrieve the most recent official filings for a specific company. Use this to find a company's latest 10-K (annual), 10-Q (quarterly), or 8-K (current events) reports.",
+        inputSchema: z3.object({
+          ticker: z3.string().describe("Stock ticker symbol (e.g. 'AAPL')"),
+          forms: z3.array(z3.string()).optional().describe("Form types (e.g. ['10-K', '10-Q']). Default: all."),
+          limit: z3.number().optional().describe("Max results (default: 10, max: 50)")
+        }),
+        readOnly: true,
+        handler: withMetadata(async (params) => {
+          const ticker = resolveTicker(params.ticker).ticker;
+          const filings = await getCompanyFilings({
+            ticker,
+            forms: params.forms,
+            limit: Math.min(params.limit ?? 10, 50)
+          });
+          const enriched = filings.map((f) => ({ ...f, ticker }));
+          return successResult(JSON.stringify(enriched, null, 2));
+        }, metadata3)
+      },
+      {
+        name: "edgar_company_facts",
+        description: "Retrieve high-fidelity financial metrics (Revenue, Net Income, EPS, Assets, Liabilities) directly from SEC XBRL data. This is more reliable than extracting numbers from text filings.",
+        inputSchema: z3.object({
+          ticker: z3.string().describe("Stock ticker symbol (e.g. 'AAPL')")
+        }),
+        readOnly: true,
+        handler: withMetadata(async (params) => {
+          const ticker = resolveTicker(params.ticker).ticker;
+          const facts = await getCompanyFacts(ticker);
+          return successResult(JSON.stringify(facts, null, 2));
+        }, metadata3)
+      },
+      {
+        name: "edgar_insider_trades",
+        description: "Monitor legal stock trades made by company executives and directors (Forms 3, 4, 5). Returns detailed transaction data including insider names, titles, buy/sell type, share amounts, and prices.",
+        inputSchema: z3.object({
+          ticker: z3.string().describe("Stock ticker symbol (e.g. 'AAPL')"),
+          limit: z3.number().optional().describe("Max results (default: 10)")
+        }),
+        readOnly: true,
+        handler: withMetadata(async (params) => {
+          const ticker = resolveTicker(params.ticker).ticker;
+          const trades = await getInsiderTrades(
+            ticker,
+            params.limit
+          );
+          const enriched = trades.map((t) => ({ ...t, ticker }));
+          return successResult(JSON.stringify(enriched, null, 2));
+        }, metadata3)
+      },
+      {
+        name: "edgar_institutional_holdings",
+        description: "Track 'big money' moves by searching Form 13F filings. Use to find what hedge funds and institutional managers (e.g. 'Berkshire Hathaway') are holding or what firms own a specific ticker.",
+        inputSchema: z3.object({
+          query: z3.string().describe("Stock ticker (e.g. 'AAPL') or institutional manager name (e.g. 'Berkshire Hathaway')"),
+          limit: z3.number().optional().describe("Max results (default: 10)")
+        }),
+        readOnly: true,
+        handler: withMetadata(async (params) => {
+          const res = resolveTicker(params.query);
+          const query = res.ticker;
+          const holdings = await getInstitutionalHoldings(
+            query,
+            params.limit
+          );
+          return successResult(JSON.stringify(holdings, null, 2));
+        }, metadata3)
+      },
+      {
+        name: "edgar_ownership_filings",
+        description: "Monitor significant changes in company ownership (5%+ stakes). Use 13D and 13G filings to identify activist investors (e.g. Carl Icahn, Ryan Cohen) entering or exiting a stock.",
+        inputSchema: z3.object({
+          ticker: z3.string().describe("Stock ticker symbol (e.g. 'AAPL')"),
+          limit: z3.number().optional().describe("Max results (default: 10)")
+        }),
+        readOnly: true,
+        handler: withMetadata(async (params) => {
+          const ticker = resolveTicker(params.ticker).ticker;
+          const filings = await getOwnershipFilings(
+            ticker,
+            params.limit
+          );
+          const enriched = filings.map((f) => ({ ...f, ticker }));
+          return successResult(JSON.stringify(enriched, null, 2));
+        }, metadata3)
+      }
+    ]
+  };
+}
+
+// src/modules/coingecko/index.ts
+import { z as z4 } from "zod";
+
+// src/modules/coingecko/client.ts
+var BASE_URL2 = "https://api.coingecko.com/api/v3";
+var CACHE_TTL2 = 60 * 1e3;
+var cache2 = new TtlCache(CACHE_TTL2);
+async function getCoinDetail(coinId) {
+  const cacheKey = `coin:${coinId}`;
+  const cached = cache2.get(cacheKey);
+  if (cached) return cached;
+  const data = await httpGet(`${BASE_URL2}/coins/${coinId}?localization=false&tickers=false&market_data=true&community_data=false&developer_data=false`);
+  const coin = {
+    id: data.id,
+    symbol: data.symbol,
+    name: data.name,
+    currentPrice: data.market_data.current_price.usd,
+    marketCap: data.market_data.market_cap.usd,
+    priceChange24h: data.market_data.price_change_24h,
+    priceChangePercent24h: data.market_data.price_change_percentage_24h,
+    totalVolume: data.market_data.total_volume.usd,
+    high24h: data.market_data.high_24h.usd,
+    low24h: data.market_data.low_24h.usd,
+    ath: data.market_data.ath.usd,
+    athChangePercent: data.market_data.ath_change_percentage.usd,
+    description: (data.description.en || "").slice(0, 500)
+  };
+  cache2.set(cacheKey, coin);
+  return coin;
+}
+async function getTrending() {
+  const cacheKey = "trending";
+  const cached = cache2.get(cacheKey);
+  if (cached) return cached;
+  const data = await httpGet(`${BASE_URL2}/search/trending`);
+  const trending = data.coins.map((c) => ({
+    id: c.item.id,
+    name: c.item.name,
+    symbol: c.item.symbol,
+    marketCapRank: c.item.market_cap_rank,
+    priceBtc: c.item.price_btc,
+    score: c.item.score
+  }));
+  cache2.set(cacheKey, trending);
+  return trending;
+}
+async function getGlobal() {
+  const cacheKey = "global";
+  const cached = cache2.get(cacheKey);
+  if (cached) return cached;
+  const data = await httpGet(`${BASE_URL2}/global`);
+  const global = {
+    totalMarketCap: data.data.total_market_cap.usd,
+    totalVolume24h: data.data.total_volume.usd,
+    btcDominance: data.data.market_cap_percentage.btc,
+    ethDominance: data.data.market_cap_percentage.eth,
+    activeCryptocurrencies: data.data.active_cryptocurrencies,
+    marketCapChangePercent24h: data.data.market_cap_change_percentage_24h_usd
+  };
+  cache2.set(cacheKey, global);
+  return global;
+}
+
+// src/modules/coingecko/index.ts
+var coinTool = {
+  name: "coingecko_coin",
+  description: "Get detailed cryptocurrency info from CoinGecko. Use slug IDs (e.g. 'bitcoin', 'ethereum', 'solana'), NOT ticker symbols.",
+  inputSchema: z4.object({
+    coinId: z4.string().describe("CoinGecko coin ID / slug (e.g. 'bitcoin', 'ethereum', 'cardano')")
+  }),
+  readOnly: true,
+  handler: withMetadata(async (params) => {
+    const coin = await getCoinDetail(params.coinId);
+    return successResult(JSON.stringify(coin, null, 2));
+  }, { source: "coingecko", dataDelay: "real-time" })
+};
+var trendingTool = {
+  name: "coingecko_trending",
+  description: "Get trending cryptocurrencies on CoinGecko (top 7 by search popularity in last 24h).",
+  inputSchema: z4.object({}),
+  readOnly: true,
+  handler: withMetadata(async () => {
+    const trending = await getTrending();
+    return successResult(JSON.stringify(trending, null, 2));
+  }, { source: "coingecko", dataDelay: "real-time" })
+};
+var globalTool = {
+  name: "coingecko_global",
+  description: "Get global cryptocurrency market statistics: total market cap, 24h volume, BTC/ETH dominance.",
+  inputSchema: z4.object({}),
+  readOnly: true,
+  handler: withMetadata(async () => {
+    const global = await getGlobal();
+    return successResult(JSON.stringify(global, null, 2));
+  }, { source: "coingecko", dataDelay: "real-time" })
+};
+function createCoingeckoModule() {
+  return {
+    name: "coingecko",
+    description: "CoinGecko crypto data -- coin details, trending coins, and global market stats",
+    requiredEnvVars: [],
+    tools: [coinTool, trendingTool, globalTool]
+  };
+}
+
+// src/modules/finnhub/index.ts
+import { z as z5 } from "zod";
+
+// src/modules/finnhub/client.ts
+var BASE_URL3 = "https://finnhub.io/api/v1";
+var CACHE_TTL3 = 5 * 60 * 1e3;
+var cache3 = new TtlCache(CACHE_TTL3);
+async function getMarketNews(apiKey, category = "general", limit = 20) {
+  const cacheKey = `news:${category}:${limit}`;
+  const cached = cache3.get(cacheKey);
+  if (cached) return cached;
+  const articles = await httpGet(`${BASE_URL3}/news?category=${encodeURIComponent(category)}`, {
+    headers: { "X-Finnhub-Token": apiKey }
+  });
+  const result = articles.slice(0, limit).map((a) => ({
+    category: a.category,
+    datetime: a.datetime,
+    headline: a.headline,
+    id: a.id,
+    source: a.source,
+    summary: a.summary.slice(0, 300),
+    url: a.url,
+    related: a.related
+  }));
+  cache3.set(cacheKey, result);
+  return result;
+}
+async function getCompanyNews(apiKey, symbol, from, to, limit = 20) {
+  const cacheKey = `company-news:${symbol}:${from}:${to}:${limit}`;
+  const cached = cache3.get(cacheKey);
+  if (cached) return cached;
+  const articles = await httpGet(
+    `${BASE_URL3}/company-news?symbol=${encodeURIComponent(symbol)}&from=${from}&to=${to}`,
+    { headers: { "X-Finnhub-Token": apiKey } }
+  );
+  const result = articles.slice(0, limit).map((a) => ({
+    category: a.category,
+    datetime: a.datetime,
+    headline: a.headline,
+    source: a.source,
+    summary: a.summary.slice(0, 300),
+    url: a.url
+  }));
+  cache3.set(cacheKey, result);
+  return result;
+}
+async function getEarningsCalendar(apiKey, from, to, symbol) {
+  const cacheKey = `earnings:${from}:${to}:${symbol ?? "all"}`;
+  const cached = cache3.get(cacheKey);
+  if (cached) return cached;
+  let url = `${BASE_URL3}/calendar/earnings?from=${from}&to=${to}`;
+  if (symbol) {
+    url += `&symbol=${encodeURIComponent(symbol)}`;
+  }
+  const data = await httpGet(
+    url,
+    { headers: { "X-Finnhub-Token": apiKey } }
+  );
+  const result = data.earningsCalendar;
+  cache3.set(cacheKey, result);
+  return result;
+}
+async function getAnalystRecommendations(apiKey, symbol) {
+  const cacheKey = `recommendations:${symbol}`;
+  const cached = cache3.get(cacheKey);
+  if (cached) return cached;
+  const data = await httpGet(
+    `${BASE_URL3}/stock/recommendation?symbol=${encodeURIComponent(symbol)}`,
+    { headers: { "X-Finnhub-Token": apiKey } }
+  );
+  cache3.set(cacheKey, data);
+  return data;
+}
+async function getCompanyProfile(apiKey, symbol) {
+  const cacheKey = `profile:${symbol}`;
+  const cached = cache3.get(cacheKey);
+  if (cached) return cached;
+  const data = await httpGet(
+    `${BASE_URL3}/stock/profile2?symbol=${encodeURIComponent(symbol)}`,
+    { headers: { "X-Finnhub-Token": apiKey } }
+  );
+  cache3.set(cacheKey, data);
+  return data;
+}
+async function getPeers(apiKey, symbol) {
+  const cacheKey = `peers:${symbol}`;
+  const cached = cache3.get(cacheKey);
+  if (cached) return cached;
+  const data = await httpGet(
+    `${BASE_URL3}/stock/peers?symbol=${encodeURIComponent(symbol)}`,
+    { headers: { "X-Finnhub-Token": apiKey } }
+  );
+  cache3.set(cacheKey, data);
+  return data;
+}
+async function getMarketStatus(apiKey, exchange) {
+  const cacheKey = `market-status:${exchange}`;
+  const cached = cache3.get(cacheKey);
+  if (cached) return cached;
+  const data = await httpGet(
+    `${BASE_URL3}/stock/market-status?exchange=${encodeURIComponent(exchange)}`,
+    { headers: { "X-Finnhub-Token": apiKey } }
+  );
+  cache3.set(cacheKey, data);
+  return data;
+}
+async function getQuote(apiKey, symbol) {
+  const cacheKey = `quote:${symbol}`;
+  const cached = cache3.get(cacheKey);
+  if (cached) return cached;
+  const data = await httpGet(
+    `${BASE_URL3}/quote?symbol=${encodeURIComponent(symbol)}`,
+    { headers: { "X-Finnhub-Token": apiKey } }
+  );
+  cache3.set(cacheKey, data);
+  return data;
+}
+async function getShortInterest(apiKey, symbol) {
+  const cacheKey = `short-interest:${symbol}`;
+  const cached = cache3.get(cacheKey);
+  if (cached) return cached;
+  const data = await httpGet(
+    `${BASE_URL3}/stock/metric?symbol=${encodeURIComponent(symbol)}&metric=all`,
+    { headers: { "X-Finnhub-Token": apiKey } }
+  );
+  const result = {
+    symbol: data.symbol,
+    metric: {
+      "52WeekHigh": data.metric?.["52WeekHigh"],
+      "52WeekLow": data.metric?.["52WeekLow"],
+      "shortInterest": data.metric?.["shortInterest"],
+      "shortRatio": data.metric?.["shortRatio"],
+      "shortPercentOfFloat": data.metric?.["shortPercentOfFloat"]
+    }
+  };
+  cache3.set(cacheKey, result);
+  return result;
+}
+
+// src/modules/finnhub/index.ts
+function createFinnhubModule(apiKey) {
+  const metadata3 = { source: "finnhub", dataDelay: "real-time" };
+  const marketNewsTool = {
+    name: "finnhub_market_news",
+    description: "Get latest market news by category (general, forex, crypto, merger). Rate limit: 60 calls/min (free tier).",
+    inputSchema: z5.object({
+      category: z5.string().optional().describe("Category: general, forex, crypto, merger"),
+      limit: z5.number().optional().describe("Max results (default: 20, max: 50)")
+    }),
+    readOnly: true,
+    handler: withMetadata(async (params) => {
+      const news = await getMarketNews(
+        apiKey,
+        params.category,
+        Math.min(params.limit ?? 20, 50)
+      );
+      return successResult(JSON.stringify(news, null, 2));
+    }, metadata3)
+  };
+  const companyNewsTool = {
+    name: "finnhub_company_news",
+    description: "Get recent news for a specific company by ticker symbol. Rate limit: 60 calls/min (free tier).",
+    inputSchema: z5.object({
+      symbol: z5.string().describe("Stock symbol (e.g. 'AAPL')"),
+      from: z5.string().describe("From date (YYYY-MM-DD)"),
+      to: z5.string().describe("To date (YYYY-MM-DD)"),
+      limit: z5.number().optional().describe("Max results (default: 20, max: 50)")
+    }),
+    readOnly: true,
+    handler: withMetadata(async (params) => {
+      const symbol = resolveTicker(params.symbol).ticker;
+      const news = await getCompanyNews(
+        apiKey,
+        symbol,
+        params.from,
+        params.to,
+        Math.min(params.limit ?? 20, 50)
+      );
+      return successResult(JSON.stringify(news, null, 2));
+    }, metadata3)
+  };
+  const earningsCalendarTool = {
+    name: "finnhub_earnings_calendar",
+    description: "Get upcoming or historical earnings reports within a date range. Rate limit: 60 calls/min (free tier).",
+    inputSchema: z5.object({
+      from: z5.string().describe("Start date (YYYY-MM-DD)"),
+      to: z5.string().describe("End date (YYYY-MM-DD)"),
+      symbol: z5.string().optional().describe("Filter by specific symbol"),
+      limit: z5.number().optional().describe("Max results to return (default: 20, max: 100)")
+    }),
+    readOnly: true,
+    handler: withMetadata(async (params) => {
+      const symbol = params.symbol ? resolveTicker(params.symbol).ticker : void 0;
+      const results = await getEarningsCalendar(
+        apiKey,
+        params.from,
+        params.to,
+        symbol
+      );
+      const limit = Math.min(params.limit ?? 20, 100);
+      const capped = results.slice(0, limit);
+      return successResult(JSON.stringify(capped, null, 2));
+    }, metadata3)
+  };
+  const analystRatingsTool = {
+    name: "finnhub_analyst_ratings",
+    description: "Get analyst consensus recommendations for a stock. Returns counts of Strong Buy, Buy, Hold, Sell, Strong Sell ratings and the last 4 months of rating history. Rate limit: 60 calls/min (free tier).",
+    inputSchema: z5.object({
+      symbol: z5.string().describe("Stock symbol (e.g. 'AAPL')")
+    }),
+    readOnly: true,
+    handler: withMetadata(async (params) => {
+      const symbol = resolveTicker(params.symbol).ticker;
+      const recs = await getAnalystRecommendations(apiKey, symbol);
+      return successResult(JSON.stringify({
+        symbol,
+        currentConsensus: recs[0] || null,
+        recommendationHistory: recs.slice(0, 4)
+      }, null, 2));
+    }, metadata3)
+  };
+  const companyProfileTool = {
+    name: "finnhub_company_profile",
+    description: "Get company profile: name, industry, market cap, IPO date, logo, website, share count, and exchange. Rate limit: 60 calls/min (free tier).",
+    inputSchema: z5.object({
+      symbol: z5.string().describe("Stock symbol (e.g. 'AAPL')")
+    }),
+    readOnly: true,
+    handler: withMetadata(async (params) => {
+      const symbol = resolveTicker(params.symbol).ticker;
+      const profile = await getCompanyProfile(apiKey, symbol);
+      return successResult(JSON.stringify(profile, null, 2));
+    }, metadata3)
+  };
+  const peersTool = {
+    name: "finnhub_peers",
+    description: "Get a list of peer/comparable companies in the same industry for a given stock. Rate limit: 60 calls/min (free tier).",
+    inputSchema: z5.object({
+      symbol: z5.string().describe("Stock symbol (e.g. 'AAPL')")
+    }),
+    readOnly: true,
+    handler: withMetadata(async (params) => {
+      const symbol = resolveTicker(params.symbol).ticker;
+      const peers = await getPeers(apiKey, symbol);
+      return successResult(JSON.stringify({ symbol, peers }, null, 2));
+    }, metadata3)
+  };
+  const marketStatusTool = {
+    name: "finnhub_market_status",
+    description: "Check if a stock exchange is currently open, and what session it is in (pre-market, regular, post-market). Rate limit: 60 calls/min (free tier).",
+    inputSchema: z5.object({
+      exchange: z5.string().default("US").describe("Exchange code. Examples: US, L (London), T (Tokyo), HK")
+    }),
+    readOnly: true,
+    handler: withMetadata(async (params) => {
+      const exchange = params.exchange;
+      const status = await getMarketStatus(apiKey, exchange);
+      return successResult(JSON.stringify(status, null, 2));
+    }, metadata3)
+  };
+  const quoteTool = {
+    name: "finnhub_quote",
+    description: "Get a real-time stock quote from Finnhub (requires API key): current price, change, percent change, day high/low, open, and previous close. Preferred over tradingview_quote during market hours for live prices. Use tradingview_quote as a keyless fallback when Finnhub is unavailable. Rate limit: 60 calls/min (free tier).",
+    inputSchema: z5.object({
+      symbol: z5.string().describe("Stock symbol (e.g. 'AAPL')")
+    }),
+    readOnly: true,
+    handler: withMetadata(async (params) => {
+      const symbol = resolveTicker(params.symbol).ticker;
+      const q = await getQuote(apiKey, symbol);
+      return successResult(JSON.stringify({
+        symbol,
+        price: q.c,
+        change: q.d,
+        changePercent: q.dp,
+        dayHigh: q.h,
+        dayLow: q.l,
+        open: q.o,
+        previousClose: q.pc
+      }, null, 2));
+    }, metadata3)
+  };
+  const shortInterestTool = {
+    name: "finnhub_short_interest",
+    description: "Get short interest and other key financial metrics for a stock. Rate limit: 60 calls/min (free tier).",
+    inputSchema: z5.object({
+      symbol: z5.string().describe("Stock symbol (e.g. 'AAPL')")
+    }),
+    readOnly: true,
+    handler: withMetadata(async (params) => {
+      const symbol = resolveTicker(params.symbol).ticker;
+      const metrics = await getShortInterest(apiKey, symbol);
+      return successResult(JSON.stringify(metrics, null, 2));
+    }, metadata3)
+  };
+  return {
+    name: "finnhub",
+    description: "Finnhub market data: quotes, company profiles, peers, news, earnings, analyst ratings, short interest, and market status",
+    requiredEnvVars: ["FINNHUB_API_KEY"],
+    tools: [
+      quoteTool,
+      companyProfileTool,
+      peersTool,
+      marketStatusTool,
+      marketNewsTool,
+      companyNewsTool,
+      earningsCalendarTool,
+      analystRatingsTool,
+      shortInterestTool
+    ]
+  };
+}
+
+// src/modules/alpha-vantage/index.ts
+import { z as z6 } from "zod";
+
+// src/modules/alpha-vantage/client.ts
+var BASE_URL4 = "https://www.alphavantage.co/query";
+var CACHE_TTL4 = 60 * 1e3;
+var cache4 = new TtlCache(CACHE_TTL4);
+function checkAvResponse(data) {
+  if (!data) {
+    throw new Error("Alpha Vantage API returned empty response");
+  }
+  if (data["Note"]) {
+    throw new Error(`Alpha Vantage Rate Limit: ${data["Note"]}`);
+  }
+  if (data["Information"]) {
+    throw new Error(`Alpha Vantage Info: ${data["Information"]}`);
+  }
+  if (data["Error Message"]) {
+    throw new Error(`Alpha Vantage Error: ${data["Error Message"]}`);
+  }
+}
+async function getQuote2(apiKey, symbol) {
+  const cacheKey = `quote:${symbol}`;
+  const cached = cache4.get(cacheKey);
+  if (cached) return cached;
+  const data = await httpGet(`${BASE_URL4}?function=GLOBAL_QUOTE&symbol=${encodeURIComponent(symbol)}&apikey=${apiKey}`);
+  checkAvResponse(data);
+  const gq = data["Global Quote"];
+  if (!gq || !gq["01. symbol"]) {
+    throw new Error(`Stock quote not found for ${symbol}`);
+  }
+  const quote = {
+    symbol: gq["01. symbol"],
+    open: parseFloat(gq["02. open"]),
+    high: parseFloat(gq["03. high"]),
+    low: parseFloat(gq["04. low"]),
+    price: parseFloat(gq["05. price"]),
+    volume: parseInt(gq["06. volume"], 10),
+    latestTradingDay: gq["07. latest trading day"],
+    previousClose: parseFloat(gq["08. previous close"]),
+    change: parseFloat(gq["09. change"]),
+    changePercent: gq["10. change percent"]
+  };
+  cache4.set(cacheKey, quote);
+  return quote;
+}
+async function getDailyPrices(apiKey, symbol, limit = 30) {
+  const cacheKey = `daily:${symbol}:${limit}`;
+  const cached = cache4.get(cacheKey);
+  if (cached) return cached;
+  const data = await httpGet(`${BASE_URL4}?function=TIME_SERIES_DAILY&symbol=${encodeURIComponent(symbol)}&outputsize=compact&apikey=${apiKey}`);
+  checkAvResponse(data);
+  const timeSeries = data["Time Series (Daily)"];
+  if (!timeSeries) {
+    throw new Error(`Daily prices not found for ${symbol}`);
+  }
+  const prices = Object.entries(timeSeries).slice(0, limit).map(([date, values]) => ({
+    date,
+    open: parseFloat(values["1. open"]),
+    high: parseFloat(values["2. high"]),
+    low: parseFloat(values["3. low"]),
+    close: parseFloat(values["4. close"]),
+    volume: parseInt(values["5. volume"], 10)
+  }));
+  cache4.set(cacheKey, prices);
+  return prices;
+}
+async function getOverview(apiKey, symbol) {
+  const cacheKey = `overview:${symbol}`;
+  const cached = cache4.get(cacheKey);
+  if (cached) return cached;
+  const data = await httpGet(
+    `${BASE_URL4}?function=OVERVIEW&symbol=${encodeURIComponent(symbol)}&apikey=${apiKey}`
+  );
+  checkAvResponse(data);
+  if (!data || !data.Symbol) {
+    throw new Error(`Company overview not found for ${symbol}`);
+  }
+  const mcap = data.MarketCapitalization;
+  if (!data.Name || !mcap || mcap === "None" || mcap === "-" || mcap === "0") {
+    throw new Error(`Alpha Vantage Rate Limit: empty overview for ${symbol}`);
+  }
+  const overview = {
+    symbol: data.Symbol,
+    name: data.Name,
+    description: (data.Description ?? "").slice(0, 500),
+    exchange: data.Exchange,
+    sector: data.Sector,
+    industry: data.Industry,
+    marketCap: parseFloat(data.MarketCapitalization) || 0,
+    peRatio: parseFloat(data.PERatio) || 0,
+    pegRatio: parseFloat(data.PEGRatio) || 0,
+    bookValue: parseFloat(data.BookValue) || 0,
+    dividendYield: parseFloat(data.DividendYield) || 0,
+    eps: parseFloat(data.EPS) || 0,
+    revenuePerShare: parseFloat(data.RevenuePerShareTTM) || 0,
+    profitMargin: parseFloat(data.ProfitMargin) || 0,
+    week52High: parseFloat(data["52WeekHigh"]) || 0,
+    week52Low: parseFloat(data["52WeekLow"]) || 0,
+    analystTargetPrice: parseFloat(data.AnalystTargetPrice) || 0,
+    beta: parseFloat(data.Beta) || 0
+  };
+  cache4.set(cacheKey, overview);
+  return overview;
+}
+async function getEarningsHistory(apiKey, symbol, limit = 8) {
+  const cacheKey = `earnings-history:${symbol}:${limit}`;
+  const cached = cache4.get(cacheKey);
+  if (cached) return cached;
+  const data = await httpGet(
+    `${BASE_URL4}?function=EARNINGS&symbol=${encodeURIComponent(symbol)}&apikey=${apiKey}`
+  );
+  checkAvResponse(data);
+  const result = {
+    symbol: data.symbol,
+    annualEarnings: (data.annualEarnings || []).slice(0, 4),
+    quarterlyEarnings: (data.quarterlyEarnings || []).slice(0, limit)
+  };
+  cache4.set(cacheKey, result);
+  return result;
+}
+async function getDividendHistory(apiKey, symbol) {
+  const cacheKey = `dividend-history:${symbol}`;
+  const cached = cache4.get(cacheKey);
+  if (cached) return cached;
+  const data = await httpGet(
+    `${BASE_URL4}?function=DIVIDENDS&symbol=${encodeURIComponent(symbol)}&apikey=${apiKey}`
+  );
+  checkAvResponse(data);
+  const result = {
+    symbol: data.symbol,
+    data: (data.data || []).slice(0, 20)
+  };
+  cache4.set(cacheKey, result);
+  return result;
+}
+
+// src/modules/alpha-vantage/index.ts
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function createAlphaVantageModule(apiKey) {
+  const metadata3 = { source: "alpha-vantage", dataDelay: "real-time" };
+  const quoteTool = {
+    name: "alphavantage_quote",
+    description: "Get real-time stock quote from Alpha Vantage. Returns price, change, volume, and day range. Rate limit: 5 calls/min on free tier.",
+    inputSchema: z6.object({
+      symbol: z6.string().describe("Stock ticker symbol (e.g. 'AAPL', 'MSFT')")
+    }),
+    readOnly: true,
+    handler: withMetadata(async (params) => {
+      const symbol = resolveTicker(params.symbol).ticker;
+      const quote = await getQuote2(apiKey, symbol);
+      return successResult(JSON.stringify(quote, null, 2));
+    }, metadata3)
+  };
+  const dailyTool = {
+    name: "alphavantage_daily",
+    description: "Get daily OHLCV price history from Alpha Vantage. Returns up to 100 most recent trading days. Rate limit: 25 calls/day, 5 calls/min (free tier).",
+    inputSchema: z6.object({
+      symbol: z6.string().describe("Stock ticker symbol (e.g. 'AAPL')"),
+      limit: z6.number().optional().describe("Number of days to return (default: 30, max: 100)")
+    }),
+    readOnly: true,
+    handler: withMetadata(async (params) => {
+      const symbol = resolveTicker(params.symbol).ticker;
+      const prices = await getDailyPrices(
+        apiKey,
+        symbol,
+        Math.min(params.limit ?? 30, 100)
+      );
+      return successResult(JSON.stringify(prices, null, 2));
+    }, metadata3)
+  };
+  const overviewTool = {
+    name: "alphavantage_overview",
+    description: "Get company fundamentals from Alpha Vantage. Includes PE ratio, market cap, beta, sector, industry, earnings, and analyst target price. Supports batch requests (limit 5). Rate limit: 25 calls/day, 5 calls/min (free tier).",
+    inputSchema: z6.object({
+      symbols: z6.union([z6.string(), z6.array(z6.string())]).describe("One or more stock symbols (e.g. 'AAPL' or ['AAPL', 'MSFT'])")
+    }),
+    readOnly: true,
+    handler: withMetadata(async (params) => {
+      const inputSymbols = Array.isArray(params.symbols) ? params.symbols : [params.symbols];
+      const tickers = inputSymbols.map((s) => resolveTicker(s).ticker);
+      const results = [];
+      for (let i = 0; i < Math.min(tickers.length, 5); i++) {
+        if (i > 0) await sleep(12e3);
+        const overview = await getOverview(apiKey, tickers[i]);
+        results.push(overview);
+      }
+      return successResult(JSON.stringify(results.length === 1 ? results[0] : results, null, 2));
+    }, metadata3)
+  };
+  const earningsHistoryTool = {
+    name: "alphavantage_earnings_history",
+    description: "Get historical earnings data (EPS actual vs estimate) for a specific ticker. Rate limit: 25 calls/day, 5 calls/min (free tier).",
+    inputSchema: z6.object({
+      symbol: z6.string().describe("Stock ticker symbol (e.g. 'AAPL')"),
+      limit: z6.number().optional().describe("Number of quarters to return (default: 8, max: 20)")
+    }),
+    readOnly: true,
+    handler: withMetadata(async (params) => {
+      const symbol = resolveTicker(params.symbol).ticker;
+      const earnings = await getEarningsHistory(
+        apiKey,
+        symbol,
+        Math.min(params.limit ?? 8, 20)
+      );
+      return successResult(JSON.stringify(earnings, null, 2));
+    }, metadata3)
+  };
+  const dividendHistoryTool = {
+    name: "alphavantage_dividend_history",
+    description: "Get historical dividend data for a specific ticker. Rate limit: 25 calls/day, 5 calls/min (free tier).",
+    inputSchema: z6.object({
+      symbol: z6.string().describe("Stock ticker symbol (e.g. 'AAPL')")
+    }),
+    readOnly: true,
+    handler: withMetadata(async (params) => {
+      const symbol = resolveTicker(params.symbol).ticker;
+      const dividends = await getDividendHistory(apiKey, symbol);
+      return successResult(JSON.stringify(dividends, null, 2));
+    }, metadata3)
+  };
+  return {
+    name: "alpha-vantage",
+    description: "Alpha Vantage stock data -- quotes, daily prices, and company fundamentals",
+    requiredEnvVars: ["ALPHA_VANTAGE_API_KEY"],
+    tools: [quoteTool, dailyTool, overviewTool, earningsHistoryTool, dividendHistoryTool]
+  };
+}
+
+// src/modules/options/index.ts
+import { z as z7 } from "zod";
+
+// src/modules/options/greeks.ts
+function cnd(x) {
+  const a1 = 0.31938153;
+  const a2 = -0.356563782;
+  const a3 = 1.781477937;
+  const a4 = -1.821255978;
+  const a5 = 1.330274429;
+  const L = Math.abs(x);
+  const K = 1 / (1 + 0.2316419 * L);
+  let w = 1 - 1 / Math.sqrt(2 * Math.PI) * Math.exp(-L * L / 2) * (a1 * K + a2 * K * K + a3 * Math.pow(K, 3) + a4 * Math.pow(K, 4) + a5 * Math.pow(K, 5));
+  if (x < 0) w = 1 - w;
+  return w;
+}
+function pdf(x) {
+  return Math.exp(-x * x / 2) / Math.sqrt(2 * Math.PI);
+}
+function calculateGreeks(S, K, T, r, v, isCall) {
+  if (T <= 0 || v <= 0 || S <= 0 || K <= 0) {
+    return { delta: 0, gamma: 0, theta: 0, vega: 0 };
+  }
+  const d1 = (Math.log(S / K) + (r + v * v / 2) * T) / (v * Math.sqrt(T));
+  const d2 = d1 - v * Math.sqrt(T);
+  let delta;
+  let theta;
+  if (isCall) {
+    delta = cnd(d1);
+    theta = (-S * pdf(d1) * v / (2 * Math.sqrt(T)) - r * K * Math.exp(-r * T) * cnd(d2)) / 365;
+  } else {
+    delta = cnd(d1) - 1;
+    theta = (-S * pdf(d1) * v / (2 * Math.sqrt(T)) + r * K * Math.exp(-r * T) * cnd(-d2)) / 365;
+  }
+  const gamma = pdf(d1) / (S * v * Math.sqrt(T));
+  const vega = S * Math.sqrt(T) * pdf(d1) / 100;
+  return {
+    delta: parseFloat(delta.toFixed(6)),
+    gamma: parseFloat(gamma.toFixed(6)),
+    theta: parseFloat(theta.toFixed(6)),
+    vega: parseFloat(vega.toFixed(6))
+  };
+}
+function calculateMaxPain(strikes, calls, puts) {
+  if (strikes.length === 0) return 0;
+  let minPain = Infinity;
+  let maxPainStrike = strikes[0];
+  for (const candidate of strikes) {
+    let pain = 0;
+    for (const call of calls) {
+      if (candidate > call.strike) {
+        pain += (candidate - call.strike) * (call.openInterest ?? 0);
+      }
+    }
+    for (const put of puts) {
+      if (candidate < put.strike) {
+        pain += (put.strike - candidate) * (put.openInterest ?? 0);
+      }
+    }
+    if (pain < minPain) {
+      minPain = pain;
+      maxPainStrike = candidate;
+    }
+  }
+  return maxPainStrike;
+}
+
+// src/modules/options/yahoo-session.ts
+var COOKIE_URL = "https://fc.yahoo.com/curveball";
+var CRUMB_URL = "https://query1.finance.yahoo.com/v1/test/getcrumb";
+var SESSION_TTL = 30 * 60 * 1e3;
+var TIMEOUT_MS = 1e4;
+var RATE_LIMIT_COOLDOWN = 5 * 60 * 1e3;
+var YAHOO_USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+var session = null;
+var sessionPromise = null;
+var lastRateLimitTime = 0;
+async function createSession() {
+  const now = Date.now();
+  if (now - lastRateLimitTime < RATE_LIMIT_COOLDOWN) {
+    const remaining = Math.ceil((RATE_LIMIT_COOLDOWN - (now - lastRateLimitTime)) / 1e3);
+    throw new Error(`Yahoo Finance rate limit cooldown active. Please wait ${remaining}s.`);
+  }
+  const controller1 = new AbortController();
+  const timer1 = setTimeout(() => controller1.abort(), TIMEOUT_MS);
+  let cookie;
+  try {
+    const cookieResp = await httpFetch(COOKIE_URL, {
+      method: "GET",
+      headers: {
+        "User-Agent": YAHOO_USER_AGENT,
+        "Accept": "*/*"
+      },
+      redirect: "manual",
+      signal: controller1.signal
+    });
+    const headers = cookieResp.headers;
+    let setCookie = [];
+    if (headers) {
+      if (typeof headers.getSetCookie === "function") {
+        setCookie = headers.getSetCookie();
+      } else if (typeof headers.get === "function") {
+        const val = headers.get("set-cookie");
+        if (val) setCookie = [val];
+      }
+    }
+    const a3 = setCookie.map((c) => c.split(";")[0]).find((c) => c.startsWith("A3="));
+    if (!a3) {
+      throw new Error("Yahoo session: failed to obtain A3 cookie");
+    }
+    cookie = a3;
+  } finally {
+    clearTimeout(timer1);
+  }
+  const controller2 = new AbortController();
+  const timer2 = setTimeout(() => controller2.abort(), TIMEOUT_MS);
+  let crumb;
+  try {
+    const crumbResp = await httpFetch(CRUMB_URL, {
+      method: "GET",
+      headers: {
+        "User-Agent": YAHOO_USER_AGENT,
+        "Cookie": cookie,
+        "Referer": "https://finance.yahoo.com",
+        "Accept": "*/*"
+      },
+      signal: controller2.signal
+    });
+    if (crumbResp.status === 429) {
+      lastRateLimitTime = Date.now();
+      throw new Error("Yahoo session: IP rate limited (429). Cooling down for 5 minutes.");
+    }
+    if (!crumbResp.ok) {
+      throw new Error(`Yahoo session: crumb request failed (${crumbResp.status})`);
+    }
+    crumb = await crumbResp.text();
+    if (!crumb || crumb.includes("Too Many") || crumb.includes("error")) {
+      if (crumb.includes("Too Many")) lastRateLimitTime = Date.now();
+      throw new Error(`Yahoo session: invalid crumb response: ${crumb.slice(0, 100)}`);
+    }
+  } finally {
+    clearTimeout(timer2);
+  }
+  return { cookie, crumb, createdAt: Date.now() };
+}
+function isExpired(s) {
+  return Date.now() - s.createdAt > SESSION_TTL;
+}
+async function getSession() {
+  if (session && !isExpired(session)) {
+    return session;
+  }
+  if (!sessionPromise) {
+    sessionPromise = createSession().then((s) => {
+      session = s;
+      sessionPromise = null;
+      return s;
+    }).catch((err) => {
+      sessionPromise = null;
+      throw err;
+    });
+  }
+  return sessionPromise;
+}
+function invalidateSession() {
+  session = null;
+  sessionPromise = null;
+}
+async function getYahooHeaders() {
+  const sess = await getSession();
+  return {
+    "User-Agent": YAHOO_USER_AGENT,
+    "Cookie": sess.cookie,
+    "Referer": "https://finance.yahoo.com",
+    "Accept": "*/*"
+  };
+}
+async function appendCrumb(url) {
+  const sess = await getSession();
+  const sep = url.includes("?") ? "&" : "?";
+  return `${url}${sep}crumb=${encodeURIComponent(sess.crumb)}`;
+}
+
+// src/modules/options/client.ts
+var BASE_URL5 = "https://query1.finance.yahoo.com/v7/finance/options";
+var CACHE_TTL5 = 5 * 60 * 1e3;
+var cache5 = new TtlCache(CACHE_TTL5);
+var DEFAULT_RISK_FREE_RATE = 0.045;
+function mapOption(raw, isCall, underlyingPrice, yearsToExpiration, riskFreeRate) {
+  const strike = raw.strike ?? 0;
+  const iv = raw.impliedVolatility ?? 0;
+  let greeks = null;
+  if (underlyingPrice > 0 && strike > 0 && iv > 0 && yearsToExpiration > 0) {
+    greeks = calculateGreeks(underlyingPrice, strike, yearsToExpiration, riskFreeRate, iv, isCall);
+  }
+  return {
+    symbol: raw.contractSymbol ?? "",
+    strike,
+    lastPrice: raw.lastPrice ?? 0,
+    bid: raw.bid ?? 0,
+    ask: raw.ask ?? 0,
+    change: raw.change ?? 0,
+    percentChange: raw.percentChange ?? 0,
+    volume: raw.volume ?? 0,
+    openInterest: raw.openInterest ?? 0,
+    impliedVolatility: iv,
+    inTheMoney: raw.inTheMoney ?? false,
+    delta: greeks?.delta ?? null,
+    gamma: greeks?.gamma ?? null,
+    theta: greeks?.theta ?? null,
+    vega: greeks?.vega ?? null
+  };
+}
+async function yahooGet(url) {
+  try {
+    const headers = await getYahooHeaders();
+    const finalUrl = await appendCrumb(url);
+    return await httpGet(finalUrl, { headers });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("HTTP 401") || msg.includes("HTTP 403")) {
+      invalidateSession();
+      const headers = await getYahooHeaders();
+      const finalUrl = await appendCrumb(url);
+      return await httpGet(finalUrl, { headers });
+    }
+    throw err;
+  }
+}
+async function fetchOptionChain(rawSymbol, expiration, riskFreeRate = DEFAULT_RISK_FREE_RATE) {
+  const { ticker } = resolveTicker(rawSymbol);
+  const cacheKey = `options:${ticker}:${expiration ?? "latest"}`;
+  const cached = cache5.get(cacheKey);
+  if (cached) return cached;
+  const baseUrl = `${BASE_URL5}/${encodeURIComponent(ticker)}${expiration ? `?date=${expiration}` : ""}`;
+  const response = await yahooGet(baseUrl);
+  const result = response?.optionChain?.result?.[0];
+  if (!result) {
+    throw new Error(`No options data found for symbol: ${ticker}`);
+  }
+  const underlyingPrice = result.quote?.regularMarketPrice;
+  if (!underlyingPrice) {
+    throw new Error(`No price data available for symbol: ${ticker}`);
+  }
+  const chainData = result.options?.[0];
+  if (!chainData) {
+    throw new Error(`No option contracts found for symbol: ${ticker}`);
+  }
+  const expirationTimestamp = chainData.expirationDate ?? 0;
+  const now = Date.now() / 1e3;
+  const yearsToExpiration = Math.max((expirationTimestamp - now) / (365 * 24 * 60 * 60), 0);
+  const calls = (chainData.calls ?? []).map((opt) => mapOption(opt, true, underlyingPrice, yearsToExpiration, riskFreeRate));
+  const puts = (chainData.puts ?? []).map((opt) => mapOption(opt, false, underlyingPrice, yearsToExpiration, riskFreeRate));
+  const strikes = result.strikes ?? [];
+  const processedChain = {
+    underlyingSymbol: result.underlyingSymbol ?? ticker,
+    underlyingPrice,
+    expirationDates: result.expirationDates ?? [],
+    strikes,
+    calls,
+    puts,
+    maxPain: calculateMaxPain(strikes, calls, puts)
+  };
+  cache5.set(cacheKey, processedChain);
+  return processedChain;
+}
+
+// src/modules/options/index.ts
+var metadata = { source: "yahoo-finance", dataDelay: "15min" };
+var symbolSchema = z7.string().min(1).max(10).describe("Stock ticker symbol (e.g. 'AAPL', 'NYSE:GM')");
+function parseExpiration(value) {
+  if (!value) return void 0;
+  const ts = Math.floor((/* @__PURE__ */ new Date(value + "T00:00:00Z")).getTime() / 1e3);
+  if (isNaN(ts)) return void 0;
+  return ts;
+}
+var expirationsTool = {
+  name: "options_expirations",
+  description: "Get all available option expiration dates for a stock ticker. Call this first to discover valid dates, then pass one to options_chain or options_max_pain.",
+  inputSchema: z7.object({
+    symbol: symbolSchema
+  }),
+  readOnly: true,
+  handler: withMetadata(async (params) => {
+    const chain = await fetchOptionChain(params.symbol);
+    const dates = chain.expirationDates.map(
+      (d) => new Date(d * 1e3).toISOString().split("T")[0]
+    );
+    return successResult(JSON.stringify({
+      symbol: chain.underlyingSymbol,
+      underlyingPrice: chain.underlyingPrice,
+      expirations: dates
+    }, null, 2));
+  }, metadata)
+};
+var chainTool = {
+  name: "options_chain",
+  description: "Get the full option chain (calls and puts) with calculated Greeks (Delta, Gamma, Theta, Vega). Use options_expirations first to find valid dates. If expiration is omitted, uses nearest date. By default, returns strikes within \xB120% of current price to save tokens. Use strike_min/strike_max for custom range, or all_strikes=true for everything.",
+  inputSchema: z7.object({
+    symbol: symbolSchema,
+    expiration: z7.string().optional().describe("Expiration date as YYYY-MM-DD (e.g. '2026-04-17'). If omitted, uses nearest."),
+    side: z7.enum(["call", "put", "both"]).optional().describe("Filter by option type (default: both)"),
+    limit: z7.number().optional().describe("Max contracts per side (default: 50, max: 200)"),
+    strike_min: z7.number().optional().describe("Minimum strike price filter (e.g. 25.0)"),
+    strike_max: z7.number().optional().describe("Maximum strike price filter (e.g. 35.0)"),
+    all_strikes: z7.boolean().optional().describe("Return all strikes instead of centering around ATM (default: false)")
+  }),
+  readOnly: true,
+  handler: withMetadata(async (params) => {
+    const expUnix = parseExpiration(params.expiration);
+    const chain = await fetchOptionChain(params.symbol, expUnix);
+    let { calls, puts } = chain;
+    const allStrikes = params.all_strikes ?? false;
+    const hasExplicitRange = params.strike_min != null || params.strike_max != null;
+    if (!allStrikes) {
+      let minStrike;
+      let maxStrike;
+      if (hasExplicitRange) {
+        minStrike = params.strike_min ?? 0;
+        maxStrike = params.strike_max ?? Infinity;
+      } else {
+        minStrike = chain.underlyingPrice * 0.8;
+        maxStrike = chain.underlyingPrice * 1.2;
+      }
+      calls = calls.filter((c) => c.strike >= minStrike && c.strike <= maxStrike);
+      puts = puts.filter((c) => c.strike >= minStrike && c.strike <= maxStrike);
+    }
+    if (params.side === "call") {
+      puts = [];
+    } else if (params.side === "put") {
+      calls = [];
+    }
+    const limit = Math.min(params.limit ?? 50, 200);
+    calls = calls.slice(0, limit);
+    puts = puts.slice(0, limit);
+    return successResult(JSON.stringify({
+      ...chain,
+      calls,
+      puts
+    }, null, 2));
+  }, metadata)
+};
+var unusualActivityTool = {
+  name: "options_unusual_activity",
+  description: "Find options contracts with unusually high volume relative to open interest (a common 'smart money' signal). Scans the nearest expiration and flags contracts where volume/OI exceeds a threshold.",
+  inputSchema: z7.object({
+    symbol: symbolSchema,
+    volume_oi_ratio: z7.number().optional().describe("Min volume/OI ratio to flag as unusual (default: 3.0)"),
+    min_volume: z7.number().optional().describe("Min absolute volume (default: 100)"),
+    side: z7.enum(["call", "put", "both"]).optional().describe("Filter by option type (default: both)")
+  }),
+  readOnly: true,
+  handler: withMetadata(async (params) => {
+    const chain = await fetchOptionChain(params.symbol);
+    const minRatio = params.volume_oi_ratio ?? 3;
+    const minVol = params.min_volume ?? 100;
+    const minOI = 10;
+    const allContracts = [
+      ...chain.calls.map((c) => ({ ...c, side: "call" })),
+      ...chain.puts.map((c) => ({ ...c, side: "put" }))
+    ];
+    let unusual = allContracts.filter((c) => c.volume >= minVol && c.openInterest >= minOI).map((c) => ({
+      ...c,
+      volumeOiRatio: Math.round(c.volume / c.openInterest * 100) / 100
+    })).filter((c) => c.volumeOiRatio >= minRatio);
+    if (params.side && params.side !== "both") {
+      unusual = unusual.filter((c) => c.side === params.side);
+    }
+    unusual.sort((a, b) => b.volume - a.volume);
+    unusual = unusual.slice(0, 20);
+    return successResult(JSON.stringify({
+      symbol: chain.underlyingSymbol,
+      underlyingPrice: chain.underlyingPrice,
+      unusual
+    }, null, 2));
+  }, metadata)
+};
+var maxPainTool = {
+  name: "options_max_pain",
+  description: "Calculate the max pain strike price \u2014 where cumulative option open interest expires worthless. This level often acts as a support/resistance zone near expiration.",
+  inputSchema: z7.object({
+    symbol: symbolSchema,
+    expiration: z7.string().optional().describe("Expiration date as YYYY-MM-DD. If omitted, uses nearest.")
+  }),
+  readOnly: true,
+  handler: withMetadata(async (params) => {
+    const expUnix = parseExpiration(params.expiration);
+    const chain = await fetchOptionChain(params.symbol, expUnix);
+    const expDate = chain.expirationDates[0] ? new Date(chain.expirationDates[0] * 1e3).toISOString().split("T")[0] : "unknown";
+    return successResult(JSON.stringify({
+      symbol: chain.underlyingSymbol,
+      underlyingPrice: chain.underlyingPrice,
+      expiration: expDate,
+      maxPain: chain.maxPain
+    }, null, 2));
+  }, metadata)
+};
+var impliedMoveTool = {
+  name: "options_implied_move",
+  description: "Calculate the expected move implied by options pricing (ATM straddle). Essential for earnings plays \u2014 shows how much the market expects the stock to move. Compare implied vs historical moves to assess if premium is cheap or expensive.",
+  inputSchema: z7.object({
+    symbol: symbolSchema,
+    expiration: z7.string().optional().describe("Expiration date as YYYY-MM-DD. If omitted, uses nearest.")
+  }),
+  readOnly: true,
+  handler: withMetadata(async (params) => {
+    const expUnix = parseExpiration(params.expiration);
+    const chain = await fetchOptionChain(params.symbol, expUnix);
+    const price = chain.underlyingPrice;
+    const expDate = chain.expirationDates[0] ? new Date(chain.expirationDates[0] * 1e3).toISOString().split("T")[0] : "unknown";
+    const atmCall = chain.calls.reduce(
+      (best, c) => Math.abs(c.strike - price) < Math.abs(best.strike - price) ? c : best,
+      chain.calls[0]
+    );
+    const atmPut = chain.puts.reduce(
+      (best, p) => Math.abs(p.strike - price) < Math.abs(best.strike - price) ? p : best,
+      chain.puts[0]
+    );
+    if (!atmCall || !atmPut) {
+      return successResult(JSON.stringify({
+        symbol: chain.underlyingSymbol,
+        underlyingPrice: price,
+        error: "Insufficient options data to calculate implied move"
+      }, null, 2));
+    }
+    const callPrice = atmCall.lastPrice || (atmCall.bid + atmCall.ask) / 2 || 0;
+    const putPrice = atmPut.lastPrice || (atmPut.bid + atmPut.ask) / 2 || 0;
+    const straddlePrice = callPrice + putPrice;
+    const impliedMoveAbs = straddlePrice;
+    const impliedMovePct = price > 0 ? straddlePrice / price * 100 : 0;
+    const avgIv = ((atmCall.impliedVolatility || 0) + (atmPut.impliedVolatility || 0)) / 2;
+    return successResult(JSON.stringify({
+      symbol: chain.underlyingSymbol,
+      underlyingPrice: price,
+      expiration: expDate,
+      atmCallStrike: atmCall.strike,
+      atmCallPrice: callPrice,
+      atmPutStrike: atmPut.strike,
+      atmPutPrice: putPrice,
+      straddlePrice,
+      impliedMove: Math.round(impliedMovePct * 100) / 100,
+      impliedMoveAbsolute: Math.round(impliedMoveAbs * 100) / 100,
+      impliedVolatility: Math.round(avgIv * 1e4) / 100,
+      expectedRange: {
+        low: Math.round((price - impliedMoveAbs) * 100) / 100,
+        high: Math.round((price + impliedMoveAbs) * 100) / 100
+      }
+    }, null, 2));
+  }, metadata)
+};
+function createOptionsModule() {
+  return {
+    name: "options",
+    description: "Stock options chains, Greeks, unusual activity, implied move, and max pain from Yahoo Finance (no API key required)",
+    requiredEnvVars: [],
+    tools: [expirationsTool, chainTool, unusualActivityTool, maxPainTool, impliedMoveTool]
+  };
+}
+
+// src/modules/options-cboe/index.ts
+import { z as z8 } from "zod";
+
+// src/modules/options-cboe/cboe.ts
+var BASE_URL6 = "https://cdn.cboe.com/data/us/options/market_statistics/daily";
+var CACHE_TTL6 = 30 * 60 * 1e3;
+var cache6 = new TtlCache(CACHE_TTL6);
+var TYPE_MAP = {
+  total: { ratioName: "TOTAL PUT/CALL RATIO", volumeKey: "SUM OF ALL PRODUCTS" },
+  equity: { ratioName: "EQUITY PUT/CALL RATIO", volumeKey: "EQUITY OPTIONS" },
+  index: { ratioName: "INDEX PUT/CALL RATIO", volumeKey: "INDEX OPTIONS" }
+};
+function formatDate(d) {
+  const yyyy = d.getFullYear();
+  const mm = String(d.getMonth() + 1).padStart(2, "0");
+  const dd = String(d.getDate()).padStart(2, "0");
+  return `${yyyy}-${mm}-${dd}`;
+}
+function isWeekend(d) {
+  const day = d.getDay();
+  return day === 0 || day === 6;
+}
+function parseDailyJson(json, date, type) {
+  const mapping = TYPE_MAP[type];
+  if (!mapping) return null;
+  const ratioObj = json.ratios?.find((r) => r.name === mapping.ratioName);
+  if (!ratioObj) return null;
+  const putCallRatio = Number(ratioObj.value);
+  if (isNaN(putCallRatio)) return null;
+  const volumeSection = json[mapping.volumeKey];
+  const volumeRow = volumeSection?.find((v) => v.name === "VOLUME");
+  return {
+    date,
+    callVolume: volumeRow?.call ?? 0,
+    putVolume: volumeRow?.put ?? 0,
+    totalVolume: volumeRow?.total ?? 0,
+    putCallRatio
+  };
+}
+async function fetchDay(date) {
+  const url = `${BASE_URL6}/${date}_daily_options`;
+  try {
+    return await httpGet(url);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("HTTP 403") || msg.includes("HTTP 404")) {
+      return null;
+    }
+    throw err;
+  }
+}
+async function fetchDays(type, days) {
+  const mapping = TYPE_MAP[type];
+  if (!mapping) {
+    throw new Error(`Unknown put/call ratio type: ${type}`);
+  }
+  const entries = [];
+  const cursor = /* @__PURE__ */ new Date();
+  cursor.setDate(cursor.getDate() - 1);
+  const maxAttempts = days * 2 + 10;
+  let attempts = 0;
+  while (entries.length < days && attempts < maxAttempts) {
+    attempts++;
+    if (isWeekend(cursor)) {
+      cursor.setDate(cursor.getDate() - 1);
+      continue;
+    }
+    const dateStr = formatDate(cursor);
+    const json = await fetchDay(dateStr);
+    if (json) {
+      const entry = parseDailyJson(json, dateStr, type);
+      if (entry) {
+        entries.push(entry);
+      }
+    }
+    cursor.setDate(cursor.getDate() - 1);
+  }
+  return entries;
+}
+async function getPutCallRatio(type, days) {
+  return cache6.getOrFetch(`pcr:${type}:${days}`, () => fetchDays(type, days));
+}
+
+// src/modules/options-cboe/index.ts
+function createOptionsCboeModule() {
+  const metadata3 = { source: "cboe", dataDelay: "end-of-day" };
+  return {
+    name: "options-cboe",
+    description: "CBOE market-wide put/call ratio data \u2014 daily sentiment indicator from options volume",
+    requiredEnvVars: [],
+    tools: [{
+      name: "options_put_call_ratio",
+      description: "Get historical put/call ratio from CBOE (market-wide sentiment indicator). Ratio > 1.0 = more puts (bearish sentiment), < 0.7 = more calls (bullish/complacent). Types: 'total' (all options), 'equity' (stock options only), 'index' (index options only).",
+      inputSchema: z8.object({
+        type: z8.enum(["total", "equity", "index"]).optional().describe("Ratio type (default: total)"),
+        days: z8.number().optional().describe("Number of recent trading days to return (default: 30, max: 252)")
+      }),
+      readOnly: true,
+      handler: withMetadata(async (params) => {
+        const days = Math.min(Math.max(params.days ?? 30, 1), 252);
+        const data = await getPutCallRatio(params.type ?? "total", days);
+        return successResult(JSON.stringify(data, null, 2));
+      }, metadata3)
+    }]
+  };
+}
+
+// src/modules/fred/index.ts
+import { z as z9 } from "zod";
+
+// src/modules/fred/client.ts
+var BASE_URL7 = "https://api.stlouisfed.org/fred";
+var CACHE_TTL7 = 30 * 60 * 1e3;
+var cache7 = new TtlCache(CACHE_TTL7);
+var HIGH_IMPACT_RELEASES = {
+  10: "Consumer Price Index",
+  46: "Producer Price Index",
+  50: "Employment Situation",
+  53: "Gross Domestic Product",
+  54: "Personal Income and Outlays",
+  101: "Federal Funds Rate",
+  7: "Advance Retail Sales",
+  9: "Industrial Production and Capacity Utilization",
+  18: "Housing Starts",
+  32: "ISM Manufacturing"
+};
+var COMMON_SERIES = {
+  fed_funds: "DFF",
+  cpi: "CPIAUCSL",
+  core_cpi: "CPILFESL",
+  ppi: "PPIFIS",
+  gdp: "GDPC1",
+  unemployment: "UNRATE",
+  nonfarm_payrolls: "PAYEMS",
+  treasury_10y: "DGS10",
+  treasury_2y: "DGS2",
+  initial_claims: "ICSA",
+  core_pce: "PCEPILFE"
+};
+function resolveSeriesId(seriesIdOrAlias) {
+  const lower = seriesIdOrAlias.toLowerCase();
+  return COMMON_SERIES[lower] || seriesIdOrAlias.toUpperCase();
+}
+async function getEconomicCalendar(apiKey, limit = 60) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const cacheKey = `calendar:${today}:${limit}`;
+  const cached = cache7.get(cacheKey);
+  if (cached) return cached;
+  const highImpactIds = new Set(Object.keys(HIGH_IMPACT_RELEASES).map(Number));
+  const url = `${BASE_URL7}/releases/dates?api_key=${encodeURIComponent(apiKey)}&file_type=json&realtime_start=${today}&include_release_dates_with_no_data=true&sort_order=asc&limit=${limit}`;
+  const data = await httpGet(url);
+  const filtered = (data.release_dates || []).filter((r) => highImpactIds.has(r.release_id)).map((r) => ({
+    release_id: r.release_id,
+    release_name: r.release_name,
+    date: r.date
+  }));
+  cache7.set(cacheKey, filtered);
+  return filtered;
+}
+async function getIndicator(apiKey, seriesIdOrAlias) {
+  const seriesId = resolveSeriesId(seriesIdOrAlias);
+  const cacheKey = `indicator:${seriesId}`;
+  const cached = cache7.get(cacheKey);
+  if (cached) return cached;
+  const baseParams = `api_key=${encodeURIComponent(apiKey)}&file_type=json`;
+  const seriesUrl = `${BASE_URL7}/series?series_id=${encodeURIComponent(seriesId)}&${baseParams}`;
+  const seriesData = await httpGet(seriesUrl);
+  const s = seriesData.seriess[0];
+  const obsUrl = `${BASE_URL7}/series/observations?series_id=${encodeURIComponent(seriesId)}&${baseParams}&sort_order=desc&limit=1`;
+  const obsData = await httpGet(obsUrl);
+  const obs = obsData.observations[0];
+  const result = {
+    series: {
+      id: s.id,
+      title: s.title,
+      frequency: s.frequency,
+      units: s.units,
+      seasonal_adjustment: s.seasonal_adjustment,
+      last_updated: s.last_updated
+    },
+    latest: {
+      date: obs?.date || "",
+      value: obs?.value === "." ? null : obs?.value || null
+    }
+  };
+  cache7.set(cacheKey, result);
+  return result;
+}
+async function getIndicatorHistory(apiKey, seriesIdOrAlias, startDate, endDate, units = "lin") {
+  const seriesId = resolveSeriesId(seriesIdOrAlias);
+  const cacheKey = `history:${seriesId}:${startDate}:${endDate}:${units}`;
+  const cached = cache7.get(cacheKey);
+  if (cached) return cached;
+  const url = `${BASE_URL7}/series/observations?series_id=${encodeURIComponent(seriesId)}&api_key=${encodeURIComponent(apiKey)}&file_type=json&observation_start=${encodeURIComponent(startDate)}&observation_end=${encodeURIComponent(endDate)}&units=${encodeURIComponent(units)}&sort_order=asc`;
+  const data = await httpGet(url);
+  const result = (data.observations || []).filter((o) => o.value !== ".").map((o) => ({
+    date: o.date,
+    value: o.value
+  }));
+  cache7.set(cacheKey, result);
+  return result;
+}
+async function searchSeries(apiKey, query, limit = 10) {
+  const cacheKey = `search:${query}:${limit}`;
+  const cached = cache7.get(cacheKey);
+  if (cached) return cached;
+  const url = `${BASE_URL7}/series/search?search_text=${encodeURIComponent(query)}&api_key=${encodeURIComponent(apiKey)}&file_type=json&limit=${limit}&order_by=search_rank`;
+  const data = await httpGet(url);
+  const result = (data.seriess || []).map((s) => ({
+    id: s.id,
+    title: s.title,
+    frequency: s.frequency,
+    units: s.units,
+    popularity: s.popularity,
+    last_updated: s.last_updated
+  }));
+  cache7.set(cacheKey, result);
+  return result;
+}
+
+// src/modules/fred/index.ts
+function createFredModule(apiKey) {
+  const metadata3 = { source: "fred", dataDelay: "varies by indicator" };
+  const calendarTool = {
+    name: "fred_economic_calendar",
+    description: "Get upcoming US economic release dates (FOMC, CPI, PPI, NFP, GDP, PCE, jobless claims, retail sales, ISM, treasury rates). Filters to high-impact releases only. Use this to identify macro catalysts that could move markets. Rate limit: 120 calls/min (free tier).",
+    inputSchema: z9.object({
+      limit: z9.number().optional().default(60).describe("Max raw results to fetch before filtering (default: 60)")
+    }),
+    readOnly: true,
+    handler: withMetadata(async (params) => {
+      const releases = await getEconomicCalendar(apiKey, params.limit);
+      return successResult(JSON.stringify(releases, null, 2));
+    }, metadata3)
+  };
+  const indicatorTool = {
+    name: "fred_indicator",
+    description: "Get the latest value of a US economic indicator from FRED. Accepts FRED series IDs (e.g. 'CPIAUCSL', 'DFF', 'UNRATE') or common aliases: cpi, core_cpi, ppi, gdp, unemployment, nonfarm_payrolls, fed_funds, treasury_10y, treasury_2y, initial_claims, core_pce. Returns the indicator metadata (title, frequency, units) and latest observation. Rate limit: 120 calls/min (free tier).",
+    inputSchema: z9.object({
+      series_id: z9.string().describe("FRED series ID or alias (e.g. 'cpi', 'UNRATE', 'treasury_10y')")
+    }),
+    readOnly: true,
+    handler: withMetadata(async (params) => {
+      const result = await getIndicator(apiKey, params.series_id);
+      return successResult(JSON.stringify(result, null, 2));
+    }, metadata3)
+  };
+  const historyTool = {
+    name: "fred_indicator_history",
+    description: "Get historical values for a US economic indicator from FRED. Accepts same series IDs/aliases as fred_indicator. Supports units transformation: 'lin' (raw level), 'chg' (change), 'pc1' (% change from year ago \u2014 useful for YoY inflation), 'pch' (% change from prior period). Use 'pc1' with CPI/PPI to get YoY inflation rates directly. Rate limit: 120 calls/min (free tier).",
+    inputSchema: z9.object({
+      series_id: z9.string().describe("FRED series ID or alias"),
+      start_date: z9.string().describe("Start date YYYY-MM-DD"),
+      end_date: z9.string().describe("End date YYYY-MM-DD"),
+      units: z9.enum(["lin", "chg", "ch1", "pch", "pc1", "pca"]).optional().default("lin").describe("Units: lin=level, pch=% change, pc1=YoY % change (default: lin)")
+    }),
+    readOnly: true,
+    handler: withMetadata(async (params) => {
+      const result = await getIndicatorHistory(
+        apiKey,
+        params.series_id,
+        params.start_date,
+        params.end_date,
+        params.units
+      );
+      return successResult(JSON.stringify(result, null, 2));
+    }, metadata3)
+  };
+  const searchTool = {
+    name: "fred_search",
+    description: "Search FRED for economic data series by keyword. Returns series IDs that can be used with fred_indicator and fred_indicator_history. Results sorted by relevance. Use to discover series IDs for niche indicators. Rate limit: 120 calls/min (free tier).",
+    inputSchema: z9.object({
+      query: z9.string().describe("Search keywords (e.g. 'consumer price index', 'housing starts')"),
+      limit: z9.number().optional().default(10).describe("Max results (default: 10, max: 50)")
+    }),
+    readOnly: true,
+    handler: withMetadata(async (params) => {
+      const results = await searchSeries(apiKey, params.query, params.limit);
+      return successResult(JSON.stringify(results, null, 2));
+    }, metadata3)
+  };
+  return {
+    name: "fred",
+    description: "FRED economic data: calendar, indicators, interest rates, inflation",
+    requiredEnvVars: ["FRED_API_KEY"],
+    tools: [calendarTool, indicatorTool, historyTool, searchTool]
+  };
+}
+
+// src/modules/sentiment/index.ts
+import { z as z10 } from "zod";
+
+// src/modules/sentiment/client.ts
+var CNN_URL = "https://production.dataviz.cnn.io/index/fearandgreed/graphdata";
+var ALTERNATIVE_ME_URL = "https://api.alternative.me/fng/";
+var CNN_HEADERS = {
+  "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+  "Referer": "https://www.cnn.com/markets/fear-and-greed"
+};
+var CACHE_TTL8 = 60 * 60 * 1e3;
+var cache8 = new TtlCache(CACHE_TTL8);
+var INDICATOR_LABELS = {
+  market_momentum_sp500: "S&P 500 Momentum",
+  stock_price_strength: "Stock Price Strength (52w highs vs lows)",
+  stock_price_breadth: "Stock Price Breadth (McClellan Volume)",
+  put_call_options: "Put/Call Ratio",
+  market_volatility_vix: "Market Volatility (VIX)",
+  junk_bond_demand: "Junk Bond Demand (yield spread)",
+  safe_haven_demand: "Safe Haven Demand (stocks vs bonds)"
+};
+async function getFearAndGreed() {
+  const cacheKey = "sentiment:fear-greed";
+  const cached = cache8.get(cacheKey);
+  if (cached) return cached;
+  const data = await httpGet(CNN_URL, {
+    headers: CNN_HEADERS
+  });
+  const fg = data.fear_and_greed;
+  if (!fg) throw new Error("CNN Fear & Greed API response missing 'fear_and_greed' field");
+  const indicatorKeys = Object.keys(INDICATOR_LABELS);
+  const indicators = indicatorKeys.map((key) => {
+    const ind = data[key];
+    return {
+      name: INDICATOR_LABELS[key],
+      score: Math.round(ind?.score ?? 0),
+      rating: ind?.rating ?? "unknown"
+    };
+  });
+  const result = {
+    score: Math.round(fg.score),
+    rating: fg.rating,
+    previousClose: Math.round(fg.previous_close),
+    previous1Week: Math.round(fg.previous_1_week),
+    previous1Month: Math.round(fg.previous_1_month),
+    previous1Year: Math.round(fg.previous_1_year),
+    indicators
+  };
+  cache8.set(cacheKey, result);
+  return result;
+}
+async function getCryptoFearAndGreed() {
+  const cacheKey = "sentiment:crypto-fear-greed";
+  const cached = cache8.get(cacheKey);
+  if (cached) return cached;
+  const data = await httpGet(ALTERNATIVE_ME_URL);
+  const entry = data.data[0];
+  if (!entry) throw new Error("No crypto Fear & Greed data available");
+  const result = {
+    score: parseInt(entry.value, 10),
+    rating: entry.value_classification.toLowerCase(),
+    timestamp: new Date(parseInt(entry.timestamp, 10) * 1e3).toISOString()
+  };
+  cache8.set(cacheKey, result);
+  return result;
+}
+
+// src/modules/sentiment/index.ts
+var fearGreedTool = {
+  name: "sentiment_fear_greed",
+  description: "Get the CNN Fear & Greed Index for the US stock market. Returns a composite score (0-100) with rating (extreme fear/fear/neutral/greed/extreme greed) and 7 sub-indicators: S&P 500 momentum, stock price strength (52w highs vs lows), stock price breadth (McClellan), put/call ratio, VIX, junk bond demand, safe haven demand. Also includes previous close, 1-week, 1-month, and 1-year scores for trend context. Use this to gauge overall market sentiment before analyzing individual stocks.",
+  inputSchema: z10.object({}),
+  readOnly: true,
+  handler: withMetadata(async () => {
+    const result = await getFearAndGreed();
+    return successResult(JSON.stringify(result, null, 2));
+  }, { source: "cnn-fear-greed", dataDelay: "end of day" })
+};
+var cryptoFearGreedTool = {
+  name: "sentiment_crypto_fear_greed",
+  description: "Get the Crypto Fear & Greed Index from Alternative.me. Returns a score (0-100) with rating (extreme fear/fear/neutral/greed/extreme greed). Based on Bitcoin volatility, market volume, social media, surveys, dominance, and trends. Use this alongside coingecko tools for crypto market context.",
+  inputSchema: z10.object({}),
+  readOnly: true,
+  handler: withMetadata(async () => {
+    const result = await getCryptoFearAndGreed();
+    return successResult(JSON.stringify(result, null, 2));
+  }, { source: "alternative-me", dataDelay: "daily" })
+};
+function createSentimentModule() {
+  return {
+    name: "sentiment",
+    description: "Market sentiment \u2014 CNN Fear & Greed Index and crypto sentiment",
+    requiredEnvVars: [],
+    tools: [fearGreedTool, cryptoFearGreedTool]
+  };
+}
+
+// src/modules/frankfurter/index.ts
+import { z as z11 } from "zod";
+
+// src/modules/frankfurter/client.ts
+var BASE_URL8 = "https://api.frankfurter.dev/v1";
+var CACHE_TTL_LATEST = 60 * 60 * 1e3;
+var CACHE_TTL_STATIC = 24 * 60 * 60 * 1e3;
+var MAX_TIMESERIES_DAYS = 90;
+var latestCache = new TtlCache(CACHE_TTL_LATEST);
+var staticCache = new TtlCache(CACHE_TTL_STATIC);
+function buildUrl(path3, params) {
+  const url = new URL(`${BASE_URL8}${path3}`);
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0) {
+      url.searchParams.set(key, value);
+    }
+  }
+  return url.toString();
+}
+function capEndDate(startDate, endDate) {
+  const start = new Date(startDate);
+  const maxEnd = new Date(start.getTime() + MAX_TIMESERIES_DAYS * 24 * 60 * 60 * 1e3);
+  const today = /* @__PURE__ */ new Date();
+  today.setHours(0, 0, 0, 0);
+  const upperBound = maxEnd < today ? maxEnd : today;
+  if (!endDate) return upperBound.toISOString().split("T")[0];
+  const requested = new Date(endDate);
+  const capped = requested < upperBound ? requested : upperBound;
+  return capped.toISOString().split("T")[0];
+}
+async function getLatestRates(base, symbols) {
+  const cacheKey = `latest:${base}:${symbols ?? "all"}`;
+  const cached = latestCache.get(cacheKey);
+  if (cached) return cached;
+  const url = buildUrl("/latest", { base, symbols });
+  const data = await httpGet(url);
+  latestCache.set(cacheKey, data);
+  return data;
+}
+async function getHistoricalRates(base, date, symbols) {
+  const cacheKey = `historical:${base}:${date}:${symbols ?? "all"}`;
+  const cached = staticCache.get(cacheKey);
+  if (cached) return cached;
+  const url = buildUrl(`/${encodeURIComponent(date)}`, { base, symbols });
+  const data = await httpGet(url);
+  staticCache.set(cacheKey, data);
+  return data;
+}
+async function getTimeSeries(base, symbols, startDate, endDate) {
+  const cappedEnd = capEndDate(startDate, endDate);
+  const cacheKey = `timeseries:${base}:${symbols}:${startDate}:${cappedEnd}`;
+  const cached = latestCache.get(cacheKey);
+  if (cached) return cached;
+  const path3 = `/${encodeURIComponent(startDate)}..${encodeURIComponent(cappedEnd)}`;
+  const url = buildUrl(path3, { base, symbols });
+  const data = await httpGet(url);
+  latestCache.set(cacheKey, data);
+  return data;
+}
+async function convertCurrency(amount, from, to) {
+  const cacheKey = `convert:${amount}:${from}:${to}`;
+  const cached = latestCache.get(cacheKey);
+  if (cached) return cached;
+  const url = buildUrl("/latest", {
+    amount: String(amount),
+    base: from,
+    symbols: to
+  });
+  const data = await httpGet(url);
+  latestCache.set(cacheKey, data);
+  return data;
+}
+async function getCurrencies() {
+  const cacheKey = "currencies";
+  const cached = staticCache.get(cacheKey);
+  if (cached) return cached;
+  const url = `${BASE_URL8}/currencies`;
+  const data = await httpGet(url);
+  staticCache.set(cacheKey, data);
+  return data;
+}
+
+// src/modules/frankfurter/index.ts
+var metadata2 = { source: "frankfurter", dataDelay: "end-of-day" };
+var currencyCode = z11.string().min(3).max(3).describe("ISO 4217 currency code (e.g. 'USD', 'EUR', 'GBP', 'JPY')");
+var latestTool = {
+  name: "frankfurter_latest",
+  description: "Get latest forex exchange rates from the European Central Bank. Returns daily reference rates for 31 major currencies. Updated once per business day at ~16:00 CET. These are reference rates, not real-time trading rates.",
+  inputSchema: z11.object({
+    base: currencyCode.default("USD").describe("Base currency"),
+    symbols: z11.string().optional().describe(
+      "Comma-separated target currencies (e.g. 'EUR,GBP,JPY'). Omit for all 31."
+    )
+  }),
+  readOnly: true,
+  handler: withMetadata(async (params) => {
+    const result = await getLatestRates(
+      params.base,
+      params.symbols
+    );
+    return successResult(JSON.stringify(result, null, 2));
+  }, metadata2)
+};
+var historicalTool = {
+  name: "frankfurter_historical",
+  description: "Get ECB forex exchange rates for a specific past date. Daily reference rates, not real-time trading rates. If the date is a weekend or holiday, returns the previous business day's rates. Data available from 1999-01-04 (Euro inception).",
+  inputSchema: z11.object({
+    date: z11.string().describe("Date in YYYY-MM-DD format"),
+    base: currencyCode.default("USD").describe("Base currency"),
+    symbols: z11.string().optional().describe("Comma-separated target currencies. Omit for all.")
+  }),
+  readOnly: true,
+  handler: withMetadata(async (params) => {
+    const result = await getHistoricalRates(
+      params.base,
+      params.date,
+      params.symbols
+    );
+    return successResult(JSON.stringify(result, null, 2));
+  }, metadata2)
+};
+var timeseriesTool = {
+  name: "frankfurter_timeseries",
+  description: "Get daily ECB forex rate history for a date range (max 90 days). Daily reference rates, not real-time. Use for currency trend analysis. Only business days included (weekends/holidays omitted). Requires symbols filter to control response size.",
+  inputSchema: z11.object({
+    start_date: z11.string().describe("Start date (YYYY-MM-DD)"),
+    end_date: z11.string().optional().describe(
+      "End date (YYYY-MM-DD, defaults to today, max 90 days from start)"
+    ),
+    base: currencyCode.default("USD").describe("Base currency"),
+    symbols: z11.string().describe(
+      "Required: comma-separated target currencies (e.g. 'EUR,GBP')"
+    )
+  }),
+  readOnly: true,
+  handler: withMetadata(async (params) => {
+    const result = await getTimeSeries(
+      params.base,
+      params.symbols,
+      params.start_date,
+      params.end_date
+    );
+    return successResult(JSON.stringify(result, null, 2));
+  }, metadata2)
+};
+var convertTool = {
+  name: "frankfurter_convert",
+  description: "Convert an amount between two currencies at the latest ECB daily reference rate. Updated once per business day \u2014 not suitable for intraday trading rates. Useful for cross-border stock valuation and currency exposure calculations.",
+  inputSchema: z11.object({
+    amount: z11.number().describe("Amount to convert"),
+    from: currencyCode.describe("Source currency (e.g. 'USD')"),
+    to: currencyCode.describe("Target currency (e.g. 'EUR')")
+  }),
+  readOnly: true,
+  handler: withMetadata(async (params) => {
+    const result = await convertCurrency(
+      params.amount,
+      params.from,
+      params.to
+    );
+    return successResult(JSON.stringify(result, null, 2));
+  }, metadata2)
+};
+var currenciesTool = {
+  name: "frankfurter_currencies",
+  description: "List all 31 currencies supported by the Frankfurter API with their full names. Use to look up valid currency codes before calling other frankfurter tools.",
+  inputSchema: z11.object({}),
+  readOnly: true,
+  handler: withMetadata(async () => {
+    const result = await getCurrencies();
+    return successResult(JSON.stringify(result, null, 2));
+  }, metadata2)
+};
+function createFrankfurterModule() {
+  return {
+    name: "frankfurter",
+    description: "Forex exchange rates from ECB \u2014 daily reference rates for 31 currencies, no API key required",
+    requiredEnvVars: [],
+    tools: [
+      latestTool,
+      historicalTool,
+      timeseriesTool,
+      convertTool,
+      currenciesTool
+    ]
+  };
+}
+
+// src/modules/reddit/index.ts
+import { z as z12 } from "zod";
+
+// src/modules/reddit/client.ts
+var REDDIT_BASE = "https://www.reddit.com";
+var REDDIT_HEADERS = {
+  "User-Agent": "stock-scanner-mcp/1.0 (by /u/stock-scanner-bot)"
+};
+var DEFAULT_SUBREDDITS = [
+  "wallstreetbets",
+  "stocks",
+  "investing",
+  "options"
+];
+var trendingCache = new TtlCache(5 * 60 * 1e3);
+var mentionCache = new TtlCache(2 * 60 * 1e3);
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  // 1-2 letter
+  "I",
+  "A",
+  "AM",
+  "AN",
+  "AS",
+  "AT",
+  "BE",
+  "BY",
+  "DO",
+  "GO",
+  "HE",
+  "IF",
+  "IN",
+  "IS",
+  "IT",
+  "ME",
+  "MY",
+  "NO",
+  "OF",
+  "OK",
+  "ON",
+  "OR",
+  "SO",
+  "TO",
+  "UP",
+  "US",
+  "WE",
+  // 3 letter common English
+  "ALL",
+  "AND",
+  "ANY",
+  "ARE",
+  "BAD",
+  "BIG",
+  "BUT",
+  "CAN",
+  "DAY",
+  "DID",
+  "END",
+  "FAR",
+  "FEW",
+  "FOR",
+  "GET",
+  "GOD",
+  "GOT",
+  "GUY",
+  "HAS",
+  "HAD",
+  "HER",
+  "HIM",
+  "HIS",
+  "HOW",
+  "ITS",
+  "JOB",
+  "LET",
+  "LOT",
+  "MAN",
+  "MAY",
+  "MEN",
+  "MOM",
+  "NEW",
+  "NOT",
+  "NOW",
+  "OLD",
+  "ONE",
+  "OUR",
+  "OUT",
+  "OWN",
+  "PUT",
+  "RAN",
+  "RUN",
+  "SAT",
+  "SAY",
+  "SET",
+  "SHE",
+  "SIT",
+  "THE",
+  "TOO",
+  "TOP",
+  "TRY",
+  "TWO",
+  "USE",
+  "WAR",
+  "WAS",
+  "WAY",
+  "WHO",
+  "WHY",
+  "WIN",
+  "WON",
+  "YES",
+  "YET",
+  "YOU",
+  // 4 letter common English
+  "ALSO",
+  "BACK",
+  "BEEN",
+  "BEST",
+  "BODY",
+  "BOTH",
+  "CALL",
+  "CAME",
+  "COME",
+  "DARK",
+  "DAYS",
+  "DEAD",
+  "DOES",
+  "DONE",
+  "DOWN",
+  "EACH",
+  "EVEN",
+  "EVER",
+  "EYES",
+  "FACE",
+  "FACT",
+  "FEEL",
+  "FIND",
+  "FOUR",
+  "FROM",
+  "FULL",
+  "GAVE",
+  "GIVE",
+  "GOOD",
+  "HALF",
+  "HAND",
+  "HARD",
+  "HAVE",
+  "HEAD",
+  "HEAR",
+  "HELP",
+  "HERE",
+  "HIGH",
+  "HOME",
+  "HOPE",
+  "IDEA",
+  "INTO",
+  "JUST",
+  "KEEP",
+  "KIND",
+  "KNEW",
+  "KNOW",
+  "LAND",
+  "LAST",
+  "LEFT",
+  "LESS",
+  "LIFE",
+  "LIKE",
+  "LINE",
+  "LIST",
+  "LIVE",
+  "LONG",
+  "LOOK",
+  "LOST",
+  "LOVE",
+  "MADE",
+  "MAKE",
+  "MANY",
+  "MIND",
+  "MORE",
+  "MOST",
+  "MUCH",
+  "MUST",
+  "NAME",
+  "NEED",
+  "NEWS",
+  "NEXT",
+  "NICE",
+  "NONE",
+  "ONCE",
+  "ONLY",
+  "OPEN",
+  "OVER",
+  "PAID",
+  "PART",
+  "PAST",
+  "PLAN",
+  "PLAY",
+  "POST",
+  "PULL",
+  "PUSH",
+  "RATE",
+  "READ",
+  "REAL",
+  "REST",
+  "RISK",
+  "ROOM",
+  "SAFE",
+  "SAID",
+  "SAME",
+  "SEEN",
+  "SHOW",
+  "SIDE",
+  "SOME",
+  "SOON",
+  "STOP",
+  "SUCH",
+  "SURE",
+  "TAKE",
+  "TALK",
+  "TELL",
+  "THAN",
+  "THAT",
+  "THEM",
+  "THEN",
+  "THEY",
+  "THIS",
+  "TIME",
+  "TOOK",
+  "TRUE",
+  "TURN",
+  "UPON",
+  "VERY",
+  "WANT",
+  "WEEK",
+  "WELL",
+  "WENT",
+  "WERE",
+  "WHAT",
+  "WHEN",
+  "WILL",
+  "WITH",
+  "WORD",
+  "WORK",
+  "YEAR",
+  "YOUR",
+  // 5 letter common English
+  "ABOUT",
+  "AFTER",
+  "AGAIN",
+  "BEING",
+  "BELOW",
+  "BLACK",
+  "BRING",
+  "COULD",
+  "EARLY",
+  "EVERY",
+  "FIRST",
+  "GREAT",
+  "GREEN",
+  "HEARD",
+  "HOUSE",
+  "LARGE",
+  "LATER",
+  "LEARN",
+  "LEVEL",
+  "LIGHT",
+  "MIGHT",
+  "MONEY",
+  "MONTH",
+  "NEVER",
+  "NIGHT",
+  "OTHER",
+  "PLACE",
+  "POINT",
+  "POWER",
+  "PRICE",
+  "RIGHT",
+  "SHALL",
+  "SINCE",
+  "SMALL",
+  "SORRY",
+  "STAND",
+  "START",
+  "STATE",
+  "STILL",
+  "STUDY",
+  "THEIR",
+  "THERE",
+  "THESE",
+  "THING",
+  "THINK",
+  "THREE",
+  "TODAY",
+  "UNDER",
+  "UNTIL",
+  "WATER",
+  "WHERE",
+  "WHICH",
+  "WHITE",
+  "WHILE",
+  "WHOLE",
+  "WORLD",
+  "WOULD",
+  "WRITE",
+  "YOUNG",
+  // Finance acronyms that aren't tickers
+  "ETF",
+  "IPO",
+  "SEC",
+  "GDP",
+  "FDA",
+  "FED",
+  "CEO",
+  "CFO",
+  "COO",
+  "CTO",
+  "ATH",
+  "ATL",
+  "EOD",
+  "WSB",
+  "OTC",
+  "ITM",
+  "OTM",
+  "IMO",
+  "LOL",
+  "OMG",
+  "USA",
+  "NYSE",
+  "YOLO",
+  "FOMO",
+  "HODL",
+  "MOASS",
+  "TLDR",
+  "IMHO",
+  "LMAO",
+  "EDIT",
+  "TLDR",
+  "INFO",
+  "HUGE",
+  "GAIN",
+  "HOLD",
+  "SELL",
+  "MOON",
+  "CASH",
+  "DEBT",
+  "FUND",
+  "BEAR",
+  "BULL",
+  "BOND",
+  "LOAN",
+  "LOSS",
+  "PUMP",
+  "DUMP",
+  "LONG",
+  "MAMA",
+  "PAPA",
+  "FREE",
+  "ZERO",
+  "PLUS"
+]);
+var CASHTAG_RE = /\$([A-Z]{2,5})\b/g;
+var BARE_TICKER_RE = /\b([A-Z]{2,5})\b/g;
+function extractTickers(text) {
+  const tickers = /* @__PURE__ */ new Set();
+  let match;
+  CASHTAG_RE.lastIndex = 0;
+  while ((match = CASHTAG_RE.exec(text)) !== null) {
+    const ticker = match[1];
+    if (!STOP_WORDS.has(ticker)) {
+      tickers.add(ticker);
+    }
+  }
+  BARE_TICKER_RE.lastIndex = 0;
+  while ((match = BARE_TICKER_RE.exec(text)) !== null) {
+    const word = match[1];
+    if (!STOP_WORDS.has(word)) {
+      tickers.add(word);
+    }
+  }
+  return [...tickers];
+}
+var BULLISH_TERMS = [
+  "bull",
+  "calls",
+  "long",
+  "moon",
+  "rocket",
+  "tendies",
+  "diamond hands",
+  "buy",
+  "buying",
+  "bought",
+  "dip",
+  "undervalued",
+  "breakout",
+  "squeeze",
+  "gamma",
+  "rip",
+  "printing",
+  "lambo",
+  "gains",
+  "green",
+  "upside"
+];
+var BEARISH_TERMS = [
+  "bear",
+  "puts",
+  "short",
+  "dump",
+  "crash",
+  "sell",
+  "selling",
+  "sold",
+  "overvalued",
+  "bubble",
+  "bag",
+  "bagholder",
+  "red",
+  "loss",
+  "losses",
+  "downside",
+  "drill",
+  "tank",
+  "fade",
+  "rug",
+  "rekt",
+  "worthless"
+];
+function scoreSentiment(text) {
+  const lower = text.toLowerCase();
+  let score = 0;
+  for (const term of BULLISH_TERMS) {
+    if (lower.includes(term)) score += 1;
+  }
+  for (const term of BEARISH_TERMS) {
+    if (lower.includes(term)) score -= 1;
+  }
+  return score;
+}
+async function fetchSubredditPosts(subreddit, query, timeFilter, limit = 25) {
+  const url = `${REDDIT_BASE}/r/${encodeURIComponent(subreddit)}/search.json?q=${encodeURIComponent(query)}&sort=new&restrict_sr=on&t=${encodeURIComponent(timeFilter)}&limit=${encodeURIComponent(String(limit))}`;
+  const listing = await httpGet(url, {
+    headers: REDDIT_HEADERS
+  });
+  return listing.data.children.map((child) => ({
+    title: child.data.title,
+    selftext: child.data.selftext,
+    score: child.data.score,
+    numComments: child.data.num_comments,
+    createdUtc: child.data.created_utc,
+    permalink: child.data.permalink,
+    subreddit: child.data.subreddit
+  }));
+}
+async function getTrendingTickers(subreddits = DEFAULT_SUBREDDITS, limit = 20) {
+  const cacheKey = `trending:${[...subreddits].sort().join(",")}:${limit}`;
+  const cached = trendingCache.get(cacheKey);
+  if (cached) return cached;
+  const tickerMap = /* @__PURE__ */ new Map();
+  for (const sub of subreddits) {
+    let posts;
+    try {
+      posts = await fetchSubredditPosts(sub, "stocks OR market OR trading", "week");
+    } catch {
+      continue;
+    }
+    for (const post of posts) {
+      const text = `${post.title} ${post.selftext}`;
+      const tickers = extractTickers(text);
+      for (const ticker of tickers) {
+        const existing = tickerMap.get(ticker) ?? { mentions: 0, subreddits: {} };
+        existing.mentions += 1;
+        existing.subreddits[sub] = (existing.subreddits[sub] ?? 0) + 1;
+        tickerMap.set(ticker, existing);
+      }
+    }
+  }
+  const result = [...tickerMap.entries()].map(([symbol, data]) => ({ symbol, mentions: data.mentions, subreddits: data.subreddits })).sort((a, b) => b.mentions - a.mentions).slice(0, limit);
+  trendingCache.set(cacheKey, result);
+  return result;
+}
+async function getTickerMentions(symbol, period = "week") {
+  const cacheKey = `mentions:${symbol}:${period}`;
+  const cached = mentionCache.get(cacheKey);
+  if (cached) return cached;
+  const subredditCounts = {};
+  const allPosts = [];
+  for (const sub of DEFAULT_SUBREDDITS) {
+    let posts;
+    try {
+      posts = await fetchSubredditPosts(sub, symbol, period);
+    } catch {
+      continue;
+    }
+    subredditCounts[sub] = posts.length;
+    allPosts.push(...posts);
+  }
+  const topPosts = allPosts.sort((a, b) => b.score - a.score).slice(0, 10);
+  const result = {
+    symbol,
+    totalMentions: allPosts.length,
+    subreddits: subredditCounts,
+    topPosts
+  };
+  mentionCache.set(cacheKey, result);
+  return result;
+}
+async function getTickerSentiment(symbol, limit = 50) {
+  const cacheKey = `sentiment:${symbol}:${limit}`;
+  const cached = mentionCache.get(cacheKey);
+  if (cached) return cached;
+  const allPosts = [];
+  for (const sub of DEFAULT_SUBREDDITS) {
+    let posts;
+    try {
+      posts = await fetchSubredditPosts(sub, symbol, "week", limit);
+    } catch {
+      continue;
+    }
+    allPosts.push(...posts);
+  }
+  let bullishCount = 0;
+  let bearishCount = 0;
+  let neutralCount = 0;
+  let totalScore = 0;
+  const scored = allPosts.map((post) => {
+    const text = `${post.title} ${post.selftext}`;
+    const sentimentScore = scoreSentiment(text);
+    totalScore += sentimentScore;
+    if (sentimentScore > 0) bullishCount += 1;
+    else if (sentimentScore < 0) bearishCount += 1;
+    else neutralCount += 1;
+    return { ...post, sentimentScore };
+  });
+  const samplePosts = scored.sort((a, b) => Math.abs(b.sentimentScore) - Math.abs(a.sentimentScore)).slice(0, 10);
+  const result = {
+    symbol,
+    bullishCount,
+    bearishCount,
+    neutralCount,
+    averageScore: allPosts.length > 0 ? totalScore / allPosts.length : 0,
+    samplePosts
+  };
+  mentionCache.set(cacheKey, result);
+  return result;
+}
+
+// src/modules/reddit/index.ts
+var trendingTool2 = {
+  name: "reddit_trending",
+  description: "Get trending stock tickers from Reddit based on mention frequency. Scans r/wallstreetbets, r/stocks, r/investing, and r/options for posts mentioning tickers. Returns tickers sorted by mention count with per-subreddit breakdown. Limitation: uses keyword extraction (cashtags + uppercase words), not NLP \u2014 some false positives possible. Best for gauging retail buzz, not precise sentiment.",
+  inputSchema: z12.object({
+    subreddits: z12.array(z12.string()).max(10).optional().describe("Subreddits to scan (default: wallstreetbets, stocks, investing, options)"),
+    limit: z12.number().min(1).max(50).default(20).describe("Maximum number of trending tickers to return (default: 20)")
+  }),
+  readOnly: true,
+  handler: withMetadata(async (args) => {
+    const result = await getTrendingTickers(args.subreddits ?? [...DEFAULT_SUBREDDITS], args.limit ?? 20);
+    return successResult(JSON.stringify(result, null, 2));
+  }, { source: "reddit", dataDelay: "real-time" })
+};
+var mentionsTool = {
+  name: "reddit_mentions",
+  description: "Get mention count and top posts for a specific stock ticker across Reddit. Searches r/wallstreetbets, r/stocks, r/investing, and r/options. Returns total mentions, per-subreddit breakdown, and top 10 posts by score. Use this to check how much retail attention a ticker is getting.",
+  inputSchema: z12.object({
+    symbol: z12.string().max(10).describe("Stock ticker symbol (e.g. AAPL, TSLA, GME)"),
+    period: z12.enum(["hour", "day", "week"]).default("day").describe("Time period to search (default: day)")
+  }),
+  readOnly: true,
+  handler: withMetadata(async (args) => {
+    const result = await getTickerMentions(args.symbol.toUpperCase(), args.period ?? "day");
+    return successResult(JSON.stringify(result, null, 2));
+  }, { source: "reddit", dataDelay: "real-time" })
+};
+var sentimentTool = {
+  name: "reddit_sentiment",
+  description: "Get sentiment analysis for a stock ticker from Reddit discussions. Searches r/wallstreetbets, r/stocks, r/investing, and r/options, then scores each post using keyword matching (bullish terms like 'moon', 'calls', 'breakout' vs bearish terms like 'crash', 'puts', 'dump'). Returns bullish/bearish/neutral counts, average sentiment score, and sample posts. Limitation: keyword-based scoring, not NLP \u2014 sarcasm and context may be missed.",
+  inputSchema: z12.object({
+    symbol: z12.string().max(10).describe("Stock ticker symbol (e.g. AAPL, TSLA, GME)"),
+    limit: z12.number().min(1).max(100).default(50).describe("Maximum posts to analyze per subreddit (default: 50)")
+  }),
+  readOnly: true,
+  handler: withMetadata(async (args) => {
+    const result = await getTickerSentiment(args.symbol.toUpperCase(), args.limit ?? 50);
+    return successResult(JSON.stringify(result, null, 2));
+  }, { source: "reddit", dataDelay: "real-time" })
+};
+function createRedditModule() {
+  return {
+    name: "reddit",
+    description: "Reddit sentiment \u2014 trending tickers, mention tracking, and sentiment analysis from popular investing subreddits",
+    requiredEnvVars: [],
+    tools: [trendingTool2, mentionsTool, sentimentTool]
+  };
+}
+
+// src/modules/workspace/index.ts
+import { z as z14 } from "zod";
+
+// src/modules/workspace/storage.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import { lock } from "proper-lockfile";
+
+// src/modules/workspace/types.ts
+import { z as z13 } from "zod";
+var RESERVED_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype", "toString", "valueOf", "hasOwnProperty"]);
+var ProfileSchema = z13.object({
+  defaultExchange: z13.string().max(20).default("NASDAQ"),
+  tradingStyle: z13.string().max(100).optional(),
+  assetFocus: z13.array(z13.string().max(50)).max(20).default([]),
+  preferredTimeframe: z13.string().max(50).optional(),
+  workflowCadence: z13.enum(["daily", "weekly"]).default("daily"),
+  updatedAt: z13.string().default(() => (/* @__PURE__ */ new Date(0)).toISOString())
+});
+var InstrumentSchema = z13.object({
+  full: z13.string().max(80),
+  ticker: z13.string().max(50),
+  exchange: z13.string().optional(),
+  isCrypto: z13.boolean(),
+  input: z13.string().max(50),
+  note: z13.string().max(500).optional(),
+  addedAt: z13.string()
+});
+var WatchlistSchema = z13.object({
+  id: z13.string().max(100),
+  name: z13.string().max(100),
+  instruments: z13.array(InstrumentSchema).max(200).default([]),
+  createdAt: z13.string(),
+  updatedAt: z13.string()
+});
+var ThesisSchema = z13.object({
+  full: z13.string().max(80),
+  ticker: z13.string().max(50),
+  exchange: z13.string().optional(),
+  isCrypto: z13.boolean(),
+  input: z13.string().max(50),
+  summary: z13.string().max(5e3),
+  bullCase: z13.string().max(2e3).optional(),
+  bearCase: z13.string().max(2e3).optional(),
+  catalyst: z13.string().max(2e3).optional(),
+  invalidation: z13.string().max(2e3).optional(),
+  timeframe: z13.string().max(100).optional(),
+  nextReviewDate: z13.string().optional(),
+  confidence: z13.number().min(0).max(5).optional(),
+  updatedAt: z13.string(),
+  archivedAt: z13.string().optional()
+});
+var WorkspaceSchema = z13.object({
+  schemaVersion: z13.number().default(1),
+  profile: ProfileSchema.default(() => ProfileSchema.parse({})),
+  watchlists: z13.record(z13.string(), WatchlistSchema).refine(
+    (rec) => Object.keys(rec).every((k) => !RESERVED_KEYS.has(k)),
+    { message: "Workspace contains a reserved key in watchlists" }
+  ).default({}),
+  theses: z13.record(z13.string(), ThesisSchema).refine(
+    (rec) => Object.keys(rec).every((k) => !RESERVED_KEYS.has(k)),
+    { message: "Workspace contains a reserved key in theses" }
+  ).default({})
+});
+
+// src/modules/workspace/storage.ts
+var StorageManager = class {
+  filePath;
+  lockPath;
+  defaultExchange;
+  constructor(dataDir, defaultExchange = "NASDAQ") {
+    this.filePath = path.join(dataDir, "workspace.json");
+    this.lockPath = path.join(dataDir, ".workspace.lock");
+    this.defaultExchange = defaultExchange;
+  }
+  async assertNotSymlink(filePath) {
+    try {
+      const stat2 = await fs.lstat(filePath);
+      if (stat2.isSymbolicLink()) {
+        throw new Error(`Refusing to operate on symlink: ${filePath}`);
+      }
+    } catch (e) {
+      if (e instanceof Error && "code" in e && e.code === "ENOENT") {
+        return;
+      }
+      throw e;
+    }
+  }
+  async exists() {
+    try {
+      await fs.access(this.filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async load() {
+    await this.assertNotSymlink(this.filePath);
+    if (!await this.exists()) {
+      const defaultData = WorkspaceSchema.parse({
+        profile: { defaultExchange: this.defaultExchange }
+      });
+      return { data: defaultData, lastModified: 0 };
+    }
+    const fh = await fs.open(this.filePath, "r");
+    try {
+      const [raw, stat2] = await Promise.all([
+        fh.readFile("utf-8"),
+        fh.stat()
+      ]);
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch (e) {
+        throw new Error(`Workspace file corrupted: ${e instanceof Error ? e.message : String(e)}`);
+      }
+      const data = WorkspaceSchema.parse(parsed);
+      return { data, lastModified: stat2.mtimeMs };
+    } finally {
+      await fh.close();
+    }
+  }
+  async save(data, expectedLastModified) {
+    const dir = path.dirname(this.filePath);
+    await fs.mkdir(dir, { recursive: true });
+    await this.assertNotSymlink(this.lockPath);
+    await fs.writeFile(this.lockPath, "", "utf-8");
+    let release;
+    let tmpPath;
+    try {
+      release = await lock(this.lockPath, {
+        retries: {
+          retries: 5,
+          minTimeout: 100,
+          maxTimeout: 1e3
+        }
+      });
+      await this.assertNotSymlink(this.filePath);
+      const fileExists = await this.exists();
+      if (expectedLastModified === 0 && fileExists) {
+        throw new Error("Conflict: The workspace was already initialized by another process. Please reload.");
+      }
+      if (expectedLastModified > 0) {
+        if (!fileExists) {
+          throw new Error("Conflict: The workspace file has been deleted. Please reload.");
+        }
+        const stat2 = await fs.stat(this.filePath);
+        if (stat2.mtimeMs > expectedLastModified) {
+          throw new Error("Conflict: The workspace has been modified by another process. Please reload and try again.");
+        }
+      }
+      tmpPath = `${this.filePath}.tmp`;
+      const bakPath = `${this.filePath}.bak`;
+      const content = JSON.stringify(data, null, 2);
+      await this.assertNotSymlink(tmpPath);
+      await this.assertNotSymlink(bakPath);
+      await fs.writeFile(tmpPath, content, "utf-8");
+      if (fileExists) {
+        await fs.copyFile(this.filePath, bakPath);
+      }
+      await fs.rename(tmpPath, this.filePath);
+      const newStat = await fs.stat(this.filePath);
+      return newStat.mtimeMs;
+    } finally {
+      if (release) {
+        await release();
+      }
+      if (tmpPath) {
+        try {
+          await fs.unlink(tmpPath);
+        } catch {
+        }
+      }
+    }
+  }
+};
+
+// src/modules/workspace/index.ts
+function createWorkspaceModule(dataDir, defaultExchange = "NASDAQ") {
+  const storage = new StorageManager(dataDir, defaultExchange);
+  return {
+    name: "workspace",
+    description: "Stateful market workspace for watchlists, profiles, and theses.",
+    requiredEnvVars: [],
+    // Response shape convention: all tools use successResult(JSON.stringify(data, null, 2)).
+    // Read tools return domain data directly (profile object, watchlists record, thesis lookup).
+    // Write tools return { success, message, ...context } envelopes so the LLM confirms the operation.
+    tools: [
+      {
+        name: "workspace_get_profile",
+        description: "Get the current user's trading profile and workspace settings.",
+        inputSchema: z14.object({}),
+        readOnly: true,
+        openWorld: false,
+        handler: withMetadata(async () => {
+          const { data } = await storage.load();
+          return successResult(JSON.stringify(data.profile, null, 2));
+        }, { source: "workspace" })
+      },
+      {
+        name: "workspace_update_profile",
+        description: "Update the user's trading profile (style, asset focus, review cadence).",
+        inputSchema: z14.object({
+          tradingStyle: z14.string().max(100).optional().describe("E.g., 'options', 'swing', 'day'"),
+          assetFocus: z14.array(z14.string().max(50)).max(20).optional().describe("Asset classes like 'equities', 'crypto'"),
+          workflowCadence: z14.enum(["daily", "weekly"]).optional().describe("How often you review the market")
+        }),
+        readOnly: false,
+        openWorld: false,
+        handler: withMetadata(async ({ tradingStyle, assetFocus, workflowCadence }) => {
+          const { data, lastModified } = await storage.load();
+          if (tradingStyle !== void 0) data.profile.tradingStyle = tradingStyle;
+          if (assetFocus !== void 0) data.profile.assetFocus = assetFocus;
+          if (workflowCadence !== void 0) data.profile.workflowCadence = workflowCadence;
+          data.profile.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          try {
+            await storage.save(data, lastModified);
+          } catch (e) {
+            if (e instanceof Error && e.message.startsWith("Conflict:")) {
+              return errorResult(e.message, "CONFLICT");
+            }
+            throw e;
+          }
+          return successResult(JSON.stringify({
+            success: true,
+            message: "Profile updated successfully.",
+            profile: data.profile
+          }, null, 2));
+        }, { source: "workspace" })
+      },
+      {
+        name: "workspace_list_watchlists",
+        description: "List all watchlists and their instruments.",
+        inputSchema: z14.object({}),
+        readOnly: true,
+        openWorld: false,
+        handler: withMetadata(async () => {
+          const { data } = await storage.load();
+          return successResult(JSON.stringify(data.watchlists, null, 2));
+        }, { source: "workspace" })
+      },
+      {
+        name: "workspace_create_watchlist",
+        description: "Create a new empty watchlist (max 50 per workspace).",
+        inputSchema: z14.object({
+          name: z14.string().max(100).describe("The ID/name of the watchlist (e.g., 'core', 'swing')")
+        }),
+        readOnly: false,
+        openWorld: false,
+        handler: withMetadata(async ({ name }) => {
+          if (RESERVED_KEYS.has(name)) {
+            return errorResult(`Invalid watchlist name: '${name}' is a reserved keyword.`);
+          }
+          const { data, lastModified } = await storage.load();
+          if (Object.keys(data.watchlists).length >= 50) {
+            return errorResult("Maximum of 50 watchlists reached.");
+          }
+          if (data.watchlists[name]) {
+            return errorResult(`Watchlist '${name}' already exists.`);
+          }
+          data.watchlists[name] = {
+            id: name,
+            name,
+            instruments: [],
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          try {
+            await storage.save(data, lastModified);
+          } catch (e) {
+            if (e instanceof Error && e.message.startsWith("Conflict:")) {
+              return errorResult(e.message, "CONFLICT");
+            }
+            throw e;
+          }
+          return successResult(JSON.stringify({
+            success: true,
+            message: `Watchlist '${name}' created successfully.`
+          }, null, 2));
+        }, { source: "workspace" })
+      },
+      {
+        name: "workspace_update_watchlist",
+        description: "Replace the instruments in a specific watchlist.",
+        inputSchema: z14.object({
+          name: z14.string().max(100).describe("The ID of the watchlist to update"),
+          symbols: z14.array(z14.string().max(50)).max(200).describe("Raw symbols to track (e.g., ['AAPL', 'BTC'])")
+        }),
+        readOnly: false,
+        openWorld: false,
+        handler: withMetadata(async ({ name, symbols }) => {
+          if (RESERVED_KEYS.has(name)) {
+            return errorResult(`Invalid watchlist name: '${name}' is a reserved keyword.`);
+          }
+          const { data, lastModified } = await storage.load();
+          if (!data.watchlists[name]) {
+            return errorResult(`Watchlist '${name}' does not exist.`);
+          }
+          const seen = /* @__PURE__ */ new Set();
+          const instruments = [];
+          for (const sym of symbols) {
+            const resolved = resolveTicker(sym, data.profile.defaultExchange);
+            if (seen.has(resolved.full)) continue;
+            seen.add(resolved.full);
+            instruments.push({
+              full: resolved.full,
+              ticker: resolved.ticker,
+              exchange: resolved.exchange,
+              isCrypto: resolved.isCrypto,
+              input: sym,
+              addedAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+          data.watchlists[name].instruments = instruments;
+          data.watchlists[name].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          try {
+            await storage.save(data, lastModified);
+          } catch (e) {
+            if (e instanceof Error && e.message.startsWith("Conflict:")) {
+              return errorResult(e.message, "CONFLICT");
+            }
+            throw e;
+          }
+          return successResult(JSON.stringify({
+            success: true,
+            message: `Watchlist '${name}' updated with ${instruments.length} instruments (deduplicated).`,
+            instrumentCount: instruments.length
+          }, null, 2));
+        }, { source: "workspace" })
+      },
+      {
+        name: "workspace_get_thesis",
+        description: "Get the saved global investment thesis for a specific symbol. Returns a stable JSON shape with a 'found' flag.",
+        inputSchema: z14.object({
+          symbol: z14.string().max(50).describe("The raw symbol (e.g., 'AAPL')")
+        }),
+        readOnly: true,
+        openWorld: false,
+        handler: withMetadata(async ({ symbol }) => {
+          const { data } = await storage.load();
+          const resolved = resolveTicker(symbol, data.profile.defaultExchange);
+          const thesis = data.theses[resolved.full];
+          return successResult(JSON.stringify({
+            found: !!thesis,
+            symbol: resolved.full,
+            thesis: thesis || null
+          }, null, 2));
+        }, { source: "workspace" })
+      },
+      {
+        name: "workspace_save_thesis",
+        description: "Save or update the global investment thesis for a specific symbol (max 200 per workspace).",
+        inputSchema: z14.object({
+          symbol: z14.string().max(50).describe("The raw symbol (e.g., 'AAPL')"),
+          summary: z14.string().max(5e3).describe("Brief summary of your investment view"),
+          bullCase: z14.string().max(2e3).optional().describe("Arguments for price going up"),
+          bearCase: z14.string().max(2e3).optional().describe("Arguments for price going down"),
+          catalyst: z14.string().max(2e3).optional().describe("Upcoming events that might move the price"),
+          timeframe: z14.string().max(100).optional().describe("Investment horizon (e.g., '3-6 months')")
+        }),
+        readOnly: false,
+        openWorld: false,
+        handler: withMetadata(async ({ symbol, summary, bullCase, bearCase, catalyst, timeframe }) => {
+          if (RESERVED_KEYS.has(symbol) || RESERVED_KEYS.has(symbol.toLowerCase())) {
+            return errorResult(`Invalid symbol: '${symbol}' resolves to a reserved keyword.`);
+          }
+          const { data, lastModified } = await storage.load();
+          const resolved = resolveTicker(symbol, data.profile.defaultExchange);
+          const existing = data.theses[resolved.full];
+          if (!existing && Object.keys(data.theses).length >= 200) {
+            return errorResult("Maximum of 200 theses reached.");
+          }
+          data.theses[resolved.full] = {
+            ...existing,
+            full: resolved.full,
+            ticker: resolved.ticker,
+            exchange: resolved.exchange,
+            isCrypto: resolved.isCrypto,
+            input: symbol,
+            summary,
+            bullCase: bullCase ?? existing?.bullCase,
+            bearCase: bearCase ?? existing?.bearCase,
+            catalyst: catalyst ?? existing?.catalyst,
+            timeframe: timeframe ?? existing?.timeframe,
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          try {
+            await storage.save(data, lastModified);
+          } catch (e) {
+            if (e instanceof Error && e.message.startsWith("Conflict:")) {
+              return errorResult(e.message, "CONFLICT");
+            }
+            throw e;
+          }
+          return successResult(JSON.stringify({
+            success: true,
+            message: `Thesis saved for ${resolved.full}.`,
+            ticker: resolved.full
+          }, null, 2));
+        }, { source: "workspace" })
+      }
+    ]
+  };
+}
+
+// src/registry.ts
+import * as path2 from "path";
+import * as os from "os";
+var MODULE_CATALOG = [
+  { name: "tradingview", envVar: null, toolCount: 10, factory: () => createTradingviewModule() },
+  { name: "tradingview-crypto", envVar: null, toolCount: 4, factory: () => createTradingviewCryptoModule() },
+  { name: "sec-edgar", envVar: null, toolCount: 6, factory: () => createSecEdgarModule() },
+  { name: "coingecko", envVar: null, toolCount: 3, factory: () => createCoingeckoModule() },
+  { name: "options", envVar: null, toolCount: 5, factory: () => createOptionsModule() },
+  { name: "options-cboe", envVar: null, toolCount: 1, factory: () => createOptionsCboeModule() },
+  { name: "finnhub", envVar: "FINNHUB_API_KEY", toolCount: 9, factory: (config) => config.env.FINNHUB_API_KEY ? createFinnhubModule(config.env.FINNHUB_API_KEY) : null },
+  { name: "alpha-vantage", envVar: "ALPHA_VANTAGE_API_KEY", toolCount: 5, factory: (config) => config.env.ALPHA_VANTAGE_API_KEY ? createAlphaVantageModule(config.env.ALPHA_VANTAGE_API_KEY) : null },
+  { name: "fred", envVar: "FRED_API_KEY", toolCount: 4, factory: (config) => config.env.FRED_API_KEY ? createFredModule(config.env.FRED_API_KEY) : null },
+  { name: "sentiment", envVar: null, toolCount: 2, factory: () => createSentimentModule() },
+  { name: "frankfurter", envVar: null, toolCount: 5, factory: () => createFrankfurterModule() },
+  { name: "reddit", envVar: null, toolCount: 3, factory: () => createRedditModule() },
+  { name: "workspace", envVar: null, toolCount: 7, factory: (config) => config.enableWorkspace ? createWorkspaceModule(config.dataDir || path2.join(os.homedir(), ".stock-scanner-mcp"), config.defaultExchange) : null }
+];
+function resolveEnabledModules(allModules, env, filter) {
+  return allModules.filter((mod) => {
+    if (filter && !filter.includes(mod.name)) return false;
+    const hasKeys = mod.requiredEnvVars.every((key) => env[key]);
+    if (!hasKeys) {
+      return false;
+    }
+    return true;
+  });
+}
+
+export {
+  MODULE_CATALOG,
+  resolveEnabledModules
+};