Build an OpenClaw Vig Calculator Skill — Measure Sportsbook Juice & Hold Percentage

mkdir -p ~/.openclaw/skills/vig-calculator

---
name: vig-calculator
description: "Calculate vig (juice/overround/hold) for any sportsbook market. Convert odds to no-vig fair lines. Rank books by efficiency. Use when asked about vig, juice, hold percentage, overround, or sportsbook sharpness."
metadata:
  openclaw:
    emoji: "🧮"
    requires:
      bins: ["python3"]
---

# Vig Calculator

Calculate the vig (juice/overround) for any sportsbook market and rank books by efficiency.

# When to Use

Use this skill when the user asks about:
- Vig, juice, or overround on a market
- Hold percentage for a sportsbook
- Removing vig to find fair/true odds
- Ranking sportsbooks by efficiency or sharpness
- Which book has the lowest juice
- The AgentBets Vig Index

# Operations

### 1. Calculate Vig for a Two-Way Market

Given American odds for both sides:

```python
python3 -c "
import sys
odds = [int(x) for x in sys.argv[1:]]
probs = []
for o in odds:
    if o < 0:
        probs.append(abs(o) / (abs(o) + 100))
    else:
        probs.append(100 / (o + 100))
total = sum(probs)
vig = (total - 1) * 100
hold = (1 - 1/total) * 100
print(f'Implied probs: {[round(p*100,2) for p in probs]}%')
print(f'Sum: {round(total*100,2)}%')
print(f'Vig (overround): {round(vig,2)}%')
print(f'Hold: {round(hold,2)}%')
fair = [round(p/total*100,2) for p in probs]
print(f'No-vig fair probs: {fair}%')
" ODDS_SIDE_A ODDS_SIDE_B
```

Replace ODDS_SIDE_A and ODDS_SIDE_B with the American odds (e.g., -110 -110, or -150 +130).

For multi-way markets (3+ outcomes like moneyline in a 3-way soccer match), add more odds as arguments.

### 2. Convert to No-Vig Fair Odds

Remove the vig and return fair American odds:

```python
python3 -c "
import sys
odds = [int(x) for x in sys.argv[1:]]
probs = []
for o in odds:
    if o < 0:
        probs.append(abs(o) / (abs(o) + 100))
    else:
        probs.append(100 / (o + 100))
total = sum(probs)
print('Fair odds (vig removed):')
for i, p in enumerate(probs):
    fair_p = p / total
    if fair_p >= 0.5:
        fair_american = round(-100 * fair_p / (1 - fair_p))
    else:
        fair_american = round(100 * (1 - fair_p) / fair_p)
    print(f'  Side {i+1}: {odds[i]} -> fair {fair_american:+d} (true prob {round(fair_p*100,1)}%)')
" ODDS_SIDE_A ODDS_SIDE_B
```

### 3. Rank Sportsbooks by Hold (Requires odds-scanner)

When the user has odds data from odds-scanner, calculate hold per book:

```python
python3 -c "
import json, sys
data = json.loads(sys.stdin.read())
book_vigs = {}
for game in data:
    for book in game.get('books', []):
        name = book['name']
        h2h = book.get('h2h', {})
        if h2h and len(h2h) >= 2:
            odds = list(h2h.values())
            probs = []
            for o in odds:
                if o < 0:
                    probs.append(abs(o) / (abs(o) + 100))
                else:
                    probs.append(100 / (o + 100))
            total = sum(probs)
            hold = (1 - 1/total) * 100
            book_vigs.setdefault(name, []).append(hold)
print('Sportsbook Rankings (lowest hold = sharpest):')
print('-' * 50)
rankings = []
for name, holds in book_vigs.items():
    avg = sum(holds) / len(holds)
    rankings.append((name, avg, len(holds)))
for rank, (name, avg, n) in enumerate(sorted(rankings, key=lambda x: x[1]), 1):
    print(f'{rank}. {name}: {avg:.2f}% avg hold ({n} markets)')
"
```

Pipe odds-scanner JSON output into this command.

### 4. Generate Vig Index Snapshot

Summarize the current vig landscape for a sport:

```python
python3 -c "
import json, sys
from datetime import datetime
data = json.loads(sys.stdin.read())
book_vigs = {}
for game in data:
    for book in game.get('books', []):
        name = book['name']
        h2h = book.get('h2h', {})
        if h2h and len(h2h) >= 2:
            odds = list(h2h.values())
            probs = [abs(o)/(abs(o)+100) if o < 0 else 100/(o+100) for o in odds]
            total = sum(probs)
            hold = (1 - 1/total) * 100
            book_vigs.setdefault(name, []).append(hold)
print(f'=== VIG INDEX SNAPSHOT — {datetime.now().strftime(\"%Y-%m-%d %H:%M\")} ===')
print()
rankings = sorted(
    [(n, sum(h)/len(h), min(h), max(h), len(h)) for n, h in book_vigs.items()],
    key=lambda x: x[1]
)
for name, avg, low, high, n in rankings:
    bar = '█' * int(avg * 4)
    print(f'{name:<20} avg {avg:5.2f}%  range [{low:.1f}%-{high:.1f}%]  {bar}  ({n} mkts)')
print()
market_avg = sum(r[1] for r in rankings) / len(rankings) if rankings else 0
print(f'Market average hold: {market_avg:.2f}%')
sharpest = rankings[0][0] if rankings else 'N/A'
print(f'Sharpest book today: {sharpest}')
"
```

# Output Rules

1. Always show vig as a percentage with two decimal places
2. Show both vig (overround) and hold percentage — they differ slightly
3. When ranking books, sort from lowest hold (sharpest) to highest
4. Include the number of markets sampled per book
5. For no-vig fair odds, show original → fair with true probability
6. Flag any market with vig > 8% as "high juice — consider another book"

# Error Handling

- If the user provides only one side of odds, ask for the other side
- If odds are in decimal or fractional format, convert to American first
- If hold comes out negative (which shouldn't happen with real odds), flag as likely data error
- If chaining with odds-scanner and no data is returned, the sport may be out of season

{
  "cron": "0 */6 * * *",
  "prompt": "Run the vig index snapshot for NFL, NBA, and MLB. Append results to ~/openclaw-data/vig-history.jsonl with today's date."
}

{
  "cron": "*/15 * * * *",
  "prompt": "Check NBA odds. If any sportsbook's average hold drops below 2%, alert me on Telegram with the book name and current hold."
}