options-strategy-advisor

$29

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^(-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 + 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

### Leg Details

| Leg | Type | Strike | Price | Position | Quantity |

|-----|------|--------|-------|----------|----------|

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

---

## Alternatives Comparison

| Strategy | Max Profit | Max Loss | Complexity | When Better |

|----------|-----------|----------|------------|-------------|

| Bull Call Spread | $250 | -$250 | Medium | Moderately bullish |

| Long Call | Unlimited | -$500 | Low | Very bullish |

| Covered Call | $850 | Unlimited | Medium | Own stock already |

| Bull Put Spread | $300 | -$200 | Medium | Want credit spread |

**Recommendation:** Bull call spread is good balance of risk/reward for moderate bullish thesis.

---

*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)