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 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:

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^(-rT) * N(d2) Put Price = K * e^(-rT) * 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 + 0.5 * sigma ** 2 ) * T ) / ( sigma * np . sqrt ( T ) ) return np . exp ( - q * T ) * norm . pdf ( d1 ) / ( S * sigma * np . sqrt ( T ) ) Theta (Θ): Change in option price per day (time decay) def theta_call ( 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 ) theta = ( - S * norm . pdf ( d1 ) * sigma * np . exp ( - q * T ) / ( 2 * np . sqrt ( T ) ) - r * K * np . exp ( - r * T ) * norm . cdf ( d2 ) + q * S * norm . cdf ( d1 ) * np . exp ( - q * T ) ) return theta / 365

Per day

Vega (ν): Change in option price per 1% change in volatility def vega ( S , K , T , r , sigma , q = 0 ) : d1 = ( np . log ( S / K ) + ( r - q + 0.5 * sigma ** 2 ) * T ) / ( sigma * np . sqrt ( T ) ) return S * np . exp ( - q * T ) * norm . pdf ( d1 ) * np . sqrt ( T ) / 100

Per 1%

Rho (ρ): Change in option price per 1% change in interest rate def rho_call ( S , K , T , r , sigma , q = 0 ) : d2 = ( np . log ( S / K ) + ( r - q + 0.5 * sigma ** 2 ) * T ) / ( sigma * np . sqrt ( T ) ) - sigma * np . sqrt ( T ) return K * T * np . exp ( - r * T ) * norm . cdf ( d2 ) / 100

Per 1%

Position Greeks: For a strategy with multiple legs, sum Greeks across all legs:

Example: Bull Call Spread

Long 1x $180 call

Short 1x $185 call

delta_position

( 1 * delta_long ) + ( - 1 * delta_short ) gamma_position = ( 1 * gamma_long ) + ( - 1 * gamma_short ) theta_position = ( 1 * theta_long ) + ( - 1 * theta_short ) vega_position = ( 1 * vega_long ) + ( - 1 * vega_short ) Greeks Interpretation: Greek Meaning Example Delta Directional exposure Δ = 0.50 → $50 profit if stock +$1 Gamma Delta acceleration Γ = 0.05 → Delta increases by 0.05 if stock +$1 Theta Daily time decay Θ = -$5 → Lose $5/day from time passing Vega Volatility sensitivity ν = $10 → Gain $10 if IV increases 1% Rho Interest rate sensitivity ρ = $2 → Gain $2 if rates increase 1% Step 5: Simulate Strategy P/L Objective: Calculate profit/loss at various stock prices at expiration. Method: Generate stock price range (e.g., ±30% from current price): current_price = 180 price_range = np . linspace ( current_price * 0.7 , current_price * 1.3 , 100 ) For each price point, calculate P/L: def calculate_pnl ( strategy , stock_price_at_expiration ) : pnl = 0 for leg in strategy . legs : if leg . type == 'call' : intrinsic_value = max ( 0 , stock_price_at_expiration - leg . strike ) else :

put

intrinsic_value

max ( 0 , leg . strike - stock_price_at_expiration ) if leg . position == 'long' : pnl += ( intrinsic_value - leg . premium_paid ) * 100

Per contract

else :

short

pnl

+=

(

leg

.

premium_received

-

intrinsic_value

)

*

100

return

pnl

*

num_contracts

Key Metrics:

Max Profit

Highest possible P/L

Max Loss

Worst possible P/L

Breakeven Point(s)

Stock price(s) where P/L = 0
Profit Probability: Percentage of price range that's profitable (simplified) Example Output: Bull Call Spread: $180/$185 on AAPL (30 DTE, 10 contracts) Current Price: $180.00 Net Debit: $2.50 per spread ($2,500 total) Max Profit: $2,500 (at $185+) Max Loss: -$2,500 (at $180-) Breakeven: $182.50 Risk/Reward: 1:1 Probability Profit: ~55% (if stock stays above $182.50) Step 6: Generate P/L Diagram (ASCII Art) Visual representation of P/L across stock prices: def generate_pnl_diagram ( price_range , pnl_values , current_price , width = 60 , height = 15 ) : """Generate ASCII P/L diagram"""

Normalize to chart dimensions

max_pnl

max ( pnl_values ) min_pnl = min ( pnl_values ) lines = [ ] lines . append ( f"\nP/L Diagram: { strategy_name } " ) lines . append ( "-" * width )

Y-axis levels

levels

np . linspace ( max_pnl , min_pnl , height ) for level in levels : if abs ( level ) < ( max_pnl - min_pnl ) * 0.05 : label = f" 0 |"

Zero line

else : label = f" { level : 6.0f } |" row = label for i in range ( width - len ( label ) ) : idx = int ( i / ( width - len ( label ) ) * len ( price_range ) ) pnl = pnl_values [ idx ] price = price_range [ idx ]

Determine character

if abs ( pnl - level ) < ( max_pnl - min_pnl ) / height : if pnl

0 : char = '█'

Profit

elif pnl < 0 : char = '░'

Loss

else : char = '─'

Breakeven

elif abs ( level ) < ( max_pnl - min_pnl ) * 0.05 : char = '─'

Zero line

elif abs ( price - current_price ) < ( price_range [ - 1 ] - price_range [ 0 ] ) * 0.02 : char = '│'

Current price line

else : char = ' ' row += char lines . append ( row ) lines . append ( " " * 6 + "|" + "-" * ( width - 6 ) ) lines . append ( " " * 6 + f"$ { price_range [ 0 ] : .0f } " + " " * ( width - 20 ) + f"$ { price_range [ - 1 ] : .0f } " ) lines . append ( " " * ( width // 2 - 5 ) + "Stock Price" ) return "\n" . join ( lines ) Example Output: P/L Diagram: Bull Call Spread $180/$185

+2500 | ████████████████████ | ██████ | ██████ | ██████ 0 | ────── | ░░░░░░ |░░░░░░ -2500 |░░░░░ |____________ $126 $180 $234 Stock Price Legend: █ Profit ░ Loss ── Breakeven │ Current Price Step 7: Strategy-Specific Analysis Provide tailored guidance based on strategy type: Covered Call: Income Strategy: Generate premium while capping upside Setup: - Own 100 shares of AAPL @ $180 - Sell 1x $185 call (30 DTE) for $3.50 Max Profit: $850 (Stock at $185+ = $5 stock gain + $3.50 premium) Max Loss: Unlimited downside (stock ownership) Breakeven: $176.50 (Cost basis - premium received) Greeks: - Delta: -0.30 (reduces stock delta from 1.00 to 0.70) - Theta: +$8/day (time decay benefit) Assignment Risk: If AAPL > $185 at expiration, shares called away When to Use: - Neutral to slightly bullish - Want income in sideways market - Willing to sell stock at $185 Exit Plan: - Buy back call if stock rallies strongly (preserve upside) - Let expire if stock stays below $185 - Roll to next month if want to keep shares Protective Put: Insurance Strategy: Limit downside while keeping upside Setup: - Own 100 shares of AAPL @ $180 - Buy 1x $175 put (30 DTE) for $2.00 Max Profit: Unlimited (stock can rise infinitely) Max Loss: -$7 per share = ($5 stock loss + $2 premium) Breakeven: $182 (Cost basis + premium paid) Greeks: - Delta: +0.80 (stock delta 1.00 - put delta 0.20) - Theta: -$6/day (time decay cost) Protection: Guaranteed to sell at $175, no matter how far stock falls When to Use: - Own stock, worried about short-term drop - Earnings coming up, want protection - Alternative to stop-loss (can't be stopped out) Cost: "Insurance premium" - typically 1-3% of stock value Exit Plan: - Let expire worthless if stock rises (cost of insurance) - Exercise put if stock falls below $175 - Sell put if stock drops but want to keep shares Iron Condor: Range-Bound Strategy: Profit from low volatility Setup (example on AAPL @ $180): - Sell $175 put for $1.50 - Buy $170 put for $0.50 - Sell $185 call for $1.50 - Buy $190 call for $0.50 Net Credit: $2.00 ($200 per iron condor) Max Profit: $200 (if stock stays between $175-$185) Max Loss: $300 (if stock moves outside $170-$190) Breakevens: $173 and $187 Profit Range: $175 to $185 (58% probability) Greeks: - Delta: ~0 (market neutral) - Theta: +$15/day (time decay benefit) - Vega: -$25 (short volatility) When to Use: - Expect low volatility, range-bound movement - After big move, think consolidation - High IV environment (sell expensive options) Risk: Unlimited if one side tested - Use stop loss at 2x credit received (exit at -$400) Adjustments: - If tested on one side, roll that side out in time - Close early at 50% max profit to reduce tail risk Step 8: Earnings Strategy Analysis Integration with Earnings Calendar: When user asks about earnings strategies, fetch earnings date: from earnings_calendar import get_next_earnings_date earnings_date = get_next_earnings_date ( "AAPL" ) days_to_earnings = ( earnings_date - today ) . days Pre-Earnings Strategies: Long Straddle/Strangle: Setup (AAPL @ $180, earnings in 7 days): - Buy $180 call for $5.00 - Buy $180 put for $4.50 - Total Cost: $9.50 Thesis: Expect big move (>5%) but unsure of direction Breakevens: $170.50 and $189.50 Profit if: Stock moves >$9.50 in either direction Greeks: - Delta: ~0 (neutral) - Vega: +$50 (long volatility) - Theta: -$25/day (time decay hurts) IV Crush Risk: ⚠️ CRITICAL - Pre-earnings IV: 40% (elevated) - Post-earnings IV: 25% (typical) - IV drop: -15 points = -$750 loss even if stock doesn't move! Analysis: - Implied Move: √(DTE/365) × IV × Stock Price = √(7/365) × 0.40 × 180 = ±$10.50 - Breakeven Move Needed: ±$9.50 - Probability Profit: ~30-40% (implied move > breakeven move) Recommendation: ✅ Consider if you expect >10% move (larger than implied) ❌ Avoid if expect normal ~5% earnings move (IV crush will hurt) Alternative: Buy further OTM strikes to reduce cost - $175/$185 strangle cost $4.00 (need >$8 move, but cheaper) Short Iron Condor: Setup (AAPL @ $180, earnings in 7 days): - Sell $170/$175 put spread for $2.00 - Sell $185/$190 call spread for $2.00 - Net Credit: $4.00 Thesis: Expect stock to stay range-bound ($175-$185) Profit Zone: $175 to $185 Max Profit: $400 Max Loss: $100 IV Crush Benefit: ✅ - Short high IV before earnings - IV drops after earnings → profit on vega - Even if stock moves slightly, IV drop helps Greeks: - Delta: ~0 (market neutral) - Vega: -$40 (short volatility - good here!) - Theta: +$20/day Recommendation: ✅ Good if expect normal earnings reaction (<8% move) ✅ Benefit from IV crush regardless of direction ⚠️ Risk if stock gaps outside range (>10% move) Exit Plan: - Close next day if IV crushed (capture profit early) - Use stop loss if one side tested (-2x credit) Step 9: Risk Management Guidance Position Sizing: Account Size: $50,000 Risk Tolerance: 2% per trade = $1,000 max risk Iron Condor Example: - Max loss per spread: $300 - Max contracts: $1,000 / $300 = 3 contracts - Actual position: 3 iron condors Bull Call Spread Example: - Debit paid: $2.50 per spread - Max contracts: $1,000 / $250 = 4 contracts - Actual position: 4 spreads Portfolio Greeks Management: Portfolio Guidelines: - Delta: -10 to +10 (mostly neutral) - Theta: Positive preferred (seller advantage) - Vega: Monitor if >$500 (IV risk) Current Portfolio: - Delta: +5 (slightly bullish) - Theta: +$150/day (collecting $150 daily) - Vega: -$300 (short volatility) Interpretation: ✅ Neutral delta (safe) ✅ Positive theta (time working for you) ⚠️ Short vega: If IV spikes, lose $300 per 1% IV increase → Reduce short premium positions if VIX rising Adjustments and Exits: Exit Rules by Strategy: Covered Call: - Profit: 50-75% of max profit - Loss: Stock drops >5%, buy back call to preserve upside - Time: 7-10 DTE, roll to avoid assignment Spreads: - Profit: 50% of max profit (close early, reduce tail risk) - Loss: 2x debit paid (cut losses early) - Time: 21 DTE, close or roll (avoid gamma risk) Iron Condor: - Profit: 50% of credit (close early common) - Loss: One side tested, 2x credit lost - Adjustment: Roll tested side out in time Straddle/Strangle: - Profit: Stock moved >breakeven, close immediately - Loss: Theta eating position, stock not moving - Time: Day after earnings (if earnings play) Output Format Strategy Analysis Report Template:

Options Strategy Analysis: [Strategy Name] ** Symbol: ** [TICKER] ** Strategy: ** [Strategy Type] ** Expiration: ** [Date] ([DTE] days) ** Contracts: ** [Number]

Strategy Setup

|

| | 1 | Call | $180 | $5.00 | Long | 1 | | 2 | Call | $185 | $2.50 | Short | 1 | ** Net Debit/Credit: ** $2.50 debit ($250 total for 1 spread)

Profit/Loss Analysis ** Max Profit: ** $250 (at $185+) ** Max Loss: ** -$250 (at $180-) ** Breakeven: ** $182.50 ** Risk/Reward Ratio: ** 1:1 ** Probability Analysis: ** - Probability of Profit: ~55% (stock above $182.50) - Expected Value: $25 (simplified)

P/L Diagram [ASCII art diagram here]

Greeks Analysis

Position Greeks (1 spread)

** Delta: ** +0.20 (gains $20 if stock +$1) - ** Gamma: ** +0.03 (delta increases by 0.03 if stock +$1) - ** Theta: ** -$5/day (loses $5 per day from time decay) - ** Vega: ** +$8 (gains $8 if IV increases 1%)

Interpretation

** Directional Bias: ** Slightly bullish (positive delta) - ** Time Decay: ** Working against you (negative theta) - ** Volatility: ** Benefits from IV increase (positive vega)

Risk Assessment

Maximum Risk ** Scenario: ** Stock falls below $180 ** Max Loss: ** -$250 (100% of premium paid) ** % of Account: ** 0.5% (if $50k account)

Assignment Risk ** Early Assignment: ** Low (calls have time value) ** At Expiration: ** Manage positions if in-the-money

Trade Management

Entry ✅ Enter if: [Conditions] - Stock price $178-$182 - IV below 30% -

21 DTE

Profit Taking

** Target 1: ** 50% profit ($125) - Close half - ** Target 2: ** 75% profit ($187.50) - Close all

Stop Loss

** Trigger: ** Stock falls below $177 (-$150 loss) - ** Action: ** Close position immediately

Adjustments

If stock rallies to $184, consider rolling short call higher

If stock drops to $179, add second spread at $175/$180

Suitability

When to Use This Strategy ✅ Moderately bullish on AAPL ✅ Expect upside to $185-$190 ✅ Want defined risk ✅ 21-45 DTE timeframe

When to Avoid ❌ Very bullish (buy stock or long call instead) ❌ High IV environment (wait for IV to drop) ❌ Earnings in <7 days (IV crush risk)

|

* Disclaimer: This is theoretical analysis using Black-Scholes pricing. Actual market prices may differ. Trade at your own risk. Options are complex instruments with significant loss potential. * File Naming Convention: options_analysis_[TICKER][STRATEGY][DATE].md Example: options_analysis_AAPL_BullCallSpread_2025-11-08.md Key Principles Theoretical Pricing Limitations What Users Should Know: Black-Scholes Assumptions: European-style options (can't exercise early) Constant volatility (IV changes in reality) No transaction costs Continuous trading Real vs Theoretical: Bid-ask spread: Actual cost higher than theoretical American options: Can be exercised early (especially ITM puts) Liquidity: Wide markets on illiquid options Dividends: Ex-dividend dates affect pricing Best Practices: Use as educational tool and comparative analysis Get real quotes from broker before trading Understand theoretical price ≈ mid-market price Account for commissions and slippage Volatility Guidance Historical vs Implied Volatility: Historical Volatility (HV): What happened - Calculated from past price movements - Objective, based on data - Available for free (FMP API) Implied Volatility (IV): What market expects - Derived from option prices - Subjective, based on supply/demand - Requires live options data (user provides) Comparison: - IV > HV: Options expensive (consider selling) - IV < HV: Options cheap (consider buying) - IV = HV: Fairly priced IV Percentile: User provides current IV, we calculate percentile:

Fetch 1-year HV data

historical_hvs

calculate_hv_series ( prices_1yr , window = 30 )

Calculate IV percentile

iv_percentile

percentileofscore

(

historical_hvs

,

current_iv

)

if

iv_percentile

>

75

:

guidance

=

"High IV - consider selling premium (credit spreads, iron condors)"

elif

iv_percentile

<

25

:

guidance

=

"Low IV - consider buying options (long calls/puts, debit spreads)"

else

:

guidance

=

"Normal IV - any strategy appropriate"

Integration with Other Skills

Earnings Calendar:

Fetch earnings dates automatically

Suggest earnings-specific strategies

Calculate days to earnings (DTE critical for IV)

Warn about IV crush risk

Technical Analyst:

Use support/resistance for strike selection

Trend analysis for directional strategies

Breakout potential for straddle/strangle timing

US Stock Analysis:

Fundamental analysis for longer-term strategies (LEAPS)

Dividend yield for covered call/put analysis

Earnings quality for earnings plays

Bubble Detector:

High bubble risk → focus on protective puts

Low risk → bullish strategies

Critical risk → avoid long premium (theta hurts)

Portfolio Manager:

Track options positions alongside stock positions

Aggregate Greeks across portfolio

Options as hedging tool for stock positions

Important Notes

All analysis in English

Educational focus

Strategies explained clearly

Theoretical pricing

Black-Scholes approximation

User IV input

Optional, defaults to HV

No real-time data required

FMP Free tier sufficient

Dependencies

Python 3.8+, numpy, scipy, pandas

Common Use Cases

Use Case 1: Learn Strategy

User: "Explain a covered call"

Workflow:

1. Load strategy reference (references/strategies_guide.md)

2. Explain concept, risk/reward, when to use

3. Simulate example on AAPL

4. Show P/L diagram

5. Compare to alternatives

Use Case 2: Analyze Specific Trade

User: "Analyze $180/$185 bull call spread on AAPL, 30 days"

Workflow:

1. Fetch AAPL price from FMP

2. Calculate HV or ask user for IV

3. Price both options (Black-Scholes)

4. Calculate Greeks

5. Simulate P/L

6. Generate analysis report

Use Case 3: Earnings Strategy

User: "Should I trade options before NVDA earnings?"

Workflow:

1. Fetch NVDA earnings date (Earnings Calendar)

2. Calculate days to earnings

3. Estimate IV percentile (if user provides IV)

4. Suggest straddle/strangle vs iron condor

5. Warn about IV crush

6. Simulate both strategies

Use Case 4: Portfolio Greeks Check

User: "What are my total portfolio Greeks?"

Workflow:

1. User provides current positions

2. Calculate Greeks for each position

3. Sum Greeks across portfolio

4. Assess overall exposure

5. Suggest adjustments if needed

Troubleshooting

Problem: IV not available

Solution: Use HV as proxy, note to user

Ask user to provide IV from broker platform

Problem: Negative option price

Solution: Check inputs (strike vs stock price)

Deep ITM options may have numerical issues

Problem: Greeks seem wrong

Solution: Verify inputs (T, sigma, r)

Check if using annual vs daily values

Problem: Strategy too complex

Solution: Break into legs, analyze separately

Refer to references for strategy details

Resources

References:

references/black_scholes_methodology.md

- Black-Scholes formulas, Greeks, and interpretation

references/strategies_guide.md

- All 17+ strategies explained (future)

references/greeks_explained.md

- Greeks deep dive (future)

references/volatility_guide.md

- HV vs IV, when to trade (future)

Scripts:

scripts/black_scholes.py

- Pricing engine and Greeks

scripts/strategy_analyzer.py

- Strategy simulation

scripts/earnings_strategy.py

- Earnings-specific analysis

External Resources:

Options Playbook:

https://www.optionsplaybook.com/

CBOE Education:

https://www.cboe.com/education/

Black-Scholes Calculator: Various online tools for verification

Version

1.0

Last Updated

2025-11-08

Dependencies

Python 3.8+, numpy, scipy, pandas, requests
API: FMP API (Free tier sufficient)

安装

Basic call option pricing (no API key needed)

With FMP API key for real-time data

Custom option parameters

Put option analysis

Fetch 90 days of price data

prices

Calculate daily returns

returns

Annualized volatility

HV

252 trading days

Per day

Per 1%

Per 1%

Example: Bull Call Spread

Long 1x $180 call

Short 1x $185 call

delta_position

put

intrinsic_value

Per contract

short

Normalize to chart dimensions

max_pnl

Y-axis levels

levels

Zero line

Determine character

Profit

Loss

Breakeven

Zero line

Current price line

|

|

|

|

|

Position Greeks (1 spread)

Interpretation

Profit Taking

Stop Loss

Adjustments

If stock rallies to $184, consider rolling short call higher

If stock drops to $179, add second spread at $175/$180

|

|

|

|

Fetch 1-year HV data

historical_hvs

Calculate IV percentile

iv_percentile