tastytrade 0.2.0

data/lib/tastytrade/models/current_position.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module Tastytrade
+  module Models
+    # Represents a current position in an account
+    class CurrentPosition < Base
+      attr_reader :account_number, :symbol, :instrument_type, :underlying_symbol,
+                  :quantity, :quantity_direction, :close_price, :average_open_price,
+                  :average_yearly_market_close_price, :average_daily_market_close_price,
+                  :multiplier, :cost_effect, :is_suppressed, :is_frozen,
+                  :realized_day_gain, :realized_today, :created_at, :updated_at,
+                  :mark, :mark_price, :restricted_quantity, :expires_at,
+                  :root_symbol, :option_expiration_type, :strike_price,
+                  :option_type, :contract_size, :exercise_style
+
+      def initialize(data)
+        super
+        @account_number = data["account-number"]
+        @symbol = data["symbol"]
+        @instrument_type = data["instrument-type"]
+        @underlying_symbol = data["underlying-symbol"]
+
+        # Quantity information
+        @quantity = parse_decimal(data["quantity"])
+        @quantity_direction = data["quantity-direction"]
+        @restricted_quantity = parse_decimal(data["restricted-quantity"])
+
+        # Price information
+        @close_price = parse_decimal(data["close-price"])
+        @average_open_price = parse_decimal(data["average-open-price"])
+        @average_yearly_market_close_price = parse_decimal(data["average-yearly-market-close-price"])
+        @average_daily_market_close_price = parse_decimal(data["average-daily-market-close-price"])
+        @mark = parse_decimal(data["mark"])
+        @mark_price = parse_decimal(data["mark-price"])
+
+        # Position details
+        @multiplier = data["multiplier"]&.to_i || 1
+        @cost_effect = data["cost-effect"]
+        @is_suppressed = data["is-suppressed"] || false
+        @is_frozen = data["is-frozen"] || false
+
+        # Realized gains
+        @realized_day_gain = parse_decimal(data["realized-day-gain"])
+        @realized_today = parse_decimal(data["realized-today"])
+
+        # Timestamps
+        @created_at = parse_time(data["created-at"])
+        @updated_at = parse_time(data["updated-at"])
+        @expires_at = parse_time(data["expires-at"])
+
+        # Option-specific fields
+        @root_symbol = data["root-symbol"]
+        @option_expiration_type = data["option-expiration-type"]
+        @strike_price = parse_decimal(data["strike-price"])
+        @option_type = data["option-type"]
+        @contract_size = data["contract-size"]&.to_i
+        @exercise_style = data["exercise-style"]
+      end
+
+      # Check if this is a long position
+      def long?
+        quantity_direction == "Long"
+      end
+
+      # Check if this is a short position
+      def short?
+        quantity_direction == "Short"
+      end
+
+      # Check if position is closed (zero quantity)
+      def closed?
+        quantity_direction == "Zero" || quantity.zero?
+      end
+
+      # Check if this is an equity position
+      def equity?
+        instrument_type == "Equity"
+      end
+
+      # Check if this is an option position
+      def option?
+        instrument_type == "Equity Option"
+      end
+
+      # Check if this is a futures position
+      def futures?
+        instrument_type == "Future"
+      end
+
+      # Check if this is a futures option position
+      def futures_option?
+        instrument_type == "Future Option"
+      end
+
+      # Calculate position value (quantity * price * multiplier)
+      def position_value
+        return BigDecimal("0") if closed?
+        price = mark_price.zero? ? close_price : mark_price
+        quantity.abs * price * multiplier
+      end
+
+      # Calculate unrealized P&L
+      def unrealized_pnl
+        return BigDecimal("0") if closed? || average_open_price.zero?
+
+        current_price = mark_price.zero? ? close_price : mark_price
+        if long?
+          (current_price - average_open_price) * quantity * multiplier
+        else
+          (average_open_price - current_price) * quantity.abs * multiplier
+        end
+      end
+
+      # Calculate unrealized P&L percentage
+      def unrealized_pnl_percentage
+        return BigDecimal("0") if closed? || average_open_price.zero?
+
+        cost_basis = average_open_price * quantity.abs * multiplier
+        return BigDecimal("0") if cost_basis.zero?
+
+        (unrealized_pnl / cost_basis * 100).round(2)
+      end
+
+      # Calculate total P&L (realized + unrealized)
+      def total_pnl
+        realized_today + unrealized_pnl
+      end
+
+      # Get display symbol (simplified for options)
+      def display_symbol
+        if option?
+          # Format: ROOT MM/DD/YY C/P STRIKE
+          return symbol unless expires_at && strike_price && option_type
+
+          exp_date = expires_at.strftime("%m/%d/%y")
+          type_char = option_type == "Call" ? "C" : "P"
+          strike_str = strike_price.to_s("F")
+          "#{root_symbol} #{exp_date} #{type_char} #{strike_str}"
+        else
+          symbol
+        end
+      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/user.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Tastytrade
+  module Models
+    # Represents a Tastytrade user
+    class User < Base
+      attr_reader :email, :username, :external_id, :is_professional
+
+      def professional?
+        @is_professional == true
+      end
+
+      private
+
+      def parse_attributes
+        @email = @data["email"]
+        @username = @data["username"]
+        @external_id = @data["external-id"]
+        @is_professional = @data["is-professional"]
+      end
+    end
+  end
+end

data/lib/tastytrade/models.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "models/base"
+require_relative "models/user"
+require_relative "models/account"
+require_relative "models/account_balance"
+require_relative "models/current_position"

data/lib/tastytrade/session.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require_relative "models"
+
+module Tastytrade
+  # Manages authentication and session state for Tastytrade API
+  class Session
+    attr_reader :user, :session_token, :remember_token, :is_test, :session_expiration
+
+    # Initialize a new session
+    #
+    # @param username [String] Tastytrade username
+    # @param password [String] Tastytrade password (optional if remember_token provided)
+    # @param remember_me [Boolean] Whether to save remember token
+    # @param remember_token [String] Existing remember token for re-authentication
+    # @param is_test [Boolean] Use test environment
+    def initialize(username:, password: nil, remember_me: false, remember_token: nil, is_test: false, timeout: Client::DEFAULT_TIMEOUT)
+      @username = username
+      @password = password
+      @remember_me = remember_me
+      @remember_token = remember_token
+      @is_test = is_test
+      @client = Client.new(base_url: api_url, timeout: timeout)
+    end
+
+    # Authenticate with Tastytrade API
+    #
+    # @return [Session] Self for method chaining
+    # @raise [Tastytrade::Error] If authentication fails
+    def login
+      response = @client.post("/sessions", login_credentials)
+      data = response["data"]
+
+      @user = Models::User.new(data["user"])
+      @session_token = data["session-token"]
+      @remember_token = data["remember-token"] if @remember_me
+
+      # Track session expiration if provided
+      if data["session-expiration"]
+        @session_expiration = Time.parse(data["session-expiration"])
+      end
+
+      self
+    end
+
+    # Validate current session
+    #
+    # @return [Boolean] True if session is valid
+    def validate
+      response = get("/sessions/validate")
+      response["data"]["email"] == @user.email
+    rescue Tastytrade::Error
+      false
+    end
+
+    # Destroy current session
+    #
+    # @return [nil]
+    def destroy
+      delete("/sessions") if @session_token
+      @session_token = nil
+      @remember_token = nil
+      @user = nil
+    end
+
+    # Make authenticated GET request
+    #
+    # @param path [String] API endpoint path
+    # @param params [Hash] Query parameters
+    # @return [Hash] Parsed response
+    def get(path, params = {})
+      @client.get(path, params, auth_headers)
+    end
+
+    # Make authenticated POST request
+    #
+    # @param path [String] API endpoint path
+    # @param body [Hash] Request body
+    # @return [Hash] Parsed response
+    def post(path, body = {})
+      @client.post(path, body, auth_headers)
+    end
+
+    # Make authenticated PUT request
+    #
+    # @param path [String] API endpoint path
+    # @param body [Hash] Request body
+    # @return [Hash] Parsed response
+    def put(path, body = {})
+      @client.put(path, body, auth_headers)
+    end
+
+    # Make authenticated DELETE request
+    #
+    # @param path [String] API endpoint path
+    # @return [Hash] Parsed response
+    def delete(path)
+      @client.delete(path, auth_headers)
+    end
+
+    # Check if authenticated
+    #
+    # @return [Boolean] True if session has token
+    def authenticated?
+      !@session_token.nil?
+    end
+
+    # Check if session is expired
+    #
+    # @return [Boolean] True if session is expired
+    def expired?
+      return false unless @session_expiration
+      Time.now >= @session_expiration
+    end
+
+    # Time remaining until session expires
+    #
+    # @return [Float, nil] Seconds until expiration
+    def time_until_expiry
+      return nil unless @session_expiration
+      @session_expiration - Time.now
+    end
+
+    # Refresh session using remember token
+    #
+    # @return [Session] Self
+    # @raise [Tastytrade::Error] If refresh fails
+    def refresh_session
+      raise Tastytrade::Error, "No remember token available" unless @remember_token
+
+      # Clear password and re-login with remember token
+      @password = nil
+      login
+    end
+
+    private
+
+    def api_url
+      @is_test ? Tastytrade::CERT_URL : Tastytrade::API_URL
+    end
+
+    def auth_headers
+      raise Tastytrade::Error, "Not authenticated" unless @session_token
+
+      { "Authorization" => @session_token }
+    end
+
+    def login_credentials
+      credentials = {
+        "login" => @username,
+        "remember-me" => @remember_me
+      }
+
+      # Use remember token if available and no password
+      if @remember_token && !@password
+        credentials["remember-token"] = @remember_token
+      else
+        credentials["password"] = @password
+      end
+
+      credentials
+    end
+  end
+end

data/lib/tastytrade/session_manager.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require_relative "keyring_store"
+require "json"
+
+module Tastytrade
+  # Manages session persistence and token storage
+  class SessionManager
+    SESSION_KEY_PREFIX = "session"
+    TOKEN_KEY_PREFIX = "token"
+    REMEMBER_KEY_PREFIX = "remember"
+
+    attr_reader :username, :environment
+
+    def initialize(username:, environment: "production")
+      @username = username
+      @environment = environment
+    end
+
+    # Save session data securely
+    #
+    # @param session [Tastytrade::Session] The session to save
+    # @param password [String] The password (only saved if remember is true)
+    # @param remember [Boolean] Whether to save credentials for auto-login
+    def save_session(session, password: nil, remember: false)
+      # Always save the session token
+      save_token(session.session_token)
+
+      # Save session expiration if available
+      save_session_expiration(session.session_expiration) if session.session_expiration
+
+      if remember && session.remember_token
+        save_remember_token(session.remember_token)
+        save_password(password) if password && KeyringStore.available?
+      end
+
+      # Save session metadata
+      config = CLIConfig.new
+      config.set("current_username", username)
+      config.set("environment", environment)
+      config.set("last_login", Time.now.to_s)
+
+      true
+    rescue StandardError => e
+      warn "Failed to save session: #{e.message}"
+      false
+    end
+
+    # Load saved session if available
+    #
+    # @return [Hash, nil] Session data or nil if not found
+    def load_session
+      token = load_token
+      return nil unless token
+
+      {
+        session_token: token,
+        remember_token: load_remember_token,
+        session_expiration: load_session_expiration,
+        username: username,
+        environment: environment
+      }
+    end
+
+    # Create a new session from saved credentials
+    #
+    # @return [Tastytrade::Session, nil] Authenticated session or nil
+    def restore_session
+      password = load_password
+      remember_token = load_remember_token
+
+      return nil unless password || remember_token
+
+      session = Session.new(
+        username: username,
+        password: password,
+        remember_token: remember_token,
+        is_test: environment == "sandbox"
+      )
+
+      session.login
+      session
+    rescue StandardError => e
+      warn "Failed to restore session: #{e.message}"
+      nil
+    end
+
+    # Clear all stored session data
+    def clear_session!
+      KeyringStore.delete(token_key)
+      KeyringStore.delete(remember_token_key)
+      KeyringStore.delete(password_key)
+      KeyringStore.delete(session_expiration_key)
+
+      config = CLIConfig.new
+      config.delete("current_username")
+      config.delete("last_login")
+
+      true
+    end
+
+    # Check if we have stored credentials
+    def saved_credentials?
+      !load_password.nil? || !load_remember_token.nil?
+    end
+
+    private
+
+    def token_key
+      "#{TOKEN_KEY_PREFIX}_#{username}_#{environment}"
+    end
+
+    def remember_token_key
+      "#{REMEMBER_KEY_PREFIX}_#{username}_#{environment}"
+    end
+
+    def password_key
+      "password_#{username}_#{environment}"
+    end
+
+    def session_expiration_key
+      "#{SESSION_KEY_PREFIX}_expiration_#{username}_#{environment}"
+    end
+
+    def save_token(token)
+      KeyringStore.set(token_key, token)
+    end
+
+    def load_token
+      KeyringStore.get(token_key)
+    end
+
+    def save_remember_token(token)
+      KeyringStore.set(remember_token_key, token)
+    end
+
+    def load_remember_token
+      KeyringStore.get(remember_token_key)
+    end
+
+    def save_password(password)
+      KeyringStore.set(password_key, password)
+    end
+
+    def load_password
+      KeyringStore.get(password_key)
+    end
+
+    def save_session_expiration(expiration)
+      KeyringStore.set(session_expiration_key, expiration.iso8601)
+    end
+
+    def load_session_expiration
+      value = KeyringStore.get(session_expiration_key)
+      value ? Time.parse(value).iso8601 : nil
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/tastytrade/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Tastytrade
+  VERSION = "0.2.0"
+end

data/lib/tastytrade.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Unofficial Ruby SDK for Tastytrade API
+#
+# IMPORTANT DISCLAIMER:
+# This is an unofficial SDK and is not affiliated with, endorsed by, or
+# sponsored by Tastytrade, Tastyworks, or any of their affiliates.
+#
+# Trading financial instruments involves substantial risk and may result in
+# loss of capital. This software is provided for educational purposes only.
+# Always consult with a qualified financial advisor before making investment decisions.
+
+require_relative "tastytrade/version"
+require_relative "tastytrade/client"
+require_relative "tastytrade/models"
+require_relative "tastytrade/session"
+
+module Tastytrade
+  class Error < StandardError; end
+
+  # Authentication errors
+  class AuthenticationError < Error; end
+  class SessionExpiredError < AuthenticationError; end
+  class TokenRefreshError < AuthenticationError; end
+  class InvalidCredentialsError < AuthenticationError; end
+  class NetworkTimeoutError < Error; end
+
+  # API URLs
+  API_URL = "https://api.tastyworks.com"
+  CERT_URL = "https://api.cert.tastyworks.com"
+end

data/sig/tastytrade.rbs

@@ -0,0 +1,4 @@
+module Tastytrade
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/spec/exe/tastytrade_spec.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "open3"
+
+RSpec.describe "tastytrade executable" do
+  let(:exe_path) { File.expand_path("../../exe/tastytrade", __dir__) }
+
+  def run_command(*args)
+    cmd = [exe_path] + args
+    stdout, stderr, status = Open3.capture3(*cmd)
+    { stdout: stdout, stderr: stderr, status: status }
+  end
+
+  it "exists and is executable" do
+    expect(File.exist?(exe_path)).to be true
+    expect(File.executable?(exe_path)).to be true
+  end
+
+  describe "version command" do
+    it "displays version information" do
+      result = run_command("version")
+      expect(result[:status].success?).to be true
+      expect(result[:stdout]).to include("Tastytrade CLI v#{Tastytrade::VERSION}")
+    end
+
+    it "works with --version flag" do
+      result = run_command("--version")
+      expect(result[:status].success?).to be true
+      expect(result[:stdout]).to include(Tastytrade::VERSION)
+    end
+  end
+
+  describe "help command" do
+    it "displays help information" do
+      result = run_command("help")
+      expect(result[:status].success?).to be true
+      expect(result[:stdout]).to include("Tastytrade commands:")
+      expect(result[:stdout]).to include("login")
+      expect(result[:stdout]).to include("accounts")
+      expect(result[:stdout]).to include("balance")
+    end
+
+    it "works with --help flag" do
+      result = run_command("--help")
+      expect(result[:status].success?).to be true
+      expect(result[:stdout]).to include("Tastytrade commands:")
+    end
+
+    it "works with -h flag" do
+      result = run_command("-h")
+      expect(result[:status].success?).to be true
+      expect(result[:stdout]).to include("Tastytrade commands:")
+    end
+  end
+
+  describe "global options" do
+    it "accepts --test flag" do
+      result = run_command("help", "--test")
+      expect(result[:status].success?).to be true
+      expect(result[:stdout]).to include("Tastytrade commands:")
+    end
+  end
+
+  describe "invalid commands" do
+    it "shows error for unknown command" do
+      result = run_command("invalid-command")
+      expect(result[:status].success?).to be false
+      expect(result[:stderr]).to include("Could not find command").or include("Unknown command")
+    end
+  end
+
+  describe "command stubs" do
+    it "has login command" do
+      result = run_command("help", "login")
+      expect(result[:status].success?).to be true
+      expect(result[:stdout]).to include("Login to Tastytrade")
+    end
+
+    it "has accounts command" do
+      result = run_command("help", "accounts")
+      expect(result[:status].success?).to be true
+      expect(result[:stdout]).to include("List all accounts")
+    end
+
+    it "has select command" do
+      result = run_command("help", "select")
+      expect(result[:status].success?).to be true
+      expect(result[:stdout]).to include("Select an account to use")
+    end
+
+    it "has logout command" do
+      result = run_command("help", "logout")
+      expect(result[:status].success?).to be true
+      expect(result[:stdout]).to include("Logout from Tastytrade")
+    end
+
+    it "has balance command" do
+      result = run_command("help", "balance")
+      expect(result[:status].success?).to be true
+      expect(result[:stdout]).to include("Display account balance")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+unless ENV["DISABLE_SIMPLECOV"]
+  require "simplecov"
+  SimpleCov.start do
+    add_filter "/spec/"
+    add_filter "/bin/"
+  end
+end
+
+require "bundler/setup"
+require "tastytrade"
+require "webmock/rspec"
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+end