Options Strategy Advisor

Overview

This skill provides comprehensive options strategy analysis and education using theoretical pricing models. It helps traders understand, analyze, and simulate options strategies without requiring real-time market data subscriptions.

Core Capabilities:

• Black-Scholes Pricing: Theoretical option prices and Greeks calculation
• Strategy Simulation: P/L analysis for major options strategies
• Earnings Strategies: Pre-earnings volatility plays integrated with Earnings Calendar
• Risk Management: Position sizing, Greeks exposure, max loss/profit analysis
• Educational Focus: Detailed explanations of strategies and risk metrics

Data Sources:

• FMP API: Stock prices, historical volatility, dividends, earnings dates
• User Input: Implied volatility (IV), risk-free rate
• Theoretical Models: Black-Scholes for pricing and Greeks

Prerequisites

Required:

• Python 3.8+ with numpy, scipy, requests

Optional:

• FMP API key (for real-time stock prices and historical volatility)
  • Set via FMP_API_KEY environment variable or --api-key argument
  • Without API key: Use manual inputs for stock price and volatility

Installation:

pip install numpy scipy requests

Quick Start Examples:

# Basic call option pricing (no API key needed)
python3 scripts/black_scholes.py

# With FMP API key for real-time data
python3 scripts/black_scholes.py --ticker AAPL --api-key $FMP_API_KEY

# Custom option parameters
python3 scripts/black_scholes.py --stock-price 180 --strike 185 --days 30 --volatility 0.25

# Put option analysis
python3 scripts/black_scholes.py --stock-price 180 --strike 175 --days 30 --option-type put

When to Use This Skill

Use this skill when:

• User asks about options strategies ("What's a covered call?", "How does an iron condor work?")
• User wants to simulate strategy P/L ("What's my max profit on a bull call spread?")
• User needs Greeks analysis ("What's my delta exposure?")
• User asks about earnings strategies ("Should I buy a straddle before earnings?")
• User wants to compare strategies ("Covered call vs protective put?")
• User needs position sizing guidance ("How many contracts should I trade?")
• User asks about volatility ("Is IV high right now?")

Example requests:

• "Analyze a covered call on AAPL"
• "What's the P/L on a $100/$105 bull call spread on MSFT?"
• "Should I trade a straddle before NVDA earnings?"
• "Calculate Greeks for my iron condor position"
• "Compare protective put vs covered call for downside protection"

Supported Strategies

Income Strategies

1. Covered Call - Own stock, sell call (generate income, cap upside)
2. Cash-Secured Put - Sell put with cash backing (collect premium, willing to buy stock)
3. Poor Man's Covered Call - LEAPS call + short near-term call (capital efficient)

Protection Strategies

4. Protective Put - Own stock, buy put (insurance, limited downside)
5. Collar - Own stock, sell call + buy put (limited upside/downside)

Directional Strategies

6. Bull Call Spread - Buy lower strike call, sell higher strike call (limited risk/reward bullish)
7. Bull Put Spread - Sell higher strike put, buy lower strike put (credit spread, bullish)
8. Bear Call Spread - Sell lower strike call, buy higher strike call (credit spread, bearish)
9. Bear Put Spread - Buy higher strike put, sell lower strike put (limited risk/reward bearish)

Volatility Strategies

10. Long Straddle - Buy ATM call + ATM put (profit from big move either direction)
11. Long Strangle - Buy OTM call + OTM put (cheaper than straddle, bigger move needed)
12. Short Straddle - Sell ATM call + ATM put (profit from no movement, unlimited risk)
13. Short Strangle - Sell OTM call + OTM put (profit from no movement, wider range)

Range-Bound Strategies

14. Iron Condor - Bull put spread + bear call spread (profit from range-bound movement)
15. Iron Butterfly - Sell ATM straddle, buy OTM strangle (profit from tight range)

Advanced Strategies

16. Calendar Spread - Sell near-term option, buy longer-term option (profit from time decay)
17. Diagonal Spread - Calendar spread with different strikes (directional + time decay)
18. Ratio Spread - Unbalanced spread (more contracts on one leg)

Analysis Workflow

Step 1: Gather Input Data

Required from User:

• Ticker symbol
• Strategy type
• Strike prices
• Expiration date(s)
• Position size (number of contracts)

Optional from User:

• Implied Volatility (IV) - if not provided, use Historical Volatility (HV)
• Risk-free rate - default to current 3-month T-bill rate (~5.3% as of 2025)

Fetched from FMP API:

• Current stock price
• Historical prices (for HV calculation)
• Dividend yield
• Upcoming earnings date (for earnings strategies)

Example User Input:

Ticker: AAPL
Strategy: Bull Call Spread
Long Strike: $180
Short Strike: $185
Expiration: 30 days
Contracts: 10
IV: 25% (or use HV if not provided)

Step 2: Calculate Historical Volatility (if IV not provided)

Objective: Estimate volatility from historical price movements.

Method:

# Fetch 90 days of price data
prices = get_historical_prices("AAPL", days=90)

# Calculate daily returns
returns = np.log(prices / prices.shift(1))

# Annualized volatility
HV = returns.std() * np.sqrt(252)  # 252 trading days

Output:

• Historical Volatility (annualized percentage)
• Note to user: "HV = 24.5%, consider using current market IV for more accuracy"

User Can Override:

• Provide IV from broker platform (ThinkorSwim, TastyTrade, etc.)
• Script accepts --iv 28.0 parameter

Step 3: Price Options Using Black-Scholes

Black-Scholes Model:

For European-style options:

Call Price = S * N(d1) - K * e^(-r*T) * N(d2)
Put Price = K * e^(-r*T) * N(-d2) - S * N(-d1)

Where:
d1 = [ln(S/K) + (r + σ²/2) * T] / (σ * √T)
d2 = d1 - σ * √T

S = Current stock price
K = Strike price
r = Risk-free rate
T = Time to expiration (years)
σ = Volatility (IV or HV)
N() = Cumulative standard normal distribution

Adjustments:

• Subtract present value of dividends from S for calls
• American options: Use approximation or note "European pricing, may undervalue American options"

Python Implementation:

from scipy.stats import norm
import numpy as np

def black_scholes_call(S, K, T, r, sigma, q=0):
    """
    S: Stock price
    K: Strike price
    T: Time to expiration (years)
    r: Risk-free rate
    sigma: Volatility
    q: Dividend yield
    """
    d1 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    d2 = d1 - sigma*np.sqrt(T)

    call_price = S*np.exp(-q*T)*norm.cdf(d1) - K*np.exp(-r*T)*norm.cdf(d2)
    return call_price

def black_scholes_put(S, K, T, r, sigma, q=0):
    d1 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    d2 = d1 - sigma*np.sqrt(T)

    put_price = K*np.exp(-r*T)*norm.cdf(-d2) - S*np.exp(-q*T)*norm.cdf(-d1)
    return put_price

Output for Each Option Leg:

• Theoretical price
• Note: "Market price may differ due to bid-ask spread and American vs European pricing"

Step 4: Calculate Greeks

The Greeks measure option price sensitivity to various factors:

Delta (Δ): Change in option price per $1 change in stock price

def delta_call(S, K, T, r, sigma, q=0):
    d1 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    return np.exp(-q*T) * norm.cdf(d1)

def delta_put(S, K, T, r, sigma, q=0):
    d1 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    return np.exp(-q*T) * (norm.cdf(d1) - 1)

Gamma (Γ): Change in delta per $1 change in stock price

def gamma(S, K, T, r, sigma, q=0):
    d1 = (np.log(S/K) + (r - q +