schwab_mcp 0.1.0

data/lib/schwab_mcp/tools/list_movers_tool.rb

@@ -0,0 +1,125 @@
+require "mcp"
+require "schwab_rb"
+require "json"
+require_relative "../loggable"
+
+module SchwabMCP
+  module Tools
+    class ListMoversTool < MCP::Tool
+      extend Loggable
+      description "Get a list of the top ten movers for a given index using Schwab API"
+
+      input_schema(
+        properties: {
+          index: {
+            type: "string",
+            description: "Category of mover",
+            enum: ["$DJI", "$COMPX", "$SPX", "NYSE", "NASDAQ", "OTCBB", "INDEX_ALL", "EQUITY_ALL", "OPTION_ALL", "OPTION_PUT", "OPTION_CALL"]
+          },
+          sort_order: {
+            type: "string",
+            description: "Order in which to return values (optional)",
+            enum: ["VOLUME", "TRADES", "PERCENT_CHANGE_UP", "PERCENT_CHANGE_DOWN"]
+          },
+          frequency: {
+            type: "integer",
+            description: "Only return movers that saw this magnitude or greater (optional)",
+            enum: [0, 1, 5, 10, 30, 60]
+          }
+        },
+        required: ["index"]
+      )
+
+      annotations(
+        title: "List Market Movers",
+        read_only_hint: true,
+        destructive_hint: false,
+        idempotent_hint: true
+      )
+
+      def self.call(index:, sort_order: nil, frequency: nil, server_context:)
+        log_info("Getting movers for index: #{index}, sort_order: #{sort_order}, frequency: #{frequency}")
+
+        begin
+          client = SchwabRb::Auth.init_client_easy(
+            ENV['SCHWAB_API_KEY'],
+            ENV['SCHWAB_APP_SECRET'],
+            ENV['SCHWAB_CALLBACK_URI'],
+            ENV['TOKEN_PATH']
+          )
+
+          unless client
+            log_error("Failed to initialize Schwab client")
+            return MCP::Tool::Response.new([{
+              type: "text",
+              text: "**Error**: Failed to initialize Schwab client. Check your credentials."
+            }])
+          end
+
+          log_debug("Making API request for movers - index: #{index}, sort_order: #{sort_order}, frequency: #{frequency}")
+
+          response = client.get_movers(
+            index,
+            sort_order: sort_order,
+            frequency: frequency
+          )
+
+          if response&.body
+            log_info("Successfully retrieved movers for index #{index}")
+            parsed_body = JSON.parse(response.body)
+
+            formatted_output = format_movers_response(parsed_body, index, sort_order, frequency)
+
+            MCP::Tool::Response.new([{
+              type: "text",
+              text: formatted_output
+            }])
+          else
+            log_warn("Empty response from Schwab API for movers")
+            MCP::Tool::Response.new([{
+              type: "text",
+              text: "**No Data**: Empty response from Schwab API for movers"
+            }])
+          end
+
+        rescue => e
+          log_error("Error retrieving movers: #{e.message}")
+          log_debug("Backtrace: #{e.backtrace.first(3).join('\n')}")
+          MCP::Tool::Response.new([{
+            type: "text",
+            text: "**Error** retrieving movers: #{e.message}\n\n#{e.backtrace.first(3).join('\n')}"
+          }])
+        end
+      end
+
+      private
+
+      def self.format_movers_response(data, index, sort_order, frequency)
+        header = "**Market Movers for #{index}**"
+        header += " (sorted by #{sort_order})" if sort_order
+        header += " (frequency filter: #{frequency})" if frequency
+        header += "\n\n"
+
+        if data.is_a?(Array) && data.any?
+          movers_list = data.map.with_index(1) do |mover, i|
+            symbol = mover['symbol'] || 'N/A'
+            description = mover['description'] || 'N/A'
+            change = mover['change'] || 0
+            percent_change = mover['percentChange'] || 0
+            volume = mover['totalVolume'] || 0
+            last_price = mover['last'] || 0
+
+            "#{i}. **#{symbol}** - #{description}\n" \
+            "   Last: $#{last_price}\n" \
+            "   Change: #{change >= 0 ? '+' : ''}#{change} (#{percent_change >= 0 ? '+' : ''}#{percent_change}%)\n" \
+            "   Volume: #{volume.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse}"
+          end.join("\n\n")
+
+          "#{header}#{movers_list}"
+        else
+          "#{header}No movers data available.\n\n**Raw Response:**\n```json\n#{JSON.pretty_generate(data)}\n```"
+        end
+      end
+    end
+  end
+end

data/lib/schwab_mcp/tools/list_schwab_accounts_tool.rb

@@ -0,0 +1,162 @@
+require "mcp"
+require "schwab_rb"
+require "json"
+require_relative "../loggable"
+require_relative "../redactor"
+
+module SchwabMCP
+  module Tools
+    class ListSchwabAccountsTool < MCP::Tool
+      extend Loggable
+      description "List all configured Schwab accounts with their friendly names and basic info"
+
+      input_schema(
+        properties: {},
+        required: []
+      )
+
+      annotations(
+        title: "List Schwab Accounts",
+        read_only_hint: true,
+        destructive_hint: false,
+        idempotent_hint: true
+      )
+
+      def self.call(server_context:)
+        log_info("Listing all configured Schwab accounts")
+
+        begin
+          client = SchwabRb::Auth.init_client_easy(
+            ENV['SCHWAB_API_KEY'],
+            ENV['SCHWAB_APP_SECRET'],
+            ENV['SCHWAB_CALLBACK_URI'],
+            ENV['TOKEN_PATH']
+          )
+
+          unless client
+            log_error("Failed to initialize Schwab client")
+            return MCP::Tool::Response.new([{
+              type: "text",
+              text: "**Error**: Failed to initialize Schwab client. Check your credentials."
+            }])
+          end
+
+          log_debug("Fetching account numbers from Schwab API")
+          account_numbers_response = client.get_account_numbers
+
+          unless account_numbers_response&.body
+            log_error("Failed to retrieve account numbers")
+            return MCP::Tool::Response.new([{
+              type: "text",
+              text: "**Error**: Failed to retrieve account numbers from Schwab API"
+            }])
+          end
+
+          account_mappings = JSON.parse(account_numbers_response.body)
+          log_debug("Retrieved #{account_mappings.length} accounts from Schwab API")
+
+          configured_accounts = find_configured_accounts(account_mappings)
+
+          if configured_accounts.empty?
+            return MCP::Tool::Response.new([{
+              type: "text",
+              text: "**No Configured Accounts Found**\n\nNo environment variables found ending with '_ACCOUNT'.\n\nTo configure accounts, set environment variables like:\n- TRADING_BROKERAGE_ACCOUNT=123456789\n- RETIREMENT_IRA_ACCOUNT=987654321\n- INCOME_BROKERAGE_ACCOUNT=555666777"
+            }])
+          end
+
+          formatted_response = format_accounts_list(configured_accounts, account_mappings)
+
+          MCP::Tool::Response.new([{
+            type: "text",
+            text: formatted_response
+          }])
+
+        rescue JSON::ParserError => e
+          log_error("JSON parsing error: #{e.message}")
+          MCP::Tool::Response.new([{
+            type: "text",
+            text: "**Error**: Failed to parse API response: #{e.message}"
+          }])
+        rescue => e
+          log_error("Error listing accounts: #{e.message}")
+          log_debug("Backtrace: #{e.backtrace.first(3).join('\n')}")
+          MCP::Tool::Response.new([{
+            type: "text",
+            text: "**Error** listing accounts: #{e.message}\n\n#{e.backtrace.first(3).join('\n')}"
+          }])
+        end
+      end
+
+      private
+
+      def self.find_configured_accounts(account_mappings)
+        # Get all account IDs from Schwab API
+        schwab_account_ids = account_mappings.map { |mapping| mapping["accountNumber"] }
+
+        # Find environment variables ending with "_ACCOUNT"
+        configured = []
+        ENV.each do |key, value|
+          next unless key.end_with?('_ACCOUNT')
+
+          if schwab_account_ids.include?(value)
+            configured << {
+              name: key,
+              friendly_name: friendly_name_from_env_key(key),
+              account_id: value,
+              mapping: account_mappings.find { |m| m["accountNumber"] == value }
+            }
+          end
+        end
+
+        configured.sort_by { |account| account[:name] }
+      end
+
+      def self.friendly_name_from_env_key(env_key)
+        # Convert "TRADING_BROKERAGE_ACCOUNT" to "Trading Brokerage"
+        env_key.gsub('_ACCOUNT', '').split('_').map(&:capitalize).join(' ')
+      end
+
+      def self.format_accounts_list(configured_accounts, all_mappings)
+        response = "**Configured Schwab Accounts:**\n\n"
+
+        configured_accounts.each_with_index do |account, index|
+          response += "#{index + 1}. **#{account[:friendly_name]}** (`#{account[:name]}`)\n"
+          response += "   - Account ID: #{Redactor::REDACTED_ACCOUNT_PLACEHOLDER}\n"
+          response += "   - Status: ✅ Configured\n\n"
+        end
+
+        # Show unconfigured accounts (if any)
+        unconfigured = all_mappings.reject do |mapping|
+          configured_accounts.any? { |config| config[:account_id] == mapping["accountNumber"] }
+        end
+
+        if unconfigured.any?
+          response += "**Unconfigured Accounts Available:**\n\n"
+          unconfigured.each_with_index do |mapping, index|
+            response += "#{index + 1}. Account ID: #{Redactor::REDACTED_ACCOUNT_PLACEHOLDER}\n"
+            response += "   - To configure: Set `YOUR_NAME_ACCOUNT=#{Redactor::REDACTED_ACCOUNT_PLACEHOLDER}` in your .env file\n\n"
+          end
+        end
+
+        response += "**Usage:**\n"
+        response += "To get account information, use the `schwab_account` tool with one of these account names:\n"
+        configured_accounts.each do |account|
+          response += "- `#{account[:name]}`\n"
+        end
+
+        if configured_accounts.any?
+          response += "\n**Example:**\n"
+          first_account = configured_accounts.first
+          response += "```\n"
+          response += "Tool: schwab_account\n"
+          response += "Parameters: {\n"
+          response += "  \"account_name\": \"#{first_account[:name]}\"\n"
+          response += "}\n"
+          response += "```"
+        end
+
+        response
+      end
+    end
+  end
+end

data/lib/schwab_mcp/tools/option_chain_tool.rb

@@ -0,0 +1,274 @@
+require "mcp"
+require "schwab_rb"
+require "json"
+require "date"
+require_relative "../loggable"
+require_relative "../option_chain_filter"
+
+module SchwabMCP
+  module Tools
+    class OptionChainTool < MCP::Tool
+      extend Loggable
+      description "Get option chain data for an optionable symbol using Schwab API"
+
+      input_schema(
+        properties: {
+          symbol: {
+            type: "string",
+            description: "Instrument symbol (e.g., 'AAPL', 'TSLA')",
+            pattern: "^[A-Za-z]{1,5}$"
+          },
+          contract_type: {
+            type: "string",
+            description: "Type of contracts to return in the chain",
+            enum: ["CALL", "PUT", "ALL"]
+          },
+          strike_count: {
+            type: "integer",
+            description: "Number of strikes above and below the ATM price",
+            minimum: 1
+          },
+          include_underlying_quote: {
+            type: "boolean",
+            description: "Include a quote for the underlying instrument"
+          },
+          strategy: {
+            type: "string",
+            description: "Strategy type for the option chain",
+            enum: ["SINGLE", "ANALYTICAL", "COVERED", "VERTICAL", "CALENDAR", "STRANGLE", "STRADDLE", "BUTTERFLY", "CONDOR", "DIAGONAL", "COLLAR", "ROLL"]
+          },
+          strike_range: {
+            type: "string",
+            description: "Range of strikes to include",
+            enum: ["ITM", "NTM", "OTM", "SAK", "SBK", "SNK", "ALL"]
+          },
+          option_type: {
+            type: "string",
+            description: "Type of options to include in the chain",
+            enum: ["S", "NS", "ALL"]
+          },
+          exp_month: {
+            type: "string",
+            description: "Filter options by expiration month",
+            enum: ["JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC", "ALL"]
+          },
+          interval: {
+            type: "number",
+            description: "Strike interval for spread strategy chains"
+          },
+          strike: {
+            type: "number",
+            description: "Specific strike price for the option chain"
+          },
+          from_date: {
+            type: "string",
+            description: "Filter expirations after this date (YYYY-MM-DD format)"
+          },
+          to_date: {
+            type: "string",
+            description: "Filter expirations before this date (YYYY-MM-DD format)"
+          },
+          volatility: {
+            type: "number",
+            description: "Volatility for analytical calculations"
+          },
+          underlying_price: {
+            type: "number",
+            description: "Underlying price for analytical calculations"
+          },
+          interest_rate: {
+            type: "number",
+            description: "Interest rate for analytical calculations"
+          },
+          days_to_expiration: {
+            type: "integer",
+            description: "Days to expiration for analytical calculations"
+          },
+          entitlement: {
+            type: "string",
+            description: "Client entitlement",
+            enum: ["PP", "NP", "PN"]
+          },
+          max_delta: {
+            type: "number",
+            description: "Maximum delta value for option filtering",
+            minimum: 0,
+            maximum: 1
+          },
+          min_delta: {
+            type: "number",
+            description: "Minimum delta value for option filtering",
+            minimum: 0,
+            maximum: 1
+          },
+          max_strike: {
+            type: "number",
+            description: "Maximum strike price for option filtering"
+          },
+          min_strike: {
+            type: "number",
+            description: "Minimum strike price for option filtering"
+          },
+          expiration_date: {
+            type: "string",
+            description: "Filter options by specific expiration date (YYYY-MM-DD format)"
+          }
+        },
+        required: ["symbol"]
+      )
+
+      annotations(
+        title: "Get Option Chain Data",
+        read_only_hint: true,
+        destructive_hint: false,
+        idempotent_hint: true
+      )
+
+      def self.call(symbol:, contract_type: nil, strike_count: nil, include_underlying_quote: nil,
+                    strategy: nil, strike_range: nil, option_type: nil, exp_month: nil,
+                    interval: nil, strike: nil, from_date: nil, to_date: nil, volatility: nil,
+                    underlying_price: nil, interest_rate: nil, days_to_expiration: nil,
+                    entitlement: nil, max_delta: nil, min_delta: nil, max_strike: nil,
+                    min_strike: nil, expiration_date: nil, server_context:)
+        log_info("Getting option chain for symbol: #{symbol}")
+
+        begin
+          client = SchwabRb::Auth.init_client_easy(
+            ENV['SCHWAB_API_KEY'],
+            ENV['SCHWAB_APP_SECRET'],
+            ENV['SCHWAB_CALLBACK_URI'],
+            ENV['TOKEN_PATH']
+          )
+
+          unless client
+            log_error("Failed to initialize Schwab client")
+            return MCP::Tool::Response.new([{
+              type: "text",
+              text: "**Error**: Failed to initialize Schwab client. Check your credentials."
+            }])
+          end
+
+          params = {}
+          params[:contract_type] = contract_type if contract_type
+          params[:strike_count] = strike_count if strike_count
+          params[:include_underlying_quote] = include_underlying_quote unless include_underlying_quote.nil?
+          params[:strategy] = strategy if strategy
+          params[:interval] = interval if interval
+          params[:strike] = strike if strike
+          params[:strike_range] = strike_range if strike_range
+
+          if expiration_date
+            exp_date = Date.parse(expiration_date)
+            params[:from_date] = exp_date
+            params[:to_date] = exp_date
+          else
+            params[:from_date] = Date.parse(from_date) if from_date
+            params[:to_date] = Date.parse(to_date) if to_date
+          end
+
+          params[:volatility] = volatility if volatility
+          params[:underlying_price] = underlying_price if underlying_price
+          params[:interest_rate] = interest_rate if interest_rate
+          params[:days_to_expiration] = days_to_expiration if days_to_expiration
+          params[:exp_month] = exp_month if exp_month
+          params[:option_type] = option_type if option_type
+          params[:entitlement] = entitlement if entitlement
+
+          log_debug("Making API request for option chain with params: #{params}")
+          response = client.get_option_chain(symbol.upcase, **params)
+
+          if response&.body
+            log_info("Successfully retrieved option chain for #{symbol}")
+
+            if max_delta || min_delta || max_strike || min_strike
+              begin
+                parsed_response = JSON.parse(response.body, symbolize_names: true)
+
+                log_debug("Applying option chain filtering")
+
+                filter = SchwabMCP::OptionChainFilter.new(
+                  expiration_date: Date.parse(expiration_date),
+                  max_delta: max_delta || 1.0,
+                  min_delta: min_delta || 0.0,
+                  max_strike: max_strike,
+                  min_strike: min_strike
+                )
+
+                filtered_response = parsed_response.dup
+
+                if parsed_response[:callExpDateMap]
+                  filtered_calls = filter.select(parsed_response[:callExpDateMap])
+                  log_debug("Filtered #{filtered_calls.size} call options")
+
+                  filtered_response[:callExpDateMap] = reconstruct_exp_date_map(
+                    filtered_calls, expiration_date
+                  )
+                end
+
+                if parsed_response[:putExpDateMap]
+                  filtered_puts = filter.select(parsed_response[:putExpDateMap])
+                  log_debug("Filtered #{filtered_puts.size} put options")
+
+                  filtered_response[:putExpDateMap] = reconstruct_exp_date_map(
+                    filtered_puts, expiration_date)
+                end
+
+                File.open("filtered_option_chain_#{symbol}_#{expiration_date}.json", "w") do |f|
+                  f.write(JSON.pretty_generate(filtered_response))
+                end
+
+                return MCP::Tool::Response.new([{
+                  type: "text",
+                  text: "#{JSON.pretty_generate(filtered_response)}\n"
+                }])
+              rescue JSON::ParserError => e
+                log_error("Failed to parse response for filtering: #{e.message}")
+              rescue => e
+                log_error("Error applying option chain filter: #{e.message}")
+              end
+            else
+              log_debug("No filtering applied, returning full response")
+              return MCP::Tool::Response.new([{
+                type: "text",
+                text: "#{JSON.pretty_generate(response.body)}\n"
+              }])
+            end
+          else
+            log_warn("Empty response from Schwab API for option chain: #{symbol}")
+            MCP::Tool::Response.new([{
+              type: "text",
+              text: "**No Data**: Empty response from Schwab API for option chain: #{symbol}"
+            }])
+          end
+
+        rescue => e
+          log_error("Error retrieving option chain for #{symbol}: #{e.message}")
+          log_debug("Backtrace: #{e.backtrace.first(3).join('\n')}")
+          MCP::Tool::Response.new([{
+            type: "text",
+            text: "**Error** retrieving option chain for #{symbol}: #{e.message}\n\n#{e.backtrace.first(3).join('\n')}"
+          }])
+        end
+      end
+
+      private
+
+      def self.reconstruct_exp_date_map(filtered_options, target_expiration_date)
+        return {} if filtered_options.empty?
+
+        grouped = {}
+
+        filtered_options.each do |option|
+          exp_date_key = "#{target_expiration_date}:#{option[:daysToExpiration] || 0}"
+          strike_key = "#{option[:strikePrice]}"
+
+          grouped[exp_date_key] ||= {}
+          grouped[exp_date_key][strike_key] ||= []
+          grouped[exp_date_key][strike_key] << option
+        end
+
+        grouped
+      end
+    end
+  end
+end