schwab_mcp 0.1.0 → 0.3.0

data/lib/schwab_mcp/tools/schwab_account_details_tool.rb

@@ -3,6 +3,7 @@ require "schwab_rb"
 require "json"
 require_relative "../loggable"
 require_relative "../redactor"
+require_relative "../schwab_client_factory"
 
 module SchwabMCP
   module Tools
@@ -19,7 +20,7 @@ module SchwabMCP
           },
           fields: {
             type: "array",
-            description: "Optional account fields to retrieve (balances, positions, orders)",
+            description: "Optional account fields to retrieve (positions)",
             items: {
               type: "string"
             }
@@ -47,74 +48,27 @@ module SchwabMCP
         end
 
         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
-
-          account_id = ENV[account_name]
-          unless account_id
-            available_accounts = ENV.keys.select { |key| key.end_with?('_ACCOUNT') }
-            log_error("Account name '#{account_name}' not found in environment variables")
-            return MCP::Tool::Response.new([{
-              type: "text",
-              text: "**Error**: Account name '#{account_name}' not found in environment variables.\n\nAvailable accounts: #{available_accounts.join(', ')}\n\nTo configure: Set ENV['#{account_name}'] to your account ID."
-            }])
-          end
-
-          log_debug("Found account ID: [REDACTED] for account name: #{account_name}")
-          log_debug("Fetching account numbers mapping")
-
-          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, symbolize_names: true)
-          log_debug("Account mappings retrieved (#{account_mappings.length} accounts found)")
-
-          account_hash = nil
-          account_mappings.each do |mapping|
-            if mapping[:accountNumber] == account_id
-              account_hash = mapping[:hashValue]
-              break
-            end
-          end
+          client = SchwabClientFactory.create_client
+          return SchwabClientFactory.client_error_response unless client
 
-          unless account_hash
-            log_error("Account ID not found in available accounts")
-            available_accounts = account_mappings.map { |m| "[REDACTED]" }.join(", ")
+          available_accounts = client.available_account_names
+          unless available_accounts.include?(account_name)
+            log_error("Account name '#{account_name}' not found in configured accounts")
             return MCP::Tool::Response.new([{
               type: "text",
-              text: "**Error**: Account ID not found in available accounts. #{account_mappings.length} accounts available."
+              text: "**Error**: Account name '#{account_name}' not found in configured accounts.\n\nAvailable accounts: #{available_accounts.join(', ')}\n\nTo configure: Add the account to your schwab_rb configuration file."
             }])
           end
 
-          log_debug("Found account hash for account ID: #{account_name}")
-
+          log_debug("Using account name: #{account_name}")
           log_debug("Fetching account information with fields: #{fields}")
-          account_response = client.get_account(account_hash, fields: fields)
 
-          if account_response&.body
+          account = client.get_account(account_name: account_name, fields: fields)
+
+          if account
             log_info("Successfully retrieved account information for #{account_name}")
-            account_data = JSON.parse(account_response.body)
 
-            formatted_response = format_account_data(account_data, account_name, account_id)
+            formatted_response = format_account_data(account, account_name)
 
             MCP::Tool::Response.new([{
               type: "text",
@@ -146,54 +100,58 @@ module SchwabMCP
 
       private
 
-      def self.format_account_data(account_data, account_name, account_id)
-        account = account_data["securitiesAccount"]
+      def self.format_account_data(account, account_name)
         friendly_name = account_name.gsub('_ACCOUNT', '').split('_').map(&:capitalize).join(' ')
 
         formatted = "**Account Information for #{friendly_name} (#{account_name}):**\n\n"
 
-        if account
-          formatted += "**Account Number:** #{Redactor::REDACTED_ACCOUNT_PLACEHOLDER}\n"
-          formatted += "**Account Type:** #{account['type']}\n"
-
-          if current_balances = account['currentBalances']
-            formatted += "\n**Current Balances:**\n"
-            formatted += "- Cash Balance: $#{format_currency(current_balances['cashBalance'])}\n"
-            formatted += "- Buying Power: $#{format_currency(current_balances['buyingPower'])}\n"
-            formatted += "- Total Cash: $#{format_currency(current_balances['totalCash'])}\n"
-            formatted += "- Liquidation Value: $#{format_currency(current_balances['liquidationValue'])}\n"
-            formatted += "- Long Market Value: $#{format_currency(current_balances['longMarketValue'])}\n"
-            formatted += "- Short Market Value: $#{format_currency(current_balances['shortMarketValue'])}\n"
-          end
+        formatted += "**Account Number:** #{Redactor::REDACTED_ACCOUNT_PLACEHOLDER}\n"
+        formatted += "**Account Type:** #{account.type}\n"
 
-          # Positions summary
-          if positions = account['positions']
-            formatted += "\n**Positions Summary:**\n"
-            formatted += "- Total Positions: #{positions.length}\n"
-
-            if positions.length > 0
-              formatted += "\n**Position Details:**\n"
-              positions.each do |position|
-                symbol = position.dig('instrument', 'symbol')
-                qty = position['longQuantity'].to_f - position['shortQuantity'].to_f
-                market_value = position['marketValue']
-                formatted += "- #{symbol}: #{qty} shares, Market Value: $#{format_currency(market_value)}\n"
-              end
+        if current_balances = account.current_balances
+          formatted += "\n**Current Balances:**\n"
+          formatted += "- Cash Balance: $#{format_currency(current_balances.cash_balance)}\n"
+          formatted += "- Buying Power: $#{format_currency(current_balances.buying_power)}\n"
+          formatted += "- Liquidation Value: $#{format_currency(current_balances.liquidation_value)}\n"
+          formatted += "- Long Market Value: $#{format_currency(current_balances.long_market_value)}\n"
+          formatted += "- Short Market Value: $#{format_currency(current_balances.short_market_value)}\n"
+        end
+
+        # Positions summary
+        if positions = account.positions
+          formatted += "\n**Positions Summary:**\n"
+          formatted += "- Total Positions: #{positions.length}\n"
+
+          if positions.length > 0
+            formatted += "\n**Position Details:**\n"
+            positions.each do |position|
+              symbol = position.instrument.symbol
+              qty = position.long_quantity - position.short_quantity
+              market_value = position.market_value
+              formatted += "- #{symbol}: #{qty} shares, Market Value: $#{format_currency(market_value)}\n"
             end
           end
+        end
 
-          if orders = account['orderStrategies']
-            formatted += "\n**Active Orders:**\n"
-            formatted += "- Total Orders: #{orders.length}\n"
-
-            orders.each do |order|
-              status = order['status']
-              symbol = order.dig('orderLegCollection', 0, 'instrument', 'symbol')
-              formatted += "- #{symbol}: #{status}\n"
-            end
-          end        end
+        # Note: Orders would need to be fetched separately as they're not part of the Account data object
+
+        # Convert account back to hash for JSON display (redacted)
+        account_hash = {
+          securitiesAccount: {
+            type: account.type,
+            accountNumber: account.account_number,
+            positions: account.positions.map(&:to_h),
+            currentBalances: {
+              cashBalance: account.current_balances&.cash_balance,
+              buyingPower: account.current_balances&.buying_power,
+              liquidationValue: account.current_balances&.liquidation_value,
+              longMarketValue: account.current_balances&.long_market_value,
+              shortMarketValue: account.current_balances&.short_market_value
+            }
+          }
+        }
 
-        redacted_data = Redactor.redact(account_data)
+        redacted_data = Redactor.redact(account_hash)
         formatted += "\n```json\n#{JSON.pretty_generate(redacted_data)}\n```"
         formatted
       end

data/lib/schwab_mcp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SchwabMCP
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/schwab_mcp.rb

@@ -9,10 +9,8 @@ require_relative "schwab_mcp/redactor"
 require_relative "schwab_mcp/tools/quote_tool"
 require_relative "schwab_mcp/tools/quotes_tool"
 require_relative "schwab_mcp/tools/option_chain_tool"
-require_relative "schwab_mcp/tools/option_strategy_finder_tool"
 require_relative "schwab_mcp/tools/help_tool"
 require_relative "schwab_mcp/tools/schwab_account_details_tool"
-require_relative "schwab_mcp/tools/list_schwab_accounts_tool"
 require_relative "schwab_mcp/tools/list_account_orders_tool"
 require_relative "schwab_mcp/tools/list_account_transactions_tool"
 require_relative "schwab_mcp/tools/get_order_tool"
@@ -23,7 +21,9 @@ require_relative "schwab_mcp/tools/replace_order_tool"
 require_relative "schwab_mcp/tools/list_movers_tool"
 require_relative "schwab_mcp/tools/get_market_hours_tool"
 require_relative "schwab_mcp/tools/get_price_history_tool"
+require_relative "schwab_mcp/tools/get_account_names_tool"
 require_relative "schwab_mcp/loggable"
+require_relative "schwab_mcp/schwab_client_factory"
 
 
 module SchwabMCP
@@ -33,10 +33,8 @@ module SchwabMCP
     Tools::QuoteTool,
     Tools::QuotesTool,
     Tools::OptionChainTool,
-    Tools::OptionStrategyFinderTool,
     Tools::HelpTool,
     Tools::SchwabAccountDetailsTool,
-    Tools::ListSchwabAccountsTool,
     Tools::ListAccountOrdersTool,
     Tools::ListAccountTransactionsTool,
     Tools::GetOrderTool,
@@ -46,35 +44,38 @@ module SchwabMCP
     Tools::ReplaceOrderTool,
     Tools::ListMoversTool,
     Tools::GetMarketHoursTool,
-    Tools::GetPriceHistoryTool
+    Tools::GetPriceHistoryTool,
+    Tools::GetAccountNamesTool
   ].freeze
 
   class Server
     include Loggable
 
     def initialize
-      configure_schwab_rb_logging
+      configure_schwab_rb
 
       @server = MCP::Server.new(
         name: "schwab_mcp_server",
         version: SchwabMCP::VERSION,
         tools: TOOLS,
+        server_context: { user: "foobar" }
       )
     end
 
     def start
       configure_mcp
-      log_info("🚀 Starting Schwab MCP Server #{SchwabMCP::VERSION}")
-      log_info("📊 Available tools: #{TOOLS.map { |tool| tool.name.split('::').last }.join(', ')}")
-      log_info("📝 Logs will be written to: #{log_file_path}")
+      log_info("Starting Schwab MCP Server #{SchwabMCP::VERSION}")
+      log_info("Available tools: #{TOOLS.map { |tool| tool.name.split('::').last }.join(', ')}")
+      log_info("Logs will be written to: #{log_file_path}")
       transport = MCP::Transports::StdioTransport.new(@server)
       transport.open
     end
 
     private
 
-    def configure_schwab_rb_logging
+    def configure_schwab_rb
       SchwabRb.configure do |config|
+        config.schwab_home = ENV['SCHWAB_HOME']
         config.logger = SchwabMCP::Logger.instance
         config.log_level = ENV.fetch('LOG_LEVEL', 'INFO').upcase
       end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: schwab_mcp
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Joseph Platta
 bindir: exe
 cert_chain: []
-date: 2025-07-17 00:00:00.000000000 Z
+date: 2025-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mcp
@@ -48,27 +48,30 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".claude/settings.json"
 - ".copilotignore"
 - ".rspec"
 - ".rubocop.yml"
 - CHANGELOG.md
+- CLAUDE.md
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
 - README.md
 - Rakefile
+- debug_env.rb
+- doc/DATA_OBJECTS_MIGRATION_TODO.md
+- doc/SCHWAB_CLIENT_FACTORY_REFACTOR_PLAN.md
 - exe/schwab_mcp
 - exe/schwab_token_refresh
 - exe/schwab_token_reset
 - lib/schwab_mcp.rb
 - lib/schwab_mcp/loggable.rb
 - lib/schwab_mcp/logger.rb
-- lib/schwab_mcp/option_chain_filter.rb
-- lib/schwab_mcp/orders/iron_condor_order.rb
-- lib/schwab_mcp/orders/order_factory.rb
-- lib/schwab_mcp/orders/vertical_order.rb
 - lib/schwab_mcp/redactor.rb
 - lib/schwab_mcp/resources/.keep
+- lib/schwab_mcp/schwab_client_factory.rb
 - lib/schwab_mcp/tools/cancel_order_tool.rb
+- lib/schwab_mcp/tools/get_account_names_tool.rb
 - lib/schwab_mcp/tools/get_market_hours_tool.rb
 - lib/schwab_mcp/tools/get_order_tool.rb
 - lib/schwab_mcp/tools/get_price_history_tool.rb
@@ -76,9 +79,7 @@ files:
 - lib/schwab_mcp/tools/list_account_orders_tool.rb
 - lib/schwab_mcp/tools/list_account_transactions_tool.rb
 - lib/schwab_mcp/tools/list_movers_tool.rb
-- lib/schwab_mcp/tools/list_schwab_accounts_tool.rb
 - lib/schwab_mcp/tools/option_chain_tool.rb
-- lib/schwab_mcp/tools/option_strategy_finder_tool.rb
 - lib/schwab_mcp/tools/place_order_tool.rb
 - lib/schwab_mcp/tools/preview_order_tool.rb
 - lib/schwab_mcp/tools/quote_tool.rb
@@ -87,7 +88,6 @@ files:
 - lib/schwab_mcp/tools/schwab_account_details_tool.rb
 - lib/schwab_mcp/version.rb
 - sig/schwab_mcp.rbs
-- start_mcp_server.sh
 homepage: https://github.com/jwplatta/schwab_mcp
 licenses:
 - MIT
@@ -95,6 +95,9 @@ metadata:
   homepage_uri: https://github.com/jwplatta/schwab_mcp
   source_code_uri: https://github.com/jwplatta/schwab_mcp
   changelog_uri: https://github.com/jwplatta/schwab_mcp/blob/main/CHANGELOG.md
+  rubygems_uri: https://rubygems.org/gems/schwab_mcp
+  documentation_uri: https://rubydoc.info/gems/schwab_mcp
+  bug_tracker_uri: https://github.com/jwplatta/schwab_mcp/issues
 rdoc_options: []
 require_paths:
 - lib

data/lib/schwab_mcp/option_chain_filter.rb

@@ -1,213 +0,0 @@
-# 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

@@ -1,87 +0,0 @@
-# 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