schwab_mcp 0.1.0

data/lib/schwab_mcp/option_chain_filter.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+require_relative "loggable"
+
+module SchwabMCP
+  class OptionChainFilter
+    include Loggable
+
+    attr_reader :expiration_date, :underlying_price, :expiration_type,
+                :settlement_type, :option_root, :max_delta, :max_spread,
+                :min_credit, :min_open_interest, :dist_from_strike, :quantity,
+                :min_delta, :min_strike, :max_strike
+
+    def initialize(
+      expiration_date:,
+      underlying_price: nil,
+      expiration_type: nil,
+      settlement_type: nil,
+      option_root: nil,
+      min_delta: 0.0,
+      max_delta: 0.15,
+      max_spread: 20.0,
+      min_credit: 0.0,
+      min_open_interest: 0,
+      dist_from_strike: 0.0,
+      quantity: 1,
+      max_strike: nil,
+      min_strike: nil
+    )
+      @expiration_date = expiration_date
+      @underlying_price = underlying_price
+      @expiration_type = expiration_type
+      @settlement_type = settlement_type
+      @option_root = option_root
+      @max_spread = max_spread
+      @min_credit = min_credit
+      @min_open_interest = min_open_interest
+      @dist_from_strike = dist_from_strike
+      @quantity = quantity
+      @max_delta = max_delta
+      @min_delta = min_delta
+      @max_strike = max_strike
+      @min_strike = min_strike
+    end
+
+    def select(options_map)
+      filtered_options = []
+      exp_date_str = expiration_date.strftime('%Y-%m-%d')
+
+      options_map.each do |date_key, strikes|
+        strikes.each do |strike_key, option_array|
+          option_array.each do |option|
+            next unless passes_delta_filter?(option)
+            next unless passes_strike_range_filter?(option)
+            filtered_options << option
+          end
+        end
+      end
+
+      log_debug("Found #{filtered_options.size} filtered options")
+      filtered_options
+    end
+
+    def find_spreads(options_map, option_type)
+      spreads = []
+      exp_date_str = expiration_date.strftime('%Y-%m-%d')
+
+      short_cnt = 0
+
+      options_map.each do |date_key, strikes|
+        next unless date_matches?(date_key, exp_date_str)
+        log_debug("Processing options for date: #{date_key}. Searching #{strikes.size} strikes...")
+
+        strikes.each do |strike_key, option_array|
+          option_array.each do |short_option|
+            next unless passes_short_option_filters?(short_option)
+
+            log_debug("Found short option: #{short_option[:symbol]} at strike #{short_option[:strikePrice]}")
+
+            short_cnt += 1
+
+            short_strike = short_option[:strikePrice]
+            short_mark = short_option[:mark]
+
+            long_options = find_long_option_candidates(strikes, short_option, option_type)
+
+            long_options.each do |long_option|
+              spread = build_spread(short_option, long_option)
+              spreads << spread if spread
+            end
+          end
+        end
+      end
+
+      log_debug("Found #{spreads.size} #{option_type} spreads for #{short_cnt} short options")
+
+      spreads
+    end
+
+    def passes_short_option_filters?(option)
+      return false unless passes_delta_filter?(option)
+      return false unless passes_open_interest_filter?(option)
+      return false unless passes_distance_filter?(option)
+      return false unless passes_optional_filters?(option)
+
+      true
+    end
+
+    private
+
+    def date_matches?(date_key, exp_date_str)
+      date_key.to_s.include?(exp_date_str)
+    end
+
+    def passes_delta_filter?(option)
+      delta = option[:delta]&.abs || 0.0
+      delta <= max_delta && delta >= min_delta
+    end
+
+    def passes_open_interest_filter?(option)
+      open_interest = option[:openInterest] || 0
+      open_interest >= min_open_interest
+    end
+
+    def passes_distance_filter?(option)
+      raise "Underlying price must be set for distance filter" unless underlying_price
+
+      strike = option[:strikePrice]
+      return false unless strike
+
+      distance = ((underlying_price - strike) / underlying_price).abs
+      distance >= dist_from_strike
+    end
+
+    def passes_optional_filters?(option)
+      return false if expiration_type && option[:expirationType] != expiration_type
+      return false if settlement_type && option[:settlementType] != settlement_type
+      return false if option_root && option[:optionRoot] != option_root
+
+      true
+    end
+
+    def passes_strike_range_filter?(option)
+      strike = option[:strikePrice]
+      return false unless strike
+
+      return false if @min_strike && strike < @min_strike
+      return false if @max_strike && strike > @max_strike
+
+      true
+    end
+
+    def find_long_option_candidates(strikes, short_option, option_type)
+      short_strike = short_option[:strikePrice]
+      candidates = []
+
+      strikes.each do |long_strike_key, long_option_array|
+        long_option_array.each do |long_option|
+          long_strike = long_option[:strikePrice]
+          long_mark = long_option[:mark]
+
+          next unless long_mark > 0
+          next unless valid_spread_structure?(short_strike, long_strike, option_type)
+          next unless passes_min_credit?(short_option, long_option)
+          next unless passes_optional_filters?(long_option)
+          next unless passes_open_interest_filter?(long_option)
+
+          candidates << long_option
+        end
+      end
+
+      candidates
+    end
+
+    def valid_spread_structure?(short_strike, long_strike, option_type)
+      case option_type
+      when 'call'
+        long_strike > short_strike && (long_strike - short_strike) <= max_spread
+
+      when 'put'
+        long_strike < short_strike && (short_strike - long_strike) <= max_spread
+      else
+        false
+      end
+    end
+
+    def passes_min_credit?(short_option, long_option)
+      return true if min_credit <= 0
+
+      short_mark = short_option[:mark]
+      long_mark = long_option[:mark]
+      credit = short_mark - long_mark
+
+      credit * 100 >= min_credit
+    end
+
+    def build_spread(short_option, long_option)
+      short_mark = short_option[:mark]
+      long_mark = long_option[:mark]
+      credit = short_mark - long_mark
+      short_strike = short_option[:strikePrice]
+      long_strike = long_option[:strikePrice]
+
+      {
+        short_option: short_option,
+        long_option: long_option,
+        credit: credit,
+        delta: short_option[:delta] || 0,
+        spread_width: (short_strike - long_strike).abs,
+        quantity: quantity
+      }
+    end
+  end
+end

data/lib/schwab_mcp/orders/iron_condor_order.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'schwab_rb'
+
+module SchwabMCP
+  module Orders
+    class IronCondorOrder
+      class << self
+        def build(
+          account_number:,
+          put_short_symbol:,
+          put_long_symbol:,
+          call_short_symbol:,
+          call_long_symbol:,
+          price:,
+          order_instruction: :open,
+          quantity: 1
+        )
+          schwab_order_builder.new.tap do |builder|
+            builder.set_account_number(account_number)
+            builder.set_order_strategy_type('SINGLE')
+            builder.set_session(SchwabRb::Orders::Session::NORMAL)
+            builder.set_duration(SchwabRb::Orders::Duration::DAY)
+            builder.set_order_type(order_type(order_instruction))
+            builder.set_complex_order_strategy_type(SchwabRb::Order::ComplexOrderStrategyTypes::IRON_CONDOR)
+            builder.set_quantity(quantity)
+            builder.set_price(price)
+
+            instructions = leg_instructions_for_position(order_instruction)
+
+            builder.add_option_leg(
+              instructions[:put_short],
+              put_short_symbol,
+              quantity
+            )
+            builder.add_option_leg(
+              instructions[:put_long],
+              put_long_symbol,
+              quantity
+            )
+            builder.add_option_leg(
+              instructions[:call_short],
+              call_short_symbol,
+              quantity
+            )
+            builder.add_option_leg(
+              instructions[:call_long],
+              call_long_symbol,
+              quantity
+            )
+          end
+        end
+
+        def order_type(order_instruction)
+          if order_instruction == :open
+            SchwabRb::Order::Types::NET_CREDIT
+          else
+            SchwabRb::Order::Types::NET_DEBIT
+          end
+        end
+
+        def leg_instructions_for_position(order_instruction)
+          case order_instruction
+          when :open
+            {
+              put_short: SchwabRb::Orders::OptionInstructions::SELL_TO_OPEN,
+              put_long: SchwabRb::Orders::OptionInstructions::BUY_TO_OPEN,
+              call_short: SchwabRb::Orders::OptionInstructions::SELL_TO_OPEN,
+              call_long: SchwabRb::Orders::OptionInstructions::BUY_TO_OPEN
+            }
+          when :exit
+            {
+              put_short: SchwabRb::Orders::OptionInstructions::BUY_TO_CLOSE,
+              put_long: SchwabRb::Orders::OptionInstructions::SELL_TO_CLOSE,
+              call_short: SchwabRb::Orders::OptionInstructions::BUY_TO_CLOSE,
+              call_long: SchwabRb::Orders::OptionInstructions::SELL_TO_CLOSE
+            }
+          end
+        end
+
+        def schwab_order_builder
+          SchwabRb::Orders::Builder
+        end
+      end
+    end
+  end
+end

data/lib/schwab_mcp/orders/order_factory.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'schwab_rb'
+require_relative 'iron_condor_order'
+require_relative 'vertical_order'
+
+module SchwabMCP
+  module Orders
+    class OrderFactory
+      class << self
+        def build(**options)
+          case options[:strategy_type] || 'none'
+          when 'ironcondor'
+            IronCondorOrder.build(
+              put_short_symbol: options[:put_short_symbol],
+              put_long_symbol: options[:put_long_symbol],
+              call_short_symbol: options[:call_short_symbol],
+              call_long_symbol: options[:call_long_symbol],
+              price: options[:price],
+              account_number: options[:account_number],
+              order_instruction: options[:order_instruction] || :open,
+              quantity: options[:quantity] || 1
+            )
+          when 'callspread', 'putspread'
+            VerticalOrder.build(
+              short_leg_symbol: options[:short_leg_symbol],
+              long_leg_symbol: options[:long_leg_symbol],
+              price: options[:price],
+              account_number: options[:account_number],
+              order_instruction: options[:order_instruction] || :open,
+              quantity: options[:quantity] || 1
+            )
+          else
+            raise "Unsupported trade strategy: #{options[:strategy_type] || 'none'}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/schwab_mcp/orders/vertical_order.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'schwab_rb'
+
+module SchwabMCP
+  module Orders
+    class VerticalOrder
+      class << self
+        def build(short_leg_symbol:, long_leg_symbol:, price:, account_number:, order_instruction: :open, quantity: 1)
+          schwab_order_builder.new.tap do |builder|
+            builder.set_account_number(account_number)
+            builder.set_order_strategy_type('SINGLE')
+            builder.set_session(SchwabRb::Orders::Session::NORMAL)
+            builder.set_duration(SchwabRb::Orders::Duration::DAY)
+            builder.set_order_type(order_type(order_instruction))
+            builder.set_complex_order_strategy_type(SchwabRb::Order::ComplexOrderStrategyTypes::VERTICAL)
+            builder.set_quantity(quantity)
+            builder.set_price(price)
+            builder.add_option_leg(
+              short_leg_instruction(order_instruction),
+              short_leg_symbol,
+              quantity
+            )
+            builder.add_option_leg(
+              long_leg_instruction(order_instruction),
+              long_leg_symbol,
+              quantity
+            )
+          end
+        end
+
+        def order_type(order_instruction)
+          if order_instruction == :open
+            SchwabRb::Order::Types::NET_CREDIT
+          else
+            SchwabRb::Order::Types::NET_DEBIT
+          end
+        end
+
+        def short_leg_instruction(order_instruction)
+          if order_instruction == :open
+            SchwabRb::Orders::OptionInstructions::SELL_TO_OPEN
+          else
+            SchwabRb::Orders::OptionInstructions::BUY_TO_CLOSE
+          end
+        end
+
+        def long_leg_instruction(order_instruction)
+          if order_instruction == :open
+            SchwabRb::Orders::OptionInstructions::BUY_TO_OPEN
+          else
+            SchwabRb::Orders::OptionInstructions::SELL_TO_CLOSE
+          end
+        end
+
+        def schwab_order_builder
+          SchwabRb::Orders::Builder
+        end
+      end
+    end
+  end
+end

data/lib/schwab_mcp/redactor.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require "json"
+
+module SchwabMCP
+  class Redactor
+    ACCOUNT_NUMBER_PATTERN = /\b\d{8,9}\b/
+    HASH_VALUE_PATTERN = /\b[A-Za-z0-9]{20,}\b/
+    BEARER_TOKEN_PATTERN = /Bearer\s+[A-Za-z0-9\.\-_]+/i
+    ACCOUNT_FIELDS = %w[
+      accountNumber
+      accountId
+      account_number
+      account_id
+      hashValue
+      hash_value
+    ].freeze
+    NON_SENSITIVE_FIELDS = %w[
+      cusip
+      orderId
+      order_id
+      legId
+      leg_id
+      strikePrice
+      strike_price
+      quantity
+      daysToExpiration
+      days_to_expiration
+      expirationDate
+      expiration_date
+      price
+      netChange
+      net_change
+      mismarkedQuantity
+      mismarked_quantity
+    ].freeze
+    REDACTED_PLACEHOLDER = '[REDACTED]'
+    REDACTED_ACCOUNT_PLACEHOLDER = '[REDACTED_ACCOUNT]'
+    REDACTED_HASH_PLACEHOLDER = '[REDACTED_HASH]'
+    REDACTED_TOKEN_PLACEHOLDER = '[REDACTED_TOKEN]'
+
+    class << self
+      # Main entry point for redacting any data structure
+      # @param data [Object] Data to redact (Hash, Array, String, or other)
+      # @return [Object] Redacted copy of the data
+      def redact(data)
+        case data
+        when Hash
+          redact_hash(data)
+        when Array
+          redact_array(data)
+        when String
+          redact_string(data)
+        else
+          data
+        end
+      end
+
+      # Redact a JSON response from Schwab API
+      # @param response_body [String] Raw response body from API
+      # @return [String] Pretty-formatted redacted JSON
+      def redact_api_response(response_body)
+        return response_body unless response_body.is_a?(String)
+
+        begin
+          parsed = JSON.parse(response_body)
+          redacted = redact(parsed)
+          JSON.pretty_generate(redacted)
+        rescue JSON::ParserError
+          # If parsing fails, redact as string
+          redact_string(response_body)
+        end
+      end
+
+      # Redact formatted text that might contain sensitive data
+      # @param text [String] Formatted text to redact
+      # @return [String] Redacted text
+      def redact_formatted_text(text)
+        return text unless text.is_a?(String)
+        redacted = text.dup
+        redacted.gsub!(BEARER_TOKEN_PATTERN, "Bearer #{REDACTED_TOKEN_PLACEHOLDER}")
+
+        # Redact account numbers in specific text patterns
+        redacted.gsub!(/Account\s+ID:\s*\d{8,9}/i, "Account ID: #{REDACTED_ACCOUNT_PLACEHOLDER}")
+        redacted.gsub!(/Account\s+Number:\s*\d{8,9}/i, "Account Number: #{REDACTED_ACCOUNT_PLACEHOLDER}")
+        redacted.gsub!(/Account:\s*\d{8,9}/i, "Account: #{REDACTED_ACCOUNT_PLACEHOLDER}")
+
+        # Redact account numbers in log patterns like "account_number: 123456789"
+        redacted.gsub!(/account[_\s]*number[_\s]*[:\=]\s*\d{8,9}/i, "account_number: #{REDACTED_ACCOUNT_PLACEHOLDER}")
+        redacted.gsub!(/account[_\s]*id[_\s]*[:\=]\s*\d{8,9}/i, "account_id: #{REDACTED_ACCOUNT_PLACEHOLDER}")
+
+        redacted
+      end
+
+      # Redact a log message that might contain sensitive data
+      # @param message [String] Log message to redact
+      # @return [String] Redacted log message
+      def redact_log_message(message)
+        return message unless message.is_a?(String)
+
+        redact_formatted_text(message)
+      end
+
+      # Redact an MCP tool response before sending to client
+      # @param response [Hash] MCP tool response
+      # @return [Hash] Redacted response
+      def redact_mcp_response(response)
+        return response unless response.is_a?(Hash)
+
+        redacted = redact(response)
+
+        # Also redact any content in the response content field
+        if redacted.dig("content")
+          case redacted["content"]
+          when String
+            redacted["content"] = redact_formatted_text(redacted["content"])
+          when Array
+            redacted["content"] = redacted["content"].map do |item|
+              if item.is_a?(Hash) && item["text"]
+                item["text"] = redact_formatted_text(item["text"])
+              end
+              item
+            end
+          end
+        end
+
+        redacted
+      end
+
+      private
+
+      # Redact a hash/object recursively
+      # @param hash [Hash] Hash to redact
+      # @return [Hash] Redacted copy of hash
+      def redact_hash(hash)
+        return hash unless hash.is_a?(Hash)
+
+        redacted = {}
+
+        hash.each do |key, value|
+          key_str = key.to_s.downcase
+
+          # Check if this is a known non-sensitive field
+          if NON_SENSITIVE_FIELDS.any? { |field| key_str.include?(field.downcase) }
+            redacted[key] = value
+          # Check if this is a known account-related field
+          elsif ACCOUNT_FIELDS.any? { |field| key_str.include?(field.downcase) }
+            redacted[key] = redact_account_field(value)
+          else
+            redacted[key] = redact(value)
+          end
+        end
+
+        redacted
+      end
+
+      # Redact an array recursively
+      # @param array [Array] Array to redact
+      # @return [Array] Redacted copy of array
+      def redact_array(array)
+        return array unless array.is_a?(Array)
+
+        array.map { |item| redact(item) }
+      end
+
+      # Redact a string value
+      # @param string [String] String to redact
+      # @return [String] Redacted string
+      def redact_string(string)
+        return string unless string.is_a?(String)
+
+        redacted = string.dup
+
+        # Redact bearer tokens
+        redacted.gsub!(BEARER_TOKEN_PATTERN, "Bearer #{REDACTED_TOKEN_PLACEHOLDER}")
+
+        # Redact JSON-embedded account data (specific patterns)
+        redacted.gsub!(/"hashValue":\s*"[^"]+"/i, "\"hashValue\": \"#{REDACTED_HASH_PLACEHOLDER}\"")
+        redacted.gsub!(/"accountNumber":\s*"?\d{8,9}"?/i, "\"accountNumber\": \"#{REDACTED_ACCOUNT_PLACEHOLDER}\"")
+        redacted.gsub!(/"account_id":\s*"?\d{8,9}"?/i, "\"account_id\": \"#{REDACTED_ACCOUNT_PLACEHOLDER}\"")
+
+        redacted
+      end
+
+      # Redact a field that is known to contain account information
+      # @param value [Object] Value to redact
+      # @return [Object] Redacted value
+      def redact_account_field(value)
+        case value
+        when String
+          if value.match?(ACCOUNT_NUMBER_PATTERN) && value.length.between?(8, 9)
+            REDACTED_ACCOUNT_PLACEHOLDER
+          elsif value.length > 20 && value.match?(/\A[A-Za-z0-9]+\z/)
+            REDACTED_HASH_PLACEHOLDER
+          else
+            value
+          end
+        when Integer
+          if value.to_s.length.between?(8, 9)
+            REDACTED_ACCOUNT_PLACEHOLDER
+          else
+            value
+          end
+        else
+          redact(value)
+        end
+      end
+    end
+  end
+end