schwab_mcp 0.1.0 → 0.3.0

data/lib/schwab_mcp/orders/order_factory.rb

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

@@ -1,62 +0,0 @@
-# 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/tools/list_schwab_accounts_tool.rb

@@ -1,162 +0,0 @@
-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_strategy_finder_tool.rb

@@ -1,378 +0,0 @@
-require "mcp"
-require "schwab_rb"
-require "json"
-require "date"
-require_relative "../loggable"
-require_relative "../option_chain_filter"
-
-module SchwabMCP
-  module Tools
-    class OptionStrategyFinderTool < MCP::Tool
-      extend Loggable
-      description "Find option strategies (iron condor, call spread, put spread) using Schwab API"
-
-      input_schema(
-        properties: {
-          strategy_type: {
-            type: "string",
-            description: "Type of option strategy to find",
-            enum: ["ironcondor", "callspread", "putspread"]
-          },
-          underlying_symbol: {
-            type: "string",
-            description: "Underlying symbol for the options (e.g., '$SPX', 'SPY')",
-            pattern: "^[A-Za-z$]{1,6}$"
-          },
-          expiration_date: {
-            type: "string",
-            description: "Target expiration date for options (YYYY-MM-DD format)"
-          },
-          expiration_type: {
-            type: "string",
-            description: "Type of expiration (e.g., 'W' for weekly, 'M' for monthly)",
-            enum: ["W", "M", "Q"]
-          },
-          settlement_type: {
-            type: "string",
-            description: "Settlement type (e.g., 'P' for PM settled, 'A' for AM settled)",
-            enum: ["P", "A"]
-          },
-          option_root: {
-            type: "string",
-            description: "Option root symbol (e.g., 'SPXW' for weekly SPX options)"
-          },
-          max_delta: {
-            type: "number",
-            description: "Maximum absolute delta for short legs (default: 0.15)",
-            minimum: 0.01,
-            maximum: 1.0
-          },
-          max_spread: {
-            type: "number",
-            description: "Maximum spread width in dollars (default: 20.0)",
-            minimum: 1.0
-          },
-          min_credit: {
-            type: "number",
-            description: "Minimum credit received in dollars (default: 100.0)",
-            minimum: 0.01
-          },
-          min_open_interest: {
-            type: "integer",
-            description: "Minimum open interest for options (default: 0)",
-            minimum: 0
-          },
-          dist_from_strike: {
-            type: "number",
-            description: "Minimum distance from current price as percentage (default: 0.07)",
-            minimum: 0.0,
-            maximum: 1.0
-          },
-          quantity: {
-            type: "integer",
-            description: "Number of contracts per leg (default: 1)",
-            minimum: 1
-          },
-          from_date: {
-            type: "string",
-            description: "Start date for expiration search (YYYY-MM-DD format)"
-          },
-          to_date: {
-            type: "string",
-            description: "End date for expiration search (YYYY-MM-DD format)"
-          }
-        },
-        required: ["strategy_type", "underlying_symbol", "expiration_date"]
-      )
-
-      annotations(
-        title: "Find Option Strategy",
-        read_only_hint: true,
-        destructive_hint: false,
-        idempotent_hint: true
-      )
-
-      def self.call(strategy_type:, underlying_symbol:, expiration_date:,
-                    expiration_type: nil, settlement_type: nil, option_root: nil,
-                    max_delta: 0.15, max_spread: 20.0, min_credit: 0.0,
-                    min_open_interest: 0, dist_from_strike: 0.0, quantity: 1,
-                    from_date: nil, to_date: nil, server_context:)
-
-        log_info("Finding #{strategy_type} strategy for #{underlying_symbol} expiring #{expiration_date}")
-
-        begin
-          unless %w[ironcondor callspread putspread].include?(strategy_type.downcase)
-            return MCP::Tool::Response.new([{
-              type: "text",
-              text: "**Error**: Invalid strategy type '#{strategy_type}'. Must be one of: ironcondor, callspread, putspread"
-            }])
-          end
-
-          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
-
-          exp_date = Date.parse(expiration_date)
-          from_dt = from_date ? Date.parse(from_date) : exp_date
-          to_dt = to_date ? Date.parse(to_date) : exp_date
-
-          contract_type = strategy_type.downcase == 'callspread' ? 'CALL' :
-                         strategy_type.downcase == 'putspread' ? 'PUT' : 'ALL'
-
-          log_debug("Fetching option chain for #{underlying_symbol} (#{contract_type})")
-
-          response = client.get_option_chain(
-            underlying_symbol.upcase,
-            contract_type: contract_type,
-            from_date: from_dt,
-            to_date: to_dt,
-            include_underlying_quote: true
-          )
-
-          unless response&.body
-            log_warn("Empty response from Schwab API for #{underlying_symbol}")
-            return MCP::Tool::Response.new([{
-              type: "text",
-              text: "**No Data**: Could not retrieve option chain for #{underlying_symbol}"
-            }])
-          end
-
-          option_data = JSON.parse(response.body, symbolize_names: true)
-
-          result = find_strategy(
-            strategy_type: strategy_type.downcase,
-            option_data: option_data,
-            underlying_symbol: underlying_symbol,
-            expiration_date: exp_date,
-            expiration_type: expiration_type,
-            settlement_type: settlement_type,
-            option_root: option_root,
-            max_delta: max_delta,
-            max_spread: max_spread,
-            min_credit: min_credit,
-            min_open_interest: min_open_interest,
-            dist_from_strike: dist_from_strike,
-            quantity: quantity
-          )
-
-          if result.nil? || result[:status] == 'not_found'
-            log_info("No suitable #{strategy_type} found for #{underlying_symbol}")
-            return MCP::Tool::Response.new([{
-              type: "text",
-              text: "**No Strategy Found**: Could not find a suitable #{strategy_type} for #{underlying_symbol} with the specified criteria."
-            }])
-          else
-            log_info("Found #{strategy_type} strategy for #{underlying_symbol}")
-            return MCP::Tool::Response.new([{
-              type: "text",
-              text: format_strategy_result(result, strategy_type)
-            }])
-          end
-        rescue Date::Error => e
-          log_error("Invalid date format: #{e.message}")
-          return MCP::Tool::Response.new([{
-            type: "text",
-            text: "**Error**: Invalid date format. Use YYYY-MM-DD format."
-          }])
-        rescue JSON::ParserError => e
-          log_error("Failed to parse option chain data: #{e.message}")
-          return MCP::Tool::Response.new([{
-            type: "text",
-            text: "**Error**: Failed to parse option chain data from Schwab API."
-          }])
-        rescue => e
-          log_error("Error finding #{strategy_type} for #{underlying_symbol}: #{e.message}")
-          log_debug("Backtrace: #{e.backtrace.first(3).join('\n')}")
-          return MCP::Tool::Response.new([{
-            type: "text",
-            text: "**Error** finding #{strategy_type} for #{underlying_symbol}: #{e.message}"
-          }])
-        end
-      end
-
-      private
-
-      def self.find_strategy(strategy_type:, option_data:, underlying_symbol:, expiration_date:,
-                            expiration_type:, settlement_type:, option_root:, max_delta:,
-                            max_spread:, min_credit:, min_open_interest:, dist_from_strike:, quantity:)
-
-        case strategy_type
-        when 'ironcondor'
-          find_iron_condor(option_data, underlying_symbol, expiration_date, expiration_type,
-                          settlement_type, option_root, max_delta, max_spread, min_credit / 2.0,
-                          min_open_interest, dist_from_strike, quantity)
-        when 'callspread'
-          find_spread(option_data, 'call', underlying_symbol, expiration_date, expiration_type,
-                     settlement_type, option_root, max_delta, max_spread, min_credit,
-                     min_open_interest, dist_from_strike, quantity)
-        when 'putspread'
-          find_spread(option_data, 'put', underlying_symbol, expiration_date, expiration_type,
-                     settlement_type, option_root, max_delta, max_spread, min_credit,
-                     min_open_interest, dist_from_strike, quantity)
-        end
-      end
-
-      def self.find_iron_condor(option_data, underlying_symbol, expiration_date, expiration_type,
-                               settlement_type, option_root, max_delta, max_spread, min_credit,
-                               min_open_interest, dist_from_strike, quantity)
-
-        underlying_price = option_data.dig(:underlyingPrice) || 0.0
-        call_options = option_data.dig(:callExpDateMap) || {}
-        put_options = option_data.dig(:putExpDateMap) || {}
-
-        filter = SchwabMCP::OptionChainFilter.new(
-          expiration_date: expiration_date,
-          underlying_price: underlying_price,
-          expiration_type: expiration_type,
-          settlement_type: settlement_type,
-          option_root: option_root,
-          max_delta: max_delta,
-          max_spread: max_spread,
-          min_credit: min_credit,
-          min_open_interest: min_open_interest,
-          dist_from_strike: dist_from_strike,
-          quantity: quantity
-        )
-
-        call_spreads = filter.find_spreads(call_options, 'call')
-        put_spreads = filter.find_spreads(put_options, 'put')
-
-        return { status: 'not_found' } if call_spreads.empty? || put_spreads.empty?
-
-        best_combo = nil
-        best_ratio = 0
-
-        call_spreads.each do |call_spread|
-          put_spreads.each do |put_spread|
-            total_credit = call_spread[:credit] + put_spread[:credit]
-            next if total_credit < min_credit / 100.0
-
-            total_delta = call_spread[:delta].abs + put_spread[:delta].abs
-            ratio = total_credit / total_delta if total_delta > 0
-
-            if ratio > best_ratio
-              best_ratio = ratio
-              best_combo = {
-                type: 'iron_condor',
-                call_spread: call_spread,
-                put_spread: put_spread,
-                total_credit: total_credit,
-                total_delta: total_delta,
-                underlying_price: underlying_price
-              }
-            end
-          end
-        end
-
-        best_combo || { status: 'not_found' }
-      end
-
-      def self.find_spread(option_data, spread_type, underlying_symbol, expiration_date, expiration_type,
-                          settlement_type, option_root, max_delta, max_spread, min_credit,
-                          min_open_interest, dist_from_strike, quantity)
-
-        underlying_price = option_data.dig(:underlyingPrice) || 0.0
-        options_map = case spread_type
-                     when 'call'
-                       option_data.dig(:callExpDateMap) || {}
-                     when 'put'
-                       option_data.dig(:putExpDateMap) || {}
-                     else
-                       return { status: 'not_found' }
-                     end
-
-        filter = SchwabMCP::OptionChainFilter.new(
-          expiration_date: expiration_date,
-          underlying_price: underlying_price,
-          expiration_type: expiration_type,
-          settlement_type: settlement_type,
-          option_root: option_root,
-          max_delta: max_delta,
-          max_spread: max_spread,
-          min_credit: min_credit,
-          min_open_interest: min_open_interest,
-          dist_from_strike: dist_from_strike,
-          quantity: quantity
-        )
-
-        spreads = filter.find_spreads(options_map, spread_type)
-
-        return { status: 'not_found' } if spreads.empty?
-
-        best_spread = spreads.max_by { |spread| spread[:credit] }
-        best_spread.merge(type: "#{spread_type}_spread", underlying_price: underlying_price)
-      end
-
-      def self.format_strategy_result(result, strategy_type)
-        case result[:type]
-        when 'iron_condor'
-          format_iron_condor(result)
-        when 'call_spread', 'put_spread'
-          format_spread(result, result[:type])
-        else
-          "**Found Strategy**: #{strategy_type.upcase}\n\n#{result.to_json}"
-        end
-      end
-
-      def self.format_iron_condor(result)
-        call_spread = result[:call_spread]
-        put_spread = result[:put_spread]
-
-        <<~TEXT
-          **IRON CONDOR FOUND**
-
-          **Underlying Price**: $#{result[:underlying_price].round(2)}
-          **Total Credit**: $#{(result[:total_credit] * 100).round(2)}
-
-          **Call Spread (Short)**:
-          - Short: #{call_spread[:short_option][:symbol]} $#{call_spread[:short_option][:strikePrice]} Call @ $#{call_spread[:short_option][:mark].round(2)}
-          - Long:  #{call_spread[:long_option][:symbol]} $#{call_spread[:long_option][:strikePrice]} Call @ $#{call_spread[:long_option][:mark].round(2)}
-          - Credit: $#{(call_spread[:credit] * 100).round(2)}
-          - Width: $#{call_spread[:spread_width].round(2)}
-          - Delta: #{call_spread[:delta].round(2)}
-
-          **Put Spread (Short)**:
-          - Short: #{put_spread[:short_option][:symbol]} $#{put_spread[:short_option][:strikePrice]} Put @ $#{put_spread[:short_option][:mark].round(2)}
-          - Long:  #{put_spread[:long_option][:symbol]} $#{put_spread[:long_option][:strikePrice]} Put @ $#{put_spread[:long_option][:mark].round(2)}
-          - Credit: $#{(put_spread[:credit] * 100).round(2)}
-          - Width: $#{put_spread[:spread_width].round(2)}
-          - Delta: #{put_spread[:delta].round(2)}
-        TEXT
-      end
-
-      def self.format_spread(result, spread_type)
-        short_opt = result[:short_option]
-        long_opt = result[:long_option]
-        option_type = spread_type == 'call_spread' ? 'Call' : 'Put'
-
-        <<~TEXT
-          **#{option_type.upcase} SPREAD FOUND**
-
-          **Underlying Price**: $#{result[:underlying_price].round(2)}
-          **Credit**: $#{(result[:credit] * 100).round(2)}
-          **Spread Width**: $#{result[:spread_width].round(2)}
-          **Delta**: #{result[:delta].round(4)}
-
-          **Short**: #{short_opt[:symbol]} $#{short_opt[:strikePrice]} #{option_type} @ $#{short_opt[:mark].round(2)}
-          - Delta: #{short_opt[:delta]&.round(4)}
-          - Open Interest: #{short_opt[:openInterest]}
-
-          **Long**: #{long_opt[:symbol]} $#{long_opt[:strikePrice]} #{option_type} @ $#{long_opt[:mark].round(2)}
-          - Delta: #{long_opt[:delta]&.round(4)}
-          - Open Interest: #{long_opt[:openInterest]}
-        TEXT
-      end
-    end
-  end
-end

data/start_mcp_server.sh

@@ -1,4 +0,0 @@
-#!/bin/bash
-
-cd /Users/jplatta/repos/schwab_mcp
-exec /Users/jplatta/.asdf/shims/bundle exec exe/schwab_mcp