tastytrade 0.2.0 → 0.3.0

data/lib/tastytrade/cli_helpers.rb

@@ -106,7 +106,9 @@ module Tastytrade
 
       @current_account = Tastytrade::Models::Account.get(current_session, account_number)
     rescue StandardError => e
-      warn "Failed to load current account: #{e.message}"
+      # Only warn if debug mode is enabled - otherwise silently return nil
+      # and let the caller handle the fallback
+      warn "Failed to load current account: #{e.message}" if ENV["DEBUG_SESSION"]
       nil
     end
 
@@ -115,6 +117,106 @@ module Tastytrade
       config.get("current_account_number")
     end
 
+    # Format buying power status based on usage percentage
+    def format_bp_status(usage_percentage)
+      return pastel.dim("N/A") unless usage_percentage
+
+      case usage_percentage.to_f
+      when 0..50
+        pastel.green("Low")
+      when 50..80
+        pastel.yellow("Moderate")
+      when 80..90
+        pastel.bright_yellow("High")
+      else
+        pastel.red("Critical")
+      end
+    end
+
+    # Display trading status information
+    def display_trading_status(status)
+      puts "\n#{pastel.bold("Trading Status for Account:")} #{status.account_number}"
+      puts pastel.dim("─" * 60)
+
+      # Display restrictions first if any
+      restrictions = status.active_restrictions
+      if restrictions.any?
+        puts "\n#{pastel.bold.red("⚠ Account Restrictions:")}"
+        restrictions.each do |restriction|
+          case restriction
+          when "Margin Call", "Day Trade Equity Maintenance Call"
+            puts "  #{pastel.red("• #{restriction}")}"
+          when "Pattern Day Trader"
+            puts "  #{pastel.yellow("• #{restriction}")}"
+          when "Account Closed", "Account Frozen"
+            puts "  #{pastel.bright_red("• #{restriction}")}"
+          else
+            puts "  #{pastel.yellow("• #{restriction}")}"
+          end
+        end
+      else
+        puts "\n#{pastel.green("✓ No account restrictions")}"
+      end
+
+      # Display trading permissions
+      puts "\n#{pastel.bold("Trading Permissions:")}"
+      permissions = status.permissions_summary
+
+      # Options trading
+      options_status = permissions[:options]
+      options_color = options_status == "Disabled" ? :dim : :green
+      puts "  Options Trading:      #{pastel.send(options_color, options_status)}"
+
+      # Short calls
+      short_calls_status = permissions[:short_calls]
+      short_calls_color = short_calls_status == "Enabled" ? :green : :dim
+      puts "  Short Calls:          #{pastel.send(short_calls_color, short_calls_status)}"
+
+      # Futures trading
+      futures_status = permissions[:futures]
+      futures_color = case futures_status
+                      when "Enabled" then :green
+                      when "Closing Only" then :yellow
+                      else :dim
+      end
+      puts "  Futures Trading:      #{pastel.send(futures_color, futures_status)}"
+
+      # Cryptocurrency trading
+      crypto_status = permissions[:cryptocurrency]
+      crypto_color = case crypto_status
+                     when "Enabled" then :green
+                     when "Closing Only" then :yellow
+                     else :dim
+      end
+      puts "  Cryptocurrency:       #{pastel.send(crypto_color, crypto_status)}"
+
+      # Portfolio margin
+      pm_status = permissions[:portfolio_margin]
+      pm_color = pm_status == "Enabled" ? :green : :dim
+      puts "  Portfolio Margin:     #{pastel.send(pm_color, pm_status)}"
+
+      # Display account characteristics
+      puts "\n#{pastel.bold("Account Characteristics:")}"
+      pdt_status = permissions[:pattern_day_trader] == "Yes" ? pastel.yellow("Yes") : pastel.dim("No")
+      puts "  Pattern Day Trader:   #{pdt_status}"
+
+      if status.day_trade_count && status.day_trade_count > 0
+        puts "  Day Trade Count:      #{pastel.cyan(status.day_trade_count.to_s)}"
+      end
+
+      if status.pdt_reset_on
+        puts "  PDT Reset Date:       #{pastel.yellow(status.pdt_reset_on.strftime("%Y-%m-%d"))}"
+      end
+
+      # Display additional info
+      puts "\n#{pastel.bold("Additional Information:")}"
+      puts "  Fee Schedule:         #{pastel.cyan(status.fee_schedule_name)}"
+      puts "  Margin Type:          #{pastel.cyan(status.equities_margin_calculation_type)}"
+      puts "  Last Updated:         #{pastel.dim(status.updated_at.strftime("%Y-%m-%d %H:%M:%S %Z"))}"
+
+      puts ""
+    end
+
     private
 
     def load_session
@@ -143,6 +245,12 @@ module Tastytrade
         session.instance_variable_set(:@session_expiration, Time.parse(session_data[:session_expiration]))
       end
 
+      # Set user data if available
+      if session_data[:user_data]
+        user = Tastytrade::Models::User.new(session_data[:user_data])
+        session.instance_variable_set(:@user, user)
+      end
+
       # Check if session needs refresh
       if session.expired? && session.remember_token
         info "Session expired, refreshing automatically..."
@@ -154,19 +262,8 @@ module Tastytrade
         return nil
       end
 
-      # Final validation
-      if session.validate
-        session
-      else
-        # Try one more refresh if we have a remember token
-        if session.remember_token
-          session.refresh_session
-          manager.save_session(session) if session.validate
-          session
-        else
-          nil
-        end
-      end
+      # Return the session - validation happens on actual API calls
+      session
     rescue Tastytrade::SessionExpiredError, Tastytrade::AuthenticationError => e
       warning "Session invalid: #{e.message}"
       nil

data/lib/tastytrade/client.rb

@@ -108,6 +108,13 @@ module Tastytrade
       return response.status.to_s if response.body.nil? || response.body.empty?
 
       data = parse_json(response.body)
+
+      # Handle preflight check failures with detailed errors
+      if data["code"] == "preflight_check_failure" && data["errors"]
+        error_details = data["errors"].map { |e| e["message"] }.join(", ")
+        return "#{data["message"]}: #{error_details}"
+      end
+
       # Handle both old and new API error formats
       data["error"] || data["message"] || data["reason"] || response.status.to_s
     rescue StandardError

data/lib/tastytrade/file_store.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+module Tastytrade
+  # Secure file-based credential storage
+  module FileStore
+    class << self
+      # Store a credential in a file
+      #
+      # @param key [String] The credential key
+      # @param value [String] The credential value
+      # @return [Boolean] Success status
+      def set(key, value)
+        return false if key.nil? || value.nil?
+
+        ensure_storage_directory
+        File.write(credential_path(key), value.to_s, mode: "w", perm: 0o600)
+        true
+      rescue StandardError => e
+        warn "Failed to store credential: #{e.message}" if ENV["DEBUG_SESSION"]
+        false
+      end
+
+      # Retrieve a credential from a file
+      #
+      # @param key [String] The credential key
+      # @return [String, nil] The credential value or nil if not found
+      def get(key)
+        return nil if key.nil?
+
+        path = credential_path(key)
+        return nil unless File.exist?(path)
+
+        File.read(path).strip
+      rescue StandardError => e
+        warn "Failed to retrieve credential: #{e.message}" if ENV["DEBUG_SESSION"]
+        nil
+      end
+
+      # Delete a credential file
+      #
+      # @param key [String] The credential key
+      # @return [Boolean] Success status
+      def delete(key)
+        return false if key.nil?
+
+        path = credential_path(key)
+        return true unless File.exist?(path)
+
+        File.delete(path)
+        true
+      rescue StandardError => e
+        warn "Failed to delete credential: #{e.message}" if ENV["DEBUG_SESSION"]
+        false
+      end
+
+      # Check if file storage is available
+      #
+      # @return [Boolean] Always true for file storage
+      def available?
+        true
+      end
+
+      private
+
+      def storage_directory
+        @storage_directory ||= File.expand_path("~/.config/tastytrade/credentials")
+      end
+
+      def ensure_storage_directory
+        FileUtils.mkdir_p(storage_directory, mode: 0o700)
+      end
+
+      def credential_path(key)
+        # Sanitize key to be filesystem-safe
+        safe_key = key.to_s.gsub(/[^a-zA-Z0-9._@-]/, "_")
+        File.join(storage_directory, "#{safe_key}.cred")
+      end
+    end
+  end
+end

data/lib/tastytrade/instruments/equity.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Tastytrade
+  module Instruments
+    # Represents an equity instrument
+    class Equity
+      attr_reader :symbol, :description, :exchange, :cusip, :active
+
+      def initialize(data = {})
+        @symbol = data["symbol"]
+        @description = data["description"]
+        @exchange = data["exchange"]
+        @cusip = data["cusip"]
+        @active = data["active"]
+      end
+
+      # Get equity information for a symbol
+      #
+      # @param session [Tastytrade::Session] Active session
+      # @param symbol [String] Equity symbol
+      # @return [Equity] Equity instrument
+      def self.get(session, symbol)
+        response = session.get("/instruments/equities/#{symbol}")
+        new(response["data"])
+      end
+
+      # Create an order leg for this equity
+      #
+      # @param action [String] Order action (from OrderAction module)
+      # @param quantity [Integer] Number of shares
+      # @return [OrderLeg] Order leg for this equity
+      def build_leg(action:, quantity:)
+        OrderLeg.new(
+          action: action,
+          symbol: @symbol,
+          quantity: quantity,
+          instrument_type: "Equity"
+        )
+      end
+    end
+  end
+end

data/lib/tastytrade/models/account.rb

@@ -63,9 +63,147 @@ module Tastytrade
       # Get trading status
       #
       # @param session [Tastytrade::Session] Active session
-      # @return [Hash] Trading status data
+      # @return [Tastytrade::Models::TradingStatus] Trading status object
       def get_trading_status(session)
-        session.get("/accounts/#{account_number}/trading-status/")["data"]
+        response = session.get("/accounts/#{account_number}/trading-status/")
+        TradingStatus.new(response["data"])
+      end
+
+      # Places an order for this account with comprehensive validation.
+      # By default, performs full validation including symbol checks, quantity limits,
+      # price validation, account permissions, and buying power verification.
+      #
+      # @param session [Tastytrade::Session] Active session
+      # @param order [Tastytrade::Order] Order to place
+      # @param dry_run [Boolean] Whether to simulate the order without placing it
+      # @param skip_validation [Boolean] Skip pre-submission validation (use with caution)
+      # @return [OrderResponse] Response from order placement with order ID and status
+      # @raise [OrderValidationError] if validation fails with detailed error messages
+      # @raise [InsufficientFundsError] if account lacks buying power
+      # @raise [MarketClosedError] if market is closed
+      #
+      # @example Place an order with validation
+      #   response = account.place_order(session, order)
+      #   puts response.order_id
+      #
+      # @example Dry-run to check buying power
+      #   response = account.place_order(session, order, dry_run: true)
+      #   puts response.buying_power_effect
+      #
+      # @example Skip validation when certain order is valid
+      #   response = account.place_order(session, order, skip_validation: true)
+      def place_order(session, order, dry_run: false, skip_validation: false)
+        # Validate the order unless explicitly skipped or it's a dry-run
+        unless skip_validation || dry_run
+          validator = OrderValidator.new(session, self, order)
+          validator.validate!
+        end
+
+        endpoint = "/accounts/#{account_number}/orders"
+        endpoint += "/dry-run" if dry_run
+
+        response = session.post(endpoint, order.to_api_params)
+        OrderResponse.new(response["data"])
+      end
+
+      # Get transaction history
+      #
+      # @param session [Tastytrade::Session] Active session
+      # @param options [Hash] Optional filters
+      # @option options [Date, String] :start_date Start date for transactions
+      # @option options [Date, String] :end_date End date for transactions
+      # @option options [String] :symbol Filter by symbol
+      # @option options [String] :underlying_symbol Filter by underlying symbol
+      # @option options [String] :instrument_type Filter by instrument type
+      # @option options [Array<String>] :transaction_types Filter by transaction types
+      # @option options [Integer] :per_page Number of results per page (default: 250)
+      # @option options [Integer] :page_offset Page offset for pagination
+      # @return [Array<Transaction>] Array of transactions
+      def get_transactions(session, **options)
+        Transaction.get_all(session, account_number, **options)
+      end
+
+      # Get live orders (open and orders from last 24 hours)
+      #
+      # @param session [Tastytrade::Session] Active session
+      # @param status [String, nil] Filter by order status
+      # @param underlying_symbol [String, nil] Filter by underlying symbol
+      # @param from_time [Time, nil] Start time for order history
+      # @param to_time [Time, nil] End time for order history
+      # @return [Array<LiveOrder>] Array of live orders
+      def get_live_orders(session, status: nil, underlying_symbol: nil, from_time: nil, to_time: nil)
+        params = {}
+        params["status"] = status if status && OrderStatus.valid?(status)
+        params["underlying-symbol"] = underlying_symbol if underlying_symbol
+        params["from-time"] = from_time.iso8601 if from_time
+        params["to-time"] = to_time.iso8601 if to_time
+
+        response = session.get("/accounts/#{account_number}/orders/live/", params)
+        response["data"]["items"].map { |item| LiveOrder.new(item) }
+      end
+
+      # Get order history for this account (beyond 24 hours)
+      #
+      # @param session [Tastytrade::Session] Active session
+      # @param status [String, nil] Filter by order status
+      # @param underlying_symbol [String, nil] Filter by underlying symbol
+      # @param from_time [Time, nil] Start time for order history
+      # @param to_time [Time, nil] End time for order history
+      # @param page_offset [Integer, nil] Pagination offset
+      # @param page_limit [Integer, nil] Number of results per page (default 250, max 1000)
+      # @return [Array<LiveOrder>] Array of historical orders
+      def get_order_history(session, status: nil, underlying_symbol: nil, from_time: nil, to_time: nil,
+                           page_offset: nil, page_limit: nil)
+        params = {}
+        params["status"] = status if status && OrderStatus.valid?(status)
+        params["underlying-symbol"] = underlying_symbol if underlying_symbol
+        params["from-time"] = from_time.iso8601 if from_time
+        params["to-time"] = to_time.iso8601 if to_time
+        params["page-offset"] = page_offset if page_offset
+        params["page-limit"] = page_limit if page_limit
+
+        response = session.get("/accounts/#{account_number}/orders/", params)
+        response["data"]["items"].map { |item| LiveOrder.new(item) }
+      end
+
+      # Get a specific order by ID
+      #
+      # @param session [Tastytrade::Session] Active session
+      # @param order_id [String] Order ID to retrieve
+      # @return [LiveOrder] The requested order
+      def get_order(session, order_id)
+        response = session.get("/accounts/#{account_number}/orders/#{order_id}/")
+        LiveOrder.new(response["data"])
+      end
+
+      # Cancel an order
+      #
+      # @param session [Tastytrade::Session] Active session
+      # @param order_id [String] Order ID to cancel
+      # @return [void]
+      # @raise [OrderNotCancellableError] if order cannot be cancelled
+      # @raise [OrderAlreadyFilledError] if order has already been filled
+      def cancel_order(session, order_id)
+        session.delete("/accounts/#{account_number}/orders/#{order_id}/")
+        nil
+      rescue Tastytrade::Error => e
+        handle_cancel_error(e)
+      end
+
+      # Replace an existing order
+      #
+      # @param session [Tastytrade::Session] Active session
+      # @param order_id [String] Order ID to replace
+      # @param new_order [Tastytrade::Order] New order to replace with
+      # @return [OrderResponse] Response from order replacement
+      # @raise [OrderNotEditableError] if order cannot be edited
+      # @raise [InsufficientQuantityError] if trying to replace more than remaining quantity
+      def replace_order(session, order_id, new_order)
+        response = session.put("/accounts/#{account_number}/orders/#{order_id}/",
+                                new_order.to_api_params)
+        OrderResponse.new(response["data"])
+      rescue Tastytrade::Error => e
+        handle_replace_error(e)
       end
 
       def closed?
@@ -86,6 +224,26 @@ module Tastytrade
 
       private
 
+      def handle_cancel_error(error)
+        if error.message.include?("already filled") || error.message.include?("Filled")
+          raise OrderAlreadyFilledError, "Order has already been filled and cannot be cancelled"
+        elsif error.message.include?("not cancellable") || error.message.include?("Cannot cancel")
+          raise OrderNotCancellableError, "Order is not in a cancellable state"
+        else
+          raise error
+        end
+      end
+
+      def handle_replace_error(error)
+        if error.message.include?("not editable") || error.message.include?("Cannot edit")
+          raise OrderNotEditableError, "Order is not in an editable state"
+        elsif error.message.include?("insufficient quantity") || error.message.include?("exceeds remaining")
+          raise InsufficientQuantityError, "Cannot replace order with quantity exceeding remaining amount"
+        else
+          raise error
+        end
+      end
+
       def parse_attributes
         parse_basic_attributes
         parse_status_attributes

data/lib/tastytrade/models/account_balance.rb

@@ -63,6 +63,52 @@ module Tastytrade
         total_equity_value + total_derivative_value
       end
 
+      # Calculate derivative buying power usage percentage
+      def derivative_buying_power_usage_percentage
+        return BigDecimal("0") if derivative_buying_power.zero?
+
+        used_derivative_buying_power = derivative_buying_power - available_trading_funds
+        ((used_derivative_buying_power / derivative_buying_power) * 100).round(2)
+      end
+
+      # Calculate day trading buying power usage percentage
+      def day_trading_buying_power_usage_percentage
+        return BigDecimal("0") if day_trading_buying_power.zero?
+
+        used_day_trading_buying_power = day_trading_buying_power - available_trading_funds
+        ((used_day_trading_buying_power / day_trading_buying_power) * 100).round(2)
+      end
+
+      # Get the minimum buying power across all types
+      def minimum_buying_power
+        [equity_buying_power, derivative_buying_power, day_trading_buying_power].min
+      end
+
+      # Check if account has sufficient buying power for a given amount
+      def sufficient_buying_power?(amount, buying_power_type: :equity)
+        bp = case buying_power_type
+             when :equity then equity_buying_power
+             when :derivative then derivative_buying_power
+             when :day_trading then day_trading_buying_power
+             else equity_buying_power
+        end
+
+        bp >= BigDecimal(amount.to_s)
+      end
+
+      # Calculate buying power impact as percentage
+      def buying_power_impact_percentage(amount, buying_power_type: :equity)
+        bp = case buying_power_type
+             when :equity then equity_buying_power
+             when :derivative then derivative_buying_power
+             when :day_trading then day_trading_buying_power
+             else equity_buying_power
+        end
+
+        return BigDecimal("0") if bp.zero?
+        ((BigDecimal(amount.to_s) / bp) * 100).round(2)
+      end
+
       private
 
       # Parse string value to BigDecimal, handling nil and empty strings

data/lib/tastytrade/models/buying_power_effect.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module Tastytrade
+  module Models
+    # Represents the buying power effect from a dry-run order or order placement
+    class BuyingPowerEffect < Base
+      attr_reader :change_in_margin_requirement, :change_in_buying_power,
+                  :current_buying_power, :new_buying_power,
+                  :isolated_order_margin_requirement, :is_spread,
+                  :impact, :effect
+
+      # Calculate the buying power usage percentage for this order
+      def buying_power_usage_percentage
+        return BigDecimal("0") if current_buying_power.nil? || current_buying_power.zero?
+
+        impact_amount = impact || change_in_buying_power&.abs || BigDecimal("0")
+        ((impact_amount / current_buying_power) * 100).round(2)
+      end
+
+      # Check if this order would use more than the specified percentage of buying power
+      def exceeds_threshold?(threshold_percentage)
+        buying_power_usage_percentage > BigDecimal(threshold_percentage.to_s)
+      end
+
+      # Get the absolute value of the buying power change
+      def buying_power_change_amount
+        change_in_buying_power&.abs || impact&.abs || BigDecimal("0")
+      end
+
+      # Check if this is a debit (reduces buying power)
+      def debit?
+        effect == "Debit" || (change_in_buying_power && change_in_buying_power < 0)
+      end
+
+      # Check if this is a credit (increases buying power)
+      def credit?
+        effect == "Credit" || (change_in_buying_power && change_in_buying_power > 0)
+      end
+
+      private
+
+      def parse_attributes
+        @change_in_margin_requirement = parse_decimal(@data["change-in-margin-requirement"])
+        @change_in_buying_power = parse_decimal(@data["change-in-buying-power"])
+        @current_buying_power = parse_decimal(@data["current-buying-power"])
+        @new_buying_power = parse_decimal(@data["new-buying-power"])
+        @isolated_order_margin_requirement = parse_decimal(@data["isolated-order-margin-requirement"])
+        @is_spread = @data["is-spread"]
+        @impact = parse_decimal(@data["impact"])
+        @effect = @data["effect"]
+      end
+
+      def parse_decimal(value)
+        return nil if value.nil? || value.to_s.empty?
+        BigDecimal(value.to_s)
+      end
+    end
+  end
+end