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:
python3 scripts/black_scholes.py
python3 scripts/black_scholes.py --ticker AAPL --api-key $FMP_API_KEY
python3 scripts/black_scholes.py --stock-price 180 --strike 185 --days 30 --volatility 0.25
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
- Covered Call - Own stock, sell call (generate income, cap upside)
- Cash-Secured Put - Sell put with cash backing (collect premium, willing to buy stock)
- Poor Man's Covered Call - LEAPS call + short near-term call (capital efficient)
Protection Strategies
- Protective Put - Own stock, buy put (insurance, limited downside)
- Collar - Own stock, sell call + buy put (limited upside/downside)
Directional Strategies
- Bull Call Spread - Buy lower strike call, sell higher strike call (limited risk/reward bullish)
- Bull Put Spread - Sell higher strike put, buy lower strike put (credit spread, bullish)
- Bear Call Spread - Sell lower strike call, buy higher strike call (credit spread, bearish)
- Bear Put Spread - Buy higher strike put, sell lower strike put (limited risk/reward bearish)
Volatility Strategies
- Long Straddle - Buy ATM call + ATM put (profit from big move either direction)
- Long Strangle - Buy OTM call + OTM put (cheaper than straddle, bigger move needed)
- Short Straddle - Sell ATM call + ATM put (profit from no movement, unlimited risk)
- Short Strangle - Sell OTM call + OTM put (profit from no movement, wider range)
Range-Bound Strategies
- Iron Condor - Bull put spread + bear call spread (profit from range-bound movement)
- Iron Butterfly - Sell ATM straddle, buy OTM strangle (profit from tight range)
Advanced Strategies
- Calendar Spread - Sell near-term option, buy longer-term option (profit from time decay)
- Diagonal Spread - Calendar spread with different strikes (directional + time decay)
- 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:
prices = get_historical_prices("AAPL", days=90)
returns = np.log(prices / prices.shift(1))
HV = returns.std() * np.sqrt(252)
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 +
