tastytrade 0.2.0

data/lib/tastytrade/cli_helpers.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require "pastel"
+require "tty-prompt"
+
+module Tastytrade
+  # Common CLI helper methods
+  module CLIHelpers
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Ensure consistent exit behavior
+      def exit_on_failure?
+        true
+      end
+    end
+
+    # Colorization helper
+    def pastel
+      @pastel ||= Pastel.new
+    end
+
+    # Interactive prompt helper
+    def prompt
+      @prompt ||= TTY::Prompt.new
+    end
+
+    # Configuration helper
+    def config
+      @config ||= CLIConfig.new
+    end
+
+    # Print error message in red
+    def error(message)
+      warn pastel.red("Error: #{message}")
+    end
+
+    # Print warning message in yellow
+    def warning(message)
+      warn pastel.yellow("Warning: #{message}")
+    end
+
+    # Print success message in green
+    def success(message)
+      puts pastel.green("✓ #{message}")
+    end
+
+    # Print info message
+    def info(message)
+      puts pastel.cyan("→ #{message}")
+    end
+
+    # Format currency values
+    def format_currency(value)
+      return "$0.00" if value.nil? || value.zero?
+
+      formatted = format("$%.2f", value.abs)
+      # Add thousand separators
+      formatted.gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, '\\1,')
+      value.negative? ? "-#{formatted}" : formatted
+    end
+
+    # Color code value based on positive/negative
+    def color_value(value, format_as_currency: true)
+      return pastel.dim("$0.00") if value.nil? || value.zero?
+
+      formatted = format_as_currency ? format_currency(value) : value.to_s
+
+      if value.positive?
+        pastel.green(formatted)
+      else
+        pastel.red(formatted)
+      end
+    end
+
+    # Get current session if authenticated
+    def current_session
+      @current_session ||= load_session
+    rescue StandardError => e
+      error("Failed to load session: #{e.message}")
+      nil
+    end
+
+    # Check if user is authenticated
+    def authenticated?
+      !current_session.nil?
+    end
+
+    # Require authentication or exit
+    def require_authentication!
+      return if authenticated?
+
+      error("You must be logged in to use this command.")
+      info("Run 'tastytrade login' to authenticate.")
+      exit 1
+    end
+
+    # Get the currently selected account
+    def current_account
+      return @current_account if @current_account
+
+      account_number = config.get("current_account_number")
+      return nil unless account_number
+
+      @current_account = Tastytrade::Models::Account.get(current_session, account_number)
+    rescue StandardError => e
+      warn "Failed to load current account: #{e.message}"
+      nil
+    end
+
+    # Get the currently selected account number
+    def current_account_number
+      config.get("current_account_number")
+    end
+
+    private
+
+    def load_session
+      # Try to load saved session
+      username = config.get("current_username")
+      environment = config.get("environment") || "production"
+
+      return nil unless username
+
+      manager = SessionManager.new(username: username, environment: environment)
+      session_data = manager.load_session
+
+      return nil unless session_data && session_data[:session_token]
+
+      # Create session with saved token
+      session = Session.new(
+        username: session_data[:username],
+        password: nil,
+        is_test: environment == "sandbox"
+      )
+
+      # Set the tokens and expiration directly
+      session.instance_variable_set(:@session_token, session_data[:session_token])
+      session.instance_variable_set(:@remember_token, session_data[:remember_token])
+      if session_data[:session_expiration]
+        session.instance_variable_set(:@session_expiration, Time.parse(session_data[:session_expiration]))
+      end
+
+      # Check if session needs refresh
+      if session.expired? && session.remember_token
+        info "Session expired, refreshing automatically..."
+        session.refresh_session
+        manager.save_session(session)
+        success "Session refreshed"
+      elsif session.expired?
+        warning "Session expired and no refresh token available"
+        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
+    rescue Tastytrade::SessionExpiredError, Tastytrade::AuthenticationError => e
+      warning "Session invalid: #{e.message}"
+      nil
+    rescue StandardError => e
+      error "Failed to load session: #{e.message}"
+      nil
+    end
+  end
+end

data/lib/tastytrade/client.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/retry"
+require "json"
+
+module Tastytrade
+  # HTTP client wrapper for Tastytrade API communication
+  class Client
+    attr_reader :base_url
+
+    DEFAULT_TIMEOUT = 30
+
+    def initialize(base_url:, timeout: DEFAULT_TIMEOUT)
+      @base_url = base_url
+      @timeout = timeout
+    end
+
+    def get(path, params = {}, headers = {})
+      response = connection.get(path, params, default_headers.merge(headers))
+      handle_response(response)
+    rescue Faraday::ConnectionFailed => e
+      raise Tastytrade::NetworkTimeoutError, "Request timed out: #{e.message}"
+    end
+
+    def post(path, body = {}, headers = {})
+      response = connection.post(path, body.to_json, default_headers.merge(headers))
+      handle_response(response)
+    rescue Faraday::ConnectionFailed => e
+      raise Tastytrade::NetworkTimeoutError, "Request timed out: #{e.message}"
+    end
+
+    def put(path, body = {}, headers = {})
+      response = connection.put(path, body.to_json, default_headers.merge(headers))
+      handle_response(response)
+    rescue Faraday::ConnectionFailed => e
+      raise Tastytrade::NetworkTimeoutError, "Request timed out: #{e.message}"
+    end
+
+    def delete(path, headers = {})
+      response = connection.delete(path, nil, default_headers.merge(headers))
+      handle_response(response)
+    rescue Faraday::ConnectionFailed => e
+      raise Tastytrade::NetworkTimeoutError, "Request timed out: #{e.message}"
+    end
+
+    private
+
+    def connection
+      @connection ||= Faraday.new(url: base_url) do |faraday|
+        faraday.request :retry, max: 2, interval: 0.5,
+                                retry_statuses: [429, 503, 504],
+                                methods: %i[get put delete]
+        faraday.options.timeout = @timeout
+        faraday.options.open_timeout = @timeout
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+
+    def default_headers
+      {
+        "Accept" => "application/json",
+        "Content-Type" => "application/json"
+      }
+    end
+
+    def handle_response(response)
+      return handle_success(response) if (200..299).cover?(response.status)
+
+      handle_error(response)
+    end
+
+    def handle_success(response)
+      return nil if response.body.nil? || response.body.empty?
+
+      # API returns data in a 'data' field for most endpoints
+      parse_json(response.body)
+    end
+
+    def handle_error(response)
+      error_details = parse_error_message(response)
+
+      case response.status
+      when 401
+        raise Tastytrade::InvalidCredentialsError, "Authentication failed: #{error_details}"
+      when 403
+        raise Tastytrade::SessionExpiredError, "Session expired or invalid: #{error_details}"
+      when 404
+        raise Tastytrade::Error, "Resource not found: #{error_details}"
+      when 429
+        raise Tastytrade::Error, "Rate limit exceeded: #{error_details}"
+      when 400..499
+        raise Tastytrade::Error, "Client error: #{error_details}"
+      when 500..599
+        raise Tastytrade::Error, "Server error: #{error_details}"
+      else
+        raise Tastytrade::Error, "Unexpected response: #{error_details}"
+      end
+    end
+
+    def parse_json(body)
+      JSON.parse(body)
+    rescue JSON::ParserError => e
+      raise Tastytrade::Error, "Invalid JSON response: #{e.message}"
+    end
+
+    def parse_error_message(response)
+      return response.status.to_s if response.body.nil? || response.body.empty?
+
+      data = parse_json(response.body)
+      # Handle both old and new API error formats
+      data["error"] || data["message"] || data["reason"] || response.status.to_s
+    rescue StandardError
+      response.status.to_s
+    end
+  end
+end

data/lib/tastytrade/keyring_store.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "keyring"
+
+module Tastytrade
+  # Secure credential storage using system keyring
+  class KeyringStore
+    SERVICE_NAME = "tastytrade-ruby"
+
+    class << self
+      # Store a credential securely
+      #
+      # @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?
+
+        backend.set_password(SERVICE_NAME, key.to_s, value.to_s)
+        true
+      rescue StandardError => e
+        warn "Failed to store credential: #{e.message}"
+        false
+      end
+
+      # Retrieve a credential
+      #
+      # @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?
+
+        backend.get_password(SERVICE_NAME, key.to_s)
+      rescue StandardError => e
+        warn "Failed to retrieve credential: #{e.message}"
+        nil
+      end
+
+      # Delete a credential
+      #
+      # @param key [String] The credential key
+      # @return [Boolean] Success status
+      def delete(key)
+        return false if key.nil?
+
+        backend.delete_password(SERVICE_NAME, key.to_s)
+        true
+      rescue StandardError => e
+        warn "Failed to delete credential: #{e.message}"
+        false
+      end
+
+      # Check if keyring is available
+      #
+      # @return [Boolean] True if keyring backend is available
+      def available?
+        !backend.nil?
+      rescue StandardError
+        false
+      end
+
+      private
+
+      def backend
+        @backend ||= Keyring.new
+      rescue StandardError => e
+        warn "Keyring not available: #{e.message}"
+        nil
+      end
+    end
+  end
+end

data/lib/tastytrade/models/account.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Tastytrade
+  module Models
+    # Represents a Tastytrade account
+    class Account < Base
+      attr_reader :account_number, :nickname, :account_type_name,
+                  :opened_at, :is_closed, :day_trader_status,
+                  :is_futures_approved, :margin_or_cash, :is_foreign,
+                  :created_at, :external_id, :closed_at, :funding_date,
+                  :investment_objective, :suitable_options_level,
+                  :is_test_drive
+
+      class << self
+        # Get all accounts for the authenticated user
+        #
+        # @param session [Tastytrade::Session] Active session
+        # @param include_closed [Boolean] Include closed accounts
+        # @return [Array<Account>] List of accounts
+        def get_all(session, include_closed: false)
+          params = include_closed ? { "include-closed" => true } : {}
+          response = session.get("/customers/me/accounts/", params)
+          response["data"]["items"].map { |item| new(item["account"]) }
+        end
+
+        # Get a specific account by account number
+        #
+        # @param session [Tastytrade::Session] Active session
+        # @param account_number [String] Account number
+        # @return [Account] Account instance
+        def get(session, account_number)
+          response = session.get("/accounts/#{account_number}/")
+          new(response["data"])
+        end
+      end
+
+      # Get account balances
+      #
+      # @param session [Tastytrade::Session] Active session
+      # @return [AccountBalance] Account balance object
+      def get_balances(session)
+        response = session.get("/accounts/#{account_number}/balances/")
+        AccountBalance.new(response["data"])
+      end
+
+      # Get current positions
+      #
+      # @param session [Tastytrade::Session] Active session
+      # @param symbol [String, nil] Filter by symbol
+      # @param underlying_symbol [String, nil] Filter by underlying symbol
+      # @param include_closed [Boolean] Include closed positions
+      # @return [Array<CurrentPosition>] Position objects
+      def get_positions(session, symbol: nil, underlying_symbol: nil, include_closed: false)
+        params = {}
+        params["symbol"] = symbol if symbol
+        params["underlying-symbol"] = underlying_symbol if underlying_symbol
+        params["include-closed"] = include_closed if include_closed
+
+        response = session.get("/accounts/#{account_number}/positions/", params)
+        response["data"]["items"].map { |item| CurrentPosition.new(item) }
+      end
+
+      # Get trading status
+      #
+      # @param session [Tastytrade::Session] Active session
+      # @return [Hash] Trading status data
+      def get_trading_status(session)
+        session.get("/accounts/#{account_number}/trading-status/")["data"]
+      end
+
+      def closed?
+        @is_closed == true
+      end
+
+      def futures_approved?
+        @is_futures_approved == true
+      end
+
+      def test_drive?
+        @is_test_drive == true
+      end
+
+      def foreign?
+        @is_foreign == true
+      end
+
+      private
+
+      def parse_attributes
+        parse_basic_attributes
+        parse_status_attributes
+        parse_optional_attributes
+      end
+
+      def parse_basic_attributes
+        @account_number = @data["account-number"]
+        @nickname = @data["nickname"]
+        @account_type_name = @data["account-type-name"]
+        @opened_at = parse_time(@data["opened-at"])
+        @margin_or_cash = @data["margin-or-cash"]
+        @created_at = parse_time(@data["created-at"])
+      end
+
+      def parse_status_attributes
+        @is_closed = @data["is-closed"]
+        @day_trader_status = @data["day-trader-status"]
+        @is_futures_approved = @data["is-futures-approved"]
+        @is_foreign = @data["is-foreign"]
+        @is_test_drive = @data["is-test-drive"]
+      end
+
+      def parse_optional_attributes
+        @external_id = @data["external-id"]
+        @closed_at = parse_time(@data["closed-at"])
+        @funding_date = parse_date(@data["funding-date"])
+        @investment_objective = @data["investment-objective"]
+        @suitable_options_level = @data["suitable-options-level"]
+      end
+
+      def parse_date(value)
+        return nil if value.nil? || value.empty?
+
+        Date.parse(value)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/tastytrade/models/account_balance.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module Tastytrade
+  module Models
+    # Represents account balance information from the API
+    class AccountBalance < Base
+      attr_reader :account_number, :cash_balance, :long_equity_value, :short_equity_value,
+                  :long_derivative_value, :short_derivative_value, :net_liquidating_value,
+                  :equity_buying_power, :derivative_buying_power, :day_trading_buying_power,
+                  :available_trading_funds, :margin_equity, :pending_cash,
+                  :pending_margin_interest, :effective_trading_funds, :updated_at
+
+      def initialize(data)
+        super
+        @account_number = data["account-number"]
+
+        # Convert all monetary values to BigDecimal for precision
+        @cash_balance = parse_decimal(data["cash-balance"])
+        @long_equity_value = parse_decimal(data["long-equity-value"])
+        @short_equity_value = parse_decimal(data["short-equity-value"])
+        @long_derivative_value = parse_decimal(data["long-derivative-value"])
+        @short_derivative_value = parse_decimal(data["short-derivative-value"])
+        @net_liquidating_value = parse_decimal(data["net-liquidating-value"])
+        @equity_buying_power = parse_decimal(data["equity-buying-power"])
+        @derivative_buying_power = parse_decimal(data["derivative-buying-power"])
+        @day_trading_buying_power = parse_decimal(data["day-trading-buying-power"])
+        @available_trading_funds = parse_decimal(data["available-trading-funds"])
+        @margin_equity = parse_decimal(data["margin-equity"])
+        @pending_cash = parse_decimal(data["pending-cash"])
+        @pending_margin_interest = parse_decimal(data["pending-margin-interest"])
+        @effective_trading_funds = parse_decimal(data["effective-trading-funds"])
+
+        @updated_at = parse_time(data["updated-at"])
+      end
+
+      # Calculate buying power usage as a percentage
+      def buying_power_usage_percentage
+        return BigDecimal("0") if equity_buying_power.zero?
+
+        used_buying_power = equity_buying_power - available_trading_funds
+        ((used_buying_power / equity_buying_power) * 100).round(2)
+      end
+
+      # Check if buying power usage is above warning threshold
+      def high_buying_power_usage?(threshold = 80)
+        buying_power_usage_percentage > threshold
+      end
+
+      # Calculate total equity value (long + short)
+      def total_equity_value
+        long_equity_value + short_equity_value
+      end
+
+      # Calculate total derivative value (long + short)
+      def total_derivative_value
+        long_derivative_value + short_derivative_value
+      end
+
+      # Calculate total market value (equity + derivatives)
+      def total_market_value
+        total_equity_value + total_derivative_value
+      end
+
+      private
+
+      # Parse string value to BigDecimal, handling nil and empty strings
+      def parse_decimal(value)
+        return BigDecimal("0") if value.nil? || value.to_s.empty?
+        BigDecimal(value.to_s)
+      end
+    end
+  end
+end

data/lib/tastytrade/models/base.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Tastytrade
+  module Models
+    # Base class for all Tastytrade data models
+    class Base
+      def initialize(data = {})
+        @data = stringify_keys(data)
+        parse_attributes
+      end
+
+      attr_reader :data
+
+      private
+
+      # Convert snake_case to dash-case for API compatibility
+      def to_api_key(key)
+        key.to_s.tr("_", "-")
+      end
+
+      # Convert dash-case to snake_case for Ruby
+      def to_ruby_key(key)
+        key.to_s.tr("-", "_")
+      end
+
+      def stringify_keys(hash)
+        hash.transform_keys(&:to_s)
+      end
+
+      # Override in subclasses to define attribute parsing
+      def parse_attributes
+        # Implemented by subclasses
+      end
+
+      # Helper method to parse datetime strings
+      def parse_time(value)
+        return nil if value.nil? || value.empty?
+
+        Time.parse(value)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end