tastytrade 0.2.0 → 0.3.1

data/lib/tastytrade/cli.rb

@@ -6,6 +6,7 @@ require "bigdecimal"
 require_relative "cli_helpers"
 require_relative "cli_config"
 require_relative "session_manager"
+require_relative "cli/orders"
 
 module Tastytrade
   # Main CLI class for Tastytrade gem
@@ -25,20 +26,65 @@ module Tastytrade
     end
 
     desc "login", "Login to Tastytrade"
+    long_desc <<-LONGDESC
+    Login to your Tastytrade account.#{" "}
+
+    Credentials can be provided via:
+    - Environment variables: TASTYTRADE_USERNAME, TASTYTRADE_PASSWORD (or TT_USERNAME, TT_PASSWORD)
+    - Command line option: --username (password will be prompted)
+    - Interactive prompts (default)
+
+    Optional environment variables:
+    - TASTYTRADE_ENVIRONMENT=sandbox (or TT_ENVIRONMENT) for test environment
+    - TASTYTRADE_REMEMBER=true (or TT_REMEMBER) to save session for auto-refresh
+
+    Examples:
+      $ tastytrade login
+      $ tastytrade login --username user@example.com
+      $ tastytrade login --no-interactive  # Skip interactive mode
+      $ TASTYTRADE_USERNAME=user@example.com TASTYTRADE_PASSWORD=pass tastytrade login --no-interactive
+    LONGDESC
     option :username, aliases: "-u", desc: "Username"
     option :remember, aliases: "-r", type: :boolean, default: false, desc: "Remember credentials"
+    option :no_interactive, type: :boolean, default: false, desc: "Skip interactive mode after login"
     def login
-      credentials = login_credentials
-      environment = options[:test] ? "sandbox" : "production"
+      # Try environment variables first
+      if (session = Session.from_environment)
+        environment = session.instance_variable_get(:@is_test) ? "sandbox" : "production"
+        info "Using credentials from environment variables..."
+        info "Logging in to #{environment} environment..."
 
+        begin
+          session.login
+          success "Successfully logged in as #{session.user.email}"
+
+          save_user_session(session, {
+                              username: session.user.email,
+                              remember: session.remember_token ? true : false
+                            }, environment)
+
+          @current_session = session
+          interactive_mode unless options[:no_interactive]
+          return
+        rescue Tastytrade::Error => e
+          error "Environment variable login failed: #{e.message}"
+          info "Falling back to interactive login..."
+        end
+      end
+
+      # Fall back to interactive login
+      environment = options[:test] ? "sandbox" : "production"
+      credentials = login_credentials
       info "Logging in to #{environment} environment..."
       session = authenticate_user(credentials)
 
-      save_user_session(session, credentials, environment)
+      # Update credentials with actual email from session
+      credentials_with_email = credentials.merge(username: session.user.email)
+      save_user_session(session, credentials_with_email, environment)
 
-      # Enter interactive mode after successful login
+      # Enter interactive mode after successful login (unless --no-interactive)
       @current_session = session
-      interactive_mode
+      interactive_mode unless options[:no_interactive]
     rescue Tastytrade::InvalidCredentialsError => e
       error "Invalid credentials: #{e.message}"
       exit 1
@@ -99,8 +145,13 @@ module Tastytrade
         environment: environment
       )
 
+      # Save the configuration first
+      config.set("current_username", credentials[:username])
+      config.set("environment", environment)
+      config.set("last_login", Time.now.to_s)
+
       if manager.save_session(session, password: credentials[:password], remember: credentials[:remember])
-        info "Session saved securely" if credentials[:remember]
+        info "Session saved securely"
       else
         warning "Failed to save session credentials"
       end
@@ -323,6 +374,240 @@ module Tastytrade
       exit 1
     end
 
+    desc "positions", "Display account positions"
+    option :account, type: :string, desc: "Account number (uses default if not specified)"
+    option :symbol, type: :string, desc: "Filter by symbol"
+    option :underlying_symbol, type: :string, desc: "Filter by underlying symbol"
+    option :include_closed, type: :boolean, default: false, desc: "Include closed positions"
+    # Display account positions with optional filtering
+    #
+    # @example Display all open positions
+    #   tastytrade positions
+    #
+    # @example Display positions for a specific symbol
+    #   tastytrade positions --symbol AAPL
+    #
+    # @example Display option positions for an underlying symbol
+    #   tastytrade positions --underlying-symbol SPY
+    #
+    # @example Include closed positions
+    #   tastytrade positions --include-closed
+    #
+    # @example Display positions for a specific account
+    #   tastytrade positions --account 5WX12345
+    #
+    def positions
+      require_authentication!
+
+      # Get the account to use
+      account = if options[:account]
+        Tastytrade::Models::Account.get(current_session, options[:account])
+      else
+        current_account || select_account_interactively
+      end
+
+      return unless account
+
+      info "Fetching positions for account #{account.account_number}..."
+
+      # Fetch positions with filters
+      positions = account.get_positions(
+        current_session,
+        symbol: options[:symbol],
+        underlying_symbol: options[:underlying_symbol],
+        include_closed: options[:include_closed]
+      )
+
+      if positions.empty?
+        warning "No positions found"
+        return
+      end
+
+      # Display positions using formatter
+      formatter = Tastytrade::PositionsFormatter.new(pastel: pastel)
+      formatter.format_table(positions)
+    rescue Tastytrade::Error => e
+      error "Failed to fetch positions: #{e.message}"
+      exit 1
+    rescue StandardError => e
+      error "Unexpected error: #{e.message}"
+      exit 1
+    end
+
+    desc "trading_status", "Display account trading status and permissions"
+    option :account, type: :string, desc: "Account number (uses default if not specified)"
+    def trading_status
+      require_authentication!
+
+      account = if options[:account]
+        Tastytrade::Models::Account.get(current_session, options[:account])
+      else
+        current_account || select_account_interactively
+      end
+
+      return unless account
+
+      trading_status = account.get_trading_status(current_session)
+      display_trading_status(trading_status)
+    rescue Tastytrade::Error => e
+      error "Failed to fetch trading status: #{e.message}"
+      exit 1
+    rescue StandardError => e
+      error "Unexpected error: #{e.message}"
+      exit 1
+    end
+
+    desc "history", "Display transaction history"
+    option :account, type: :string, desc: "Account number (uses default if not specified)"
+    option :start_date, type: :string, desc: "Start date (YYYY-MM-DD)"
+    option :end_date, type: :string, desc: "End date (YYYY-MM-DD)"
+    option :symbol, type: :string, desc: "Filter by symbol"
+    option :type, type: :string, desc: "Filter by transaction type"
+    option :group_by, type: :string, desc: "Group transactions by: symbol, type, or date"
+    option :limit, type: :numeric, desc: "Limit number of transactions"
+    # Display transaction history with optional filtering and grouping
+    #
+    # @example Display all transactions
+    #   tastytrade history
+    #
+    # @example Display transactions for a specific symbol
+    #   tastytrade history --symbol AAPL
+    #
+    # @example Display transactions for a date range
+    #   tastytrade history --start-date 2024-01-01 --end-date 2024-12-31
+    #
+    # @example Group transactions by symbol
+    #   tastytrade history --group-by symbol
+    #
+    # @example Filter by transaction type
+    #   tastytrade history --type Trade
+    #
+    def history
+      require_authentication!
+
+      # Get the account to use
+      account = if options[:account]
+        Tastytrade::Models::Account.get(current_session, options[:account])
+      else
+        current_account || select_account_interactively
+      end
+
+      return unless account
+
+      info "Fetching transaction history for account #{account.account_number}..."
+
+      # Build filter options
+      filter_options = {}
+      filter_options[:start_date] = Date.parse(options[:start_date]) if options[:start_date]
+      filter_options[:end_date] = Date.parse(options[:end_date]) if options[:end_date]
+      filter_options[:symbol] = options[:symbol].upcase if options[:symbol]
+      filter_options[:transaction_types] = [options[:type]] if options[:type]
+      filter_options[:per_page] = options[:limit] if options[:limit]
+
+      # Fetch transactions
+      transactions = account.get_transactions(current_session, **filter_options)
+
+      if transactions.empty?
+        warning "No transactions found"
+        return
+      end
+
+      # Display transactions using formatter
+      formatter = Tastytrade::HistoryFormatter.new(pastel: pastel)
+      group_by = options[:group_by]&.to_sym
+      formatter.format_table(transactions, group_by: group_by)
+    rescue Date::Error => e
+      error "Invalid date format: #{e.message}. Use YYYY-MM-DD format."
+      exit 1
+    rescue Tastytrade::Error => e
+      error "Failed to fetch transaction history: #{e.message}"
+      exit 1
+    rescue StandardError => e
+      error "Unexpected error: #{e.message}"
+      exit 1
+    end
+
+    desc "buying_power", "Display buying power status"
+    option :account, type: :string, desc: "Account number (uses default if not specified)"
+    # Display buying power status and usage
+    #
+    # @example Display buying power status
+    #   tastytrade buying_power
+    #
+    # @example Display buying power for specific account
+    #   tastytrade buying_power --account 5WX12345
+    #
+    def buying_power
+      require_authentication!
+
+      # Get the account to use
+      account = if options[:account]
+        Tastytrade::Models::Account.get(current_session, options[:account])
+      else
+        current_account || select_account_interactively
+      end
+
+      return unless account
+
+      info "Fetching buying power status for account #{account.account_number}..."
+
+      balance = account.get_balances(current_session)
+
+      # Create buying power status table
+      headers = ["Buying Power Type", "Available", "Usage %", "Status"]
+      rows = [
+        [
+          "Equity Buying Power",
+          format_currency(balance.equity_buying_power),
+          "#{balance.buying_power_usage_percentage.to_s("F")}%",
+          format_bp_status(balance.buying_power_usage_percentage)
+        ],
+        [
+          "Derivative Buying Power",
+          format_currency(balance.derivative_buying_power),
+          "#{balance.derivative_buying_power_usage_percentage.to_s("F")}%",
+          format_bp_status(balance.derivative_buying_power_usage_percentage)
+        ],
+        [
+          "Day Trading Buying Power",
+          format_currency(balance.day_trading_buying_power),
+          "-",
+          balance.day_trading_buying_power > 0 ? pastel.green("Available") : pastel.yellow("N/A")
+        ]
+      ]
+
+      table = TTY::Table.new(headers, rows)
+
+      puts
+      begin
+        puts table.render(:unicode, padding: [0, 1])
+      rescue StandardError
+        # Fallback for testing or non-TTY environments
+        puts headers.join(" | ")
+        puts "-" * 80
+        rows.each { |row| puts row.join(" | ") }
+      end
+
+      # Display additional metrics
+      puts
+      puts "Additional Information:"
+      puts "  Available Trading Funds: #{format_currency(balance.available_trading_funds)}"
+      puts "  Cash Balance: #{format_currency(balance.cash_balance)}"
+      puts "  Net Liquidating Value: #{format_currency(balance.net_liquidating_value)}"
+
+      # Display warnings if needed
+      if balance.high_buying_power_usage?
+        puts
+        warning "High buying power usage detected! Consider reducing positions."
+      end
+    rescue Tastytrade::Error => e
+      error "Failed to fetch buying power status: #{e.message}"
+      exit 1
+    rescue StandardError => e
+      error "Unexpected error: #{e.message}"
+      exit 1
+    end
+
     desc "status", "Check session status"
     def status
       session = current_session
@@ -393,6 +678,164 @@ module Tastytrade
       interactive_mode
     end
 
+    # Register the Orders subcommand
+    desc "order SUBCOMMAND ...ARGS", "Manage orders"
+    subcommand "order", CLI::Orders
+
+    desc "place SYMBOL QUANTITY", "Place an order for equities"
+    option :type, default: "market", desc: "Order type (market or limit)"
+    option :price, type: :numeric, desc: "Price for limit orders"
+    option :action, default: "buy", desc: "Order action (buy or sell)"
+    option :dry_run, type: :boolean, default: false, desc: "Simulate order without placing it"
+    option :account, type: :string, desc: "Account number (uses default if not specified)"
+    # Place an order for equities
+    #
+    # @example Place a market buy order
+    #   tastytrade place AAPL 100
+    #
+    # @example Place a limit buy order
+    #   tastytrade place AAPL 100 --type limit --price 150.50
+    #
+    # @example Place a sell order
+    #   tastytrade place AAPL 100 --action sell
+    #
+    # @example Dry run an order
+    #   tastytrade place AAPL 100 --dry-run
+    #
+    def place(symbol, quantity)
+      require_authentication!
+
+      # Get the account to use
+      account = if options[:account]
+        Tastytrade::Models::Account.get(current_session, options[:account])
+      else
+        current_account || select_account_interactively
+      end
+
+      return unless account
+
+      # Create the order leg
+      action = case options[:action].downcase
+               when "buy"
+                 Tastytrade::OrderAction::BUY_TO_OPEN
+               when "sell"
+                 Tastytrade::OrderAction::SELL_TO_CLOSE
+               else
+                 error "Invalid action: #{options[:action]}. Must be 'buy' or 'sell'"
+                 exit 1
+      end
+
+      leg = Tastytrade::OrderLeg.new(
+        action: action,
+        symbol: symbol.upcase,
+        quantity: quantity
+      )
+
+      # Create the order
+      order_type = case options[:type].downcase
+                   when "market"
+                     Tastytrade::OrderType::MARKET
+                   when "limit"
+                     Tastytrade::OrderType::LIMIT
+                   else
+                     error "Invalid order type: #{options[:type]}. Must be 'market' or 'limit'"
+                     exit 1
+      end
+
+      begin
+        order = Tastytrade::Order.new(
+          type: order_type,
+          legs: leg,
+          price: options[:price]
+        )
+      rescue ArgumentError => e
+        error e.message
+        exit 1
+      end
+
+      # Place the order
+      order_desc = "#{options[:type]} #{options[:action]} order for #{quantity} shares of #{symbol}"
+      info "Placing #{options[:dry_run] ? "simulated " : ""}#{order_desc}..."
+
+      begin
+        # First do a dry run to check buying power impact
+        dry_run_response = account.place_order(current_session, order, dry_run: true)
+
+        # Check if this is a BuyingPowerEffect object
+        if dry_run_response.buying_power_effect.is_a?(Tastytrade::Models::BuyingPowerEffect)
+          bp_effect = dry_run_response.buying_power_effect
+          bp_usage = bp_effect.buying_power_usage_percentage
+
+          if bp_usage > 80
+            warning "This order will use #{bp_usage.to_s("F")}% of your buying power!"
+
+            # Fetch current balance for more context
+            balance = account.get_balances(current_session)
+            puts ""
+            puts "Current Buying Power Status:"
+            puts "  Available Trading Funds: #{format_currency(balance.available_trading_funds)}"
+            puts "  Equity Buying Power: #{format_currency(balance.equity_buying_power)}"
+            puts "  Current BP Usage: #{balance.buying_power_usage_percentage.to_s("F")}%"
+            puts ""
+
+            unless options[:dry_run]
+              unless prompt.yes?("Are you sure you want to proceed with this order?")
+                info "Order cancelled"
+                return
+              end
+            end
+          end
+        end
+
+        # Place the actual order if not dry run
+        if options[:dry_run]
+          response = dry_run_response
+          success "Dry run successful!"
+        else
+          response = account.place_order(current_session, order, dry_run: false)
+          success "Order placed successfully!"
+        end
+
+        puts ""
+        puts "Order Details:"
+        if response.order_id && !response.order_id.empty?
+          puts "  Order ID: #{response.order_id}"
+        end
+        if response.status && !response.status.empty?
+          puts "  Status: #{response.status}"
+        end
+        if response.account_number && !response.account_number.empty?
+          puts "  Account: #{response.account_number}"
+        end
+
+        # Handle both BigDecimal and BuyingPowerEffect
+        if response.buying_power_effect
+          if response.buying_power_effect.is_a?(Tastytrade::Models::BuyingPowerEffect)
+            bp_effect = response.buying_power_effect
+            puts "  Buying Power Impact: #{format_currency(bp_effect.buying_power_change_amount)}"
+            puts "  BP Usage: #{bp_effect.buying_power_usage_percentage.to_s("F")}%"
+          else
+            puts "  Buying Power Effect: #{format_currency(response.buying_power_effect)}"
+          end
+        end
+
+        if response.warnings.any?
+          puts ""
+          warning "Warnings:"
+          response.warnings.each do |w|
+            if w.is_a?(Hash)
+              puts "  - #{w["message"] || w["code"]}"
+            else
+              puts "  - #{w}"
+            end
+          end
+        end
+      rescue Tastytrade::Error => e
+        error "Failed to place order: #{e.message}"
+        exit 1
+      end
+    end
+
     private
 
     def interactive_mode
@@ -411,9 +854,11 @@ module Tastytrade
         when :portfolio
           info "Portfolio command not yet implemented"
         when :positions
-          info "Positions command not yet implemented"
+          interactive_positions
+        when :history
+          interactive_history
         when :orders
-          info "Orders command not yet implemented"
+          interactive_order
         when :settings
           info "Settings command not yet implemented"
         when :exit
@@ -431,13 +876,14 @@ module Tastytrade
 
       result = menu_prompt.select("Main Menu#{account_info}", per_page: 10) do |menu|
         menu.enum "."  # Enable number shortcuts with . delimiter
-        menu.help "(Use ↑/↓ arrows, vim j/k, numbers 1-8, q or ESC to quit)"
+        menu.help "(Use ↑/↓ arrows, vim j/k, numbers 1-9, q or ESC to quit)"
 
         menu.choice "Accounts - View all accounts", :accounts
         menu.choice "Select Account - Choose active account", :select
         menu.choice "Balance - View account balance", :balance
         menu.choice "Portfolio - View holdings", :portfolio
         menu.choice "Positions - View open positions", :positions
+        menu.choice "History - View transaction history", :history
         menu.choice "Orders - View recent orders", :orders
         menu.choice "Settings - Configure preferences", :settings
         menu.choice "Exit", :exit
@@ -516,9 +962,7 @@ module Tastytrade
 
       case action
       when :positions
-        info "Positions view not yet implemented"
-        prompt.keypress("\nPress any key to continue...")
-        interactive_balance # Show balance menu again
+        interactive_positions
       when :switch
         interactive_select
         interactive_balance if current_account_number # Check for account number instead of making API call
@@ -600,5 +1044,250 @@ module Tastytrade
         prompt.select("Select an account:", choices)
       end
     end
+
+    def interactive_positions
+      account = @current_account || current_account || select_account_interactively
+      return unless account
+
+      info "Fetching positions for account #{account.account_number}..."
+
+      positions = account.get_positions(current_session)
+
+      if positions.empty?
+        warning "No positions found"
+        prompt.keypress("\nPress any key to continue...")
+        return
+      end
+
+      formatter = Tastytrade::PositionsFormatter.new(pastel: pastel)
+      formatter.format_table(positions)
+
+      prompt.keypress("\nPress any key to continue...")
+    rescue Tastytrade::Error => e
+      error "Failed to fetch positions: #{e.message}"
+      prompt.keypress("\nPress any key to continue...")
+    rescue StandardError => e
+      error "Unexpected error: #{e.message}"
+      prompt.keypress("\nPress any key to continue...")
+    end
+
+    def interactive_history
+      account = @current_account || current_account || select_account_interactively
+      return unless account
+
+      # Create vim-enabled prompt for grouping option
+      group_prompt = create_vim_prompt
+      grouping = group_prompt.select("How would you like to view transactions?", per_page: 5) do |menu|
+        menu.enum "."
+        menu.help "(Use ↑/↓ arrows, vim j/k, numbers 1-5, q or ESC to go back)"
+        menu.choice "All transactions (detailed)", nil
+        menu.choice "Group by symbol", :symbol
+        menu.choice "Group by type", :type
+        menu.choice "Group by date", :date
+        menu.choice "Back to main menu", :back
+      end
+
+      return if @exit_requested || grouping == :back
+
+      # Ask for date range
+      filter_by_date = prompt.yes?("Filter by date range?")
+
+      filter_options = {}
+      if filter_by_date
+        begin
+          start_date = prompt.ask("Enter start date (YYYY-MM-DD):") do |q|
+            q.validate(/^\d{4}-\d{2}-\d{2}$/, "Must be in YYYY-MM-DD format")
+          end
+          filter_options[:start_date] = Date.parse(start_date)
+
+          end_date = prompt.ask("Enter end date (YYYY-MM-DD):") do |q|
+            q.validate(/^\d{4}-\d{2}-\d{2}$/, "Must be in YYYY-MM-DD format")
+          end
+          filter_options[:end_date] = Date.parse(end_date)
+        rescue Date::Error => e
+          error "Invalid date: #{e.message}"
+          prompt.keypress("\nPress any key to continue...")
+          return
+        end
+      end
+
+      # Ask for symbol filter
+      filter_by_symbol = prompt.yes?("Filter by symbol?")
+      if filter_by_symbol
+        symbol = prompt.ask("Enter symbol:") { |q| q.modify :up }.upcase
+        filter_options[:symbol] = symbol
+      end
+
+      info "Fetching transaction history for account #{account.account_number}..."
+
+      transactions = account.get_transactions(current_session, **filter_options)
+
+      if transactions.empty?
+        warning "No transactions found"
+        prompt.keypress("\nPress any key to continue...")
+        return
+      end
+
+      formatter = Tastytrade::HistoryFormatter.new(pastel: pastel)
+      formatter.format_table(transactions, group_by: grouping)
+
+      prompt.keypress("\nPress any key to continue...")
+    rescue Tastytrade::Error => e
+      error "Failed to fetch transaction history: #{e.message}"
+      prompt.keypress("\nPress any key to continue...")
+    rescue StandardError => e
+      error "Unexpected error: #{e.message}"
+      prompt.keypress("\nPress any key to continue...")
+    end
+
+    def interactive_order
+      account = @current_account || current_account || select_account_interactively
+      return unless account
+
+      # Get order details
+      symbol = prompt.ask("Enter symbol:") { |q| q.modify :up }.upcase
+      quantity = prompt.ask("Enter quantity:", convert: :int) do |q|
+        q.validate(/^\d+$/, "Must be a positive number")
+      end
+
+      # Create vim-enabled prompt for order type
+      order_type_prompt = create_vim_prompt
+      order_type = order_type_prompt.select("Select order type:", per_page: 2) do |menu|
+        menu.enum "."
+        menu.help "(Use ↑/↓ arrows, vim j/k, numbers 1-2, q or ESC to go back)"
+        menu.choice "Market - Execute at current market price", "Market"
+        menu.choice "Limit - Execute at specified price or better", "Limit"
+      end
+
+      return if @exit_requested
+
+      price = nil
+      if order_type == "Limit"
+        price = prompt.ask("Enter limit price:", convert: :float) do |q|
+          q.validate(/^\d+(\.\d+)?$/, "Must be a valid price")
+        end
+      end
+
+      # Create vim-enabled prompt for action
+      action_prompt = create_vim_prompt
+      action = action_prompt.select("Select action:", per_page: 2) do |menu|
+        menu.enum "."
+        menu.help "(Use ↑/↓ arrows, vim j/k, numbers 1-2, q or ESC to go back)"
+        menu.choice "Buy - Purchase shares", "Buy"
+        menu.choice "Sell - Sell shares", "Sell"
+      end
+
+      return if @exit_requested
+
+      # Show order summary
+      puts "\nOrder Summary:"
+      puts "  Symbol: #{symbol}"
+      puts "  Quantity: #{quantity}"
+      puts "  Type: #{order_type}"
+      puts "  Price: #{price ? format_currency(price) : "Market"}" if order_type == "Limit"
+      puts "  Action: #{action}"
+      puts "  Account: #{account.account_number}"
+
+      dry_run = prompt.yes?("\nRun as simulation (dry run)?")
+
+      if prompt.yes?("\nPlace this order?")
+        # Create the order
+        order_action = action == "Buy" ? Tastytrade::OrderAction::BUY_TO_OPEN : Tastytrade::OrderAction::SELL_TO_CLOSE
+
+        leg = Tastytrade::OrderLeg.new(
+          action: order_action,
+          symbol: symbol,
+          quantity: quantity
+        )
+
+        order_type_constant = order_type == "Market" ? Tastytrade::OrderType::MARKET : Tastytrade::OrderType::LIMIT
+
+        begin
+          order = Tastytrade::Order.new(
+            type: order_type_constant,
+            legs: leg,
+            price: price
+          )
+
+          info "Placing #{dry_run ? "simulated " : ""}order..."
+
+          # First do a dry run to check buying power impact
+          dry_run_response = account.place_order(current_session, order, dry_run: true)
+
+          # Check buying power impact
+          if dry_run_response.buying_power_effect.is_a?(Tastytrade::Models::BuyingPowerEffect)
+            bp_effect = dry_run_response.buying_power_effect
+            bp_usage = bp_effect.buying_power_usage_percentage
+
+            if bp_usage > 80
+              warning "This order will use #{bp_usage.to_s("F")}% of your buying power!"
+
+              # Fetch current balance for more context
+              balance = account.get_balances(current_session)
+              puts ""
+              puts "Current Buying Power Status:"
+              puts "  Available Trading Funds: #{format_currency(balance.available_trading_funds)}"
+              puts "  Equity Buying Power: #{format_currency(balance.equity_buying_power)}"
+              puts "  Current BP Usage: #{balance.buying_power_usage_percentage.to_s("F")}%"
+              puts ""
+
+              unless dry_run
+                unless prompt.yes?("Are you sure you want to proceed with this order?")
+                  info "Order cancelled"
+                  prompt.keypress("\nPress any key to continue...")
+                  return
+                end
+              end
+            end
+          end
+
+          # Place the actual order if not dry run
+          response = if dry_run
+            dry_run_response
+          else
+            account.place_order(current_session, order, dry_run: false)
+          end
+
+          success "#{dry_run ? "Dry run" : "Order placed"} successfully!"
+
+          puts "\nOrder Details:"
+          puts "  Order ID: #{response.order_id}" if response.order_id && !response.order_id.empty?
+          puts "  Status: #{response.status}" if response.status && !response.status.empty?
+
+          # Handle both BigDecimal and BuyingPowerEffect
+          if response.buying_power_effect
+            if response.buying_power_effect.is_a?(Tastytrade::Models::BuyingPowerEffect)
+              bp_effect = response.buying_power_effect
+              puts "  Buying Power Impact: #{format_currency(bp_effect.buying_power_change_amount)}"
+              puts "  BP Usage: #{bp_effect.buying_power_usage_percentage.to_s("F")}%"
+            else
+              puts "  Buying Power Effect: #{format_currency(response.buying_power_effect)}"
+            end
+          end
+
+          if response.warnings.any?
+            warning "Warnings:"
+            response.warnings.each { |w| puts "  - #{w}" }
+          end
+        rescue Tastytrade::Error => e
+          error "Failed to place order: #{e.message}"
+        rescue ArgumentError => e
+          error e.message
+        end
+      else
+        info "Order cancelled"
+      end
+
+      prompt.keypress("\nPress any key to continue...")
+    rescue Interrupt
+      nil
+    rescue => e
+      error "Failed to place order: #{e.message}"
+      prompt.keypress("\nPress any key to continue...")
+    end
   end
 end
+
+# Require after CLI class is defined to avoid module/class conflict
+require_relative "cli/positions_formatter"
+require_relative "cli/history_formatter"