Finance News

{
  "rss_feeds": {
    "wsj": {
      "name": "Wall Street Journal",
      "enabled": true,
      "markets": "https://feeds.content.dowjones.io/public/rss/RSSMarketsMain",
      "daily": "https://feeds.content.dowjones.io/public/rss/RSSWSJD"
    },
    "tagesschau": {
      "name": "Tagesschau",
      "enabled": true,
      "wirtschaft": "https://www.tagesschau.de/wirtschaft/weltwirtschaft/index~rss2.xml"
    },
    "finanzen_net": {
      "name": "Finanzen.net",
      "enabled": true,
      "news": "https://www.finanzen.net/rss/news"
    },
    "handelsblatt": {
      "name": "Handelsblatt",
      "enabled": true,
      "finanzen": "https://feeds.cms.handelsblatt.com/finanzen"
    },
    "zeit": {
      "name": "ZEIT Wirtschaft",
      "enabled": true,
      "wirtschaft": "https://newsfeed.zeit.de/wirtschaft/index"
    },
    "marketwatch": {
      "name": "MarketWatch",
      "enabled": true,
      "topstories": "https://feeds.content.dowjones.io/public/rss/mw_topstories"
    },
    "reuters": {
      "name": "Reuters",
      "enabled": true,
      "markets": "https://news.google.com/rss/search?q=site%3Areuters.com+markets+OR+stocks+OR+economy+OR+fed+OR+earnings&hl=en-US&gl=US&ceid=US%3Aen",
      "note": "Google News RSS wrapper for Reuters - filtered for finance/markets."
    },
    "ft": {
      "name": "Financial Times",
      "enabled": true,
      "markets": "https://www.ft.com/markets?format=rss"
    },
    "bloomberg": {
      "name": "Bloomberg",
      "enabled": true,
      "markets": "https://feeds.bloomberg.com/markets/news.rss"
    },
    "barrons": {
      "name": "Barron's",
      "enabled": false,
      "main": "https://www.barrons.com/market-data/rss/articles",
      "note": "Requires subscription - enable after adding credentials"
    },
    "cnbc": {
      "name": "CNBC",
      "enabled": true,
      "top": "https://search.cnbc.com/rs/search/combinedcms/view.xml?partnerId=wrss01&id=10001147",
      "business": "https://search.cnbc.com/rs/search/combinedcms/view.xml?partnerId=wrss01&id=15839069",
      "markets": "https://search.cnbc.com/rs/search/combinedcms/view.xml?partnerId=wrss01&id=20910258",
      "world": "https://search.cnbc.com/rs/search/combinedcms/view.xml?partnerId=wrss01&id=10000664",
      "tech": "https://www.cnbc.com/id/19854910/device/rss/rss.html"
    },
    "yahoo": {
      "name": "Yahoo Finance",
      "enabled": true,
      "top": "https://finance.yahoo.com/rss/topstories"
    }
  },
  "headline_sources": ["reuters", "wsj", "ft", "bloomberg", "marketwatch", "cnbc", "yahoo"],
  "headline_sources_by_lang": {
    "de": ["tagesschau", "handelsblatt", "zeit", "finanzen_net", "reuters", "wsj", "ft", "bloomberg", "marketwatch", "cnbc", "yahoo"],
    "en": ["reuters", "wsj", "ft", "bloomberg", "marketwatch", "cnbc", "yahoo"]
  },
  "headline_exclude": [],
  "source_weights": {
    "reuters": 5,
    "wsj": 4,
    "ft": 4,
    "bloomberg": 3,
    "marketwatch": 3,
    "cnbc": 2,
    "tagesschau": 4,
    "handelsblatt": 4,
    "zeit": 4,
    "finanzen_net": 3,
    "yahoo": 1
  },
  "source_tiers": {
    "paid": ["wsj", "ft", "barrons"],
    "free": ["bloomberg", "marketwatch", "yahoo", "cnbc", "tagesschau", "handelsblatt", "zeit", "finanzen_net"]
  },
  "headline_shortlist_size_by_lang": {
    "de": 30,
    "en": 20
  },
  "portfolio_deadline_sec": 360,
  "portfolio": {
    "briefing_limit": 10,
    "prioritization_enabled": true,
    "prioritization_weights": {
      "type": 0.40,
      "volatility": 0.35,
      "news_volume": 0.25
    }
  },
  "markets": {
    "us": {
      "name": "US Markets",
      "enabled": true,
      "indices": ["^GSPC", "^DJI", "^IXIC"],
      "index_names": {"^GSPC": "S&P 500", "^DJI": "Dow Jones", "^IXIC": "NASDAQ"}
    },
    "europe": {
      "name": "Europe",
      "enabled": true,
      "indices": ["^GDAXI", "^STOXX50E", "^FTSE"],
      "index_names": {"^GDAXI": "DAX", "^STOXX50E": "STOXX 50", "^FTSE": "FTSE 100"}
    },
    "japan": {
      "name": "Japan",
      "enabled": true,
      "indices": ["^N225"],
      "index_names": {"^N225": "Nikkei 225"}
    }
  },
  "language": {
    "default": "en",
    "supported": ["en", "de"]
  },
  "delivery": {
    "whatsapp": {
      "enabled": true,
      "group": ""
    },
    "telegram": {
      "enabled": false,
      "group": ""
    }
  },
  "schedule": {
    "morning": {
      "enabled": true,
      "cron": "30 6 * * 1-5",
      "timezone": "America/Los_Angeles",
      "description": "US Market Open (9:30 AM ET = 6:30 AM PT)"
    },
    "evening": {
      "enabled": true,
      "cron": "0 13 * * 1-5",
      "timezone": "America/Los_Angeles",
      "description": "US Market Close (4:00 PM ET = 1:00 PM PT)"
    }
  },
  "llm": {
    "headline_model_order": ["gemini", "minimax", "claude"],
    "summary_model_order": ["gemini", "minimax", "claude"],
    "translation_model_order": ["gemini", "minimax", "claude"]
  },
  "translations": {
    "en": {
      "title_morning": "Morning Briefing",
      "title_evening": "Evening Briefing",
      "title_prefix": "Market",
      "time_suffix": "",
      "heading_briefing": "Market Briefing",
      "heading_markets": "Markets",
      "heading_sentiment": "Sentiment",
      "heading_top_headlines": "Top 5 Headlines",
      "heading_portfolio_impact": "Portfolio Impact",
      "heading_portfolio_movers": "Portfolio Movers",
      "heading_watchpoints": "Watchpoints",
      "no_data": "No data available",
      "no_movers": "No significant moves (±1%)",
      "follows_market": " -- follows market",
      "no_catalyst": " -- no specific catalyst",
      "rec_bullish": "Selective opportunities, keep risk management tight.",
      "rec_bearish": "Reduce risk and prioritize liquidity.",
      "rec_neutral": "Wait-and-see, focus on quality names.",
      "rec_unknown": "No clear recommendation without reliable data.",
      "sources_header": "Sources",
      "sentiment_map": {
        "Bullish": "Bullish",
        "Bearish": "Bearish",
        "Neutral": "Neutral",
        "No data available": "No data available"
      }
    },
    "de": {
      "title_morning": "Morgen-Briefing",
      "title_evening": "Abend-Briefing",
      "title_prefix": "Börsen",
      "time_suffix": "Uhr",
      "heading_briefing": "Marktbriefing",
      "heading_markets": "Märkte",
      "heading_sentiment": "Stimmung",
      "heading_top_headlines": "Top 5 Schlagzeilen",
      "heading_portfolio_impact": "Portfolio-Auswirkung",
      "heading_portfolio_movers": "Portfolio-Bewegungen",
      "heading_watchpoints": "Beobachtungspunkte",
      "no_data": "Keine Daten verfügbar",
      "no_movers": "Keine deutlichen Bewegungen (±1%)",
      "follows_market": " -- folgt dem Markt",
      "no_catalyst": " -- kein spezifischer Katalysator",
      "rec_bullish": "Chancen selektiv nutzen, aber Risikomanagement beibehalten.",
      "rec_bearish": "Risiken reduzieren und Liquidität priorisieren.",
      "rec_neutral": "Abwarten und Fokus auf Qualitätstitel.",
      "rec_unknown": "Keine klare Empfehlung ohne belastbare Daten.",
      "sources_header": "Quellen",
      "sentiment_map": {
        "Bullish": "Bullisch",
        "Bearish": "Bärisch",
        "Neutral": "Neutral",
        "No data available": "Keine Daten verfügbar"
      },
      "months": {
        "January": "Januar",
        "February": "Februar",
        "March": "März",
        "April": "April",
        "May": "Mai",
        "June": "Juni",
        "July": "Juli",
        "August": "August",
        "September": "September",
        "October": "Oktober",
        "November": "November",
        "December": "Dezember"
      },
      "days": {
        "Monday": "Montag",
        "Tuesday": "Dienstag",
        "Wednesday": "Mittwoch",
        "Thursday": "Donnerstag",
        "Friday": "Freitag",
        "Saturday": "Samstag",
        "Sunday": "Sonntag"
      }
    }
  }
}

{
  "_comment": "Manual earnings dates for stocks not covered by Finnhub API",
  "_updated": "2026-01-27",
  "6857.T": {
    "date": "2026-01-27",
    "time": "amc",
    "note": "Q3 FY2025 - Advantest",
    "source": "marketscreener.com"
  },
  "6920.T": {
    "date": "2026-02-02",
    "time": "amc",
    "note": "Q3 FY2025 - Lasertec",
    "source": "tipranks.com"
  },
  "8035.T": {
    "date": "2026-02-05",
    "time": "amc",
    "note": "Q3 FY2025 - Tokyo Electron",
    "source": "tipranks.com"
  },
  "6146.T": {
    "date": "2026-02-06",
    "time": "amc",
    "note": "Q3 FY2025 - Disco Corp",
    "source": "estimate"
  },
  "7741.T": {
    "date": "2026-01-30",
    "time": "amc",
    "note": "Q3 FY2025 - Hoya",
    "source": "estimate"
  },
  "7735.T": {
    "date": "2026-01-30",
    "time": "amc",
    "note": "Q3 FY2025 - Screen Holdings",
    "source": "estimate"
  },
  "4063.T": {
    "date": "2026-01-31",
    "time": "amc",
    "note": "Q3 FY2025 - Shin-Etsu Chemical",
    "source": "estimate"
  },
  "6861.T": {
    "date": "2026-01-29",
    "time": "amc",
    "note": "Q3 FY2025 - Keyence",
    "source": "estimate"
  },
  "9984.T": {
    "date": "2026-02-07",
    "time": "amc",
    "note": "Q3 FY2025 - SoftBank Group",
    "source": "estimate"
  },
  "9983.T": {
    "date": "2026-01-09",
    "time": "amc",
    "note": "Q1 FY2026 - Fast Retailing (Uniqlo)",
    "source": "estimate"
  },
  "D05.SI": {
    "date": "2026-02-10",
    "time": "bmo",
    "note": "Q4 2025 - DBS Group",
    "source": "estimate"
  },
  "O39.SI": {
    "date": "2026-02-21",
    "time": "bmo",
    "note": "Q4 2025 - OCBC Bank",
    "source": "estimate"
  },
  "S68.SI": {
    "date": "2026-01-23",
    "time": "bmo",
    "note": "H1 FY2026 - Singapore Exchange",
    "source": "estimate"
  },
  "AAPL": {
    "date": "2026-01-30",
    "time": "amc",
    "note": "Q1 FY2026"
  },
  "MSFT": {
    "date": "2026-01-29",
    "time": "amc",
    "note": "Q2 FY2026"
  },
  "META": {
    "date": "2026-01-29",
    "time": "amc",
    "note": "Q4 2025"
  },
  "TSLA": {
    "date": "2026-01-29",
    "time": "amc",
    "note": "Q4 2025"
  },
  "NVDA": {
    "date": "2026-02-25",
    "time": "amc",
    "note": "Q4 FY2026"
  },
  "GOOGL": {
    "date": "2026-02-04",
    "time": "amc",
    "note": "Q4 2025"
  },
  "AMZN": {
    "date": "2026-02-06",
    "time": "amc",
    "note": "Q4 2025"
  },
  "NFLX": {
    "date": "2026-01-21",
    "time": "amc",
    "note": "Q4 2025"
  },
  "V": {
    "date": "2026-01-30",
    "time": "amc",
    "note": "Q1 FY2026"
  },
  "MA": {
    "date": "2026-01-30",
    "time": "bmo",
    "note": "Q4 2025"
  },
  "ASML": {
    "date": "2026-01-29",
    "time": "bmo",
    "note": "Q4 2025"
  },
  "NOW": {
    "date": "2026-01-29",
    "time": "amc",
    "note": "Q4 2025"
  },
  "UBER": {
    "date": "2026-02-05",
    "time": "bmo",
    "note": "Q4 2025"
  },
  "SHOP": {
    "date": "2026-02-11",
    "time": "bmo",
    "note": "Q4 2025"
  },
  "SPOT": {
    "date": "2026-02-04",
    "time": "bmo",
    "note": "Q4 2025"
  },
  "NET": {
    "date": "2026-02-06",
    "time": "amc",
    "note": "Q4 2025"
  },
  "SNOW": {
    "date": "2026-02-26",
    "time": "amc",
    "note": "Q4 FY2026"
  },
  "DKNG": {
    "date": "2026-02-13",
    "time": "bmo",
    "note": "Q4 2025"
  },
  "SQ": {
    "date": "2026-02-20",
    "time": "amc",
    "note": "Q4 2025"
  },
  "ABNB": {
    "date": "2026-02-13",
    "time": "amc",
    "note": "Q4 2025"
  },
  "TEAM": {
    "date": "2026-01-30",
    "time": "amc",
    "note": "Q2 FY2026"
  },
  "ZS": {
    "date": "2026-02-25",
    "time": "amc",
    "note": "Q2 FY2026"
  },
  "FTNT": {
    "date": "2026-02-06",
    "time": "amc",
    "note": "Q4 2025"
  },
  "WDAY": {
    "date": "2026-02-27",
    "time": "amc",
    "note": "Q4 FY2026"
  },
  "TTD": {
    "date": "2026-02-13",
    "time": "amc",
    "note": "Q4 2025"
  },
  "WMT": {
    "date": "2026-02-19",
    "time": "bmo",
    "note": "Q4 FY2026"
  },
  "EA": {
    "date": "2026-02-03",
    "time": "amc",
    "note": "Q3 FY2026"
  },
  "ADSK": {
    "date": "2026-02-26",
    "time": "amc",
    "note": "Q4 FY2026"
  },
  "ROKU": {
    "date": "2026-02-13",
    "time": "amc",
    "note": "Q4 2025"
  },
  "SNAP": {
    "date": "2026-02-04",
    "time": "amc",
    "note": "Q4 2025"
  },
  "ETSY": {
    "date": "2026-02-19",
    "time": "amc",
    "note": "Q4 2025"
  },
  "KO": {
    "date": "2026-02-11",
    "time": "bmo",
    "note": "Q4 2025"
  },
  "BLK": {
    "date": "2026-01-15",
    "time": "bmo",
    "note": "Q4 2025"
  },
  "PH": {
    "date": "2026-01-30",
    "time": "bmo",
    "note": "Q2 FY2026"
  },
  "SYK": {
    "date": "2026-01-28",
    "time": "bmo",
    "note": "Q4 2025"
  },
  "TJX": {
    "date": "2026-02-26",
    "time": "bmo",
    "note": "Q4 FY2026"
  },
  "ROST": {
    "date": "2026-03-04",
    "time": "amc",
    "note": "Q4 FY2026"
  },
  "ORLY": {
    "date": "2026-02-05",
    "time": "amc",
    "note": "Q4 2025"
  },
  "SHW": {
    "date": "2026-01-30",
    "time": "bmo",
    "note": "Q4 2025"
  },
  "FISV": {
    "date": "2026-02-04",
    "time": "bmo",
    "note": "Q4 2025"
  },
  "MSI": {
    "date": "2026-02-06",
    "time": "bmo",
    "note": "Q4 2025"
  },
  "APH": {
    "date": "2026-01-22",
    "time": "bmo",
    "note": "Q4 2025"
  },
  "AXON": {
    "date": "2026-02-25",
    "time": "amc",
    "note": "Q4 2025"
  },
  "ROP": {
    "date": "2026-01-30",
    "time": "bmo",
    "note": "Q4 2025"
  },
  "RACE": {
    "date": "2026-02-04",
    "time": "bmo",
    "note": "Q4 2025"
  },
  "TWLO": {
    "date": "2026-02-12",
    "time": "amc",
    "note": "Q4 2025"
  },
  "ZM": {
    "date": "2026-02-24",
    "time": "amc",
    "note": "Q4 FY2026"
  },
  "U": {
    "date": "2026-02-20",
    "time": "amc",
    "note": "Q4 2025"
  },
  "ZI": {
    "date": "2026-02-10",
    "time": "amc",
    "note": "Q4 2025"
  }
}

#!/usr/bin/env bash
# Price Alerts Cron Job (Lobster Workflow)
# Schedule: 2:00 PM PT / 5:00 PM ET (1 hour after market close)
#
# Checks price alerts against current prices including after-hours.
# Sends triggered alerts and watchlist status to WhatsApp/Telegram.

set -e

export SKILL_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
export FINANCE_NEWS_TARGET="${FINANCE_NEWS_TARGET:-120363421796203667@g.us}"
export FINANCE_NEWS_CHANNEL="${FINANCE_NEWS_CHANNEL:-whatsapp}"

echo "[$(date)] Checking price alerts via Lobster..."

lobster run --file "$SKILL_DIR/workflows/alerts-cron.yaml" \
  --args-json '{"lang":"en"}'

echo "[$(date)] Price alerts check complete."

#!/usr/bin/env bash
# Weekly Earnings Alert Cron Job (Lobster Workflow)
# Schedule: Sunday 7:00 AM PT (before market week starts)
#
# Sends upcoming week's earnings calendar to WhatsApp/Telegram.
# Shows all portfolio stocks reporting Mon-Fri.

set -e

export SKILL_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
export FINANCE_NEWS_TARGET="${FINANCE_NEWS_TARGET:-120363421796203667@g.us}"
export FINANCE_NEWS_CHANNEL="${FINANCE_NEWS_CHANNEL:-whatsapp}"

echo "[$(date)] Checking next week's earnings via Lobster..."

lobster run --file "$SKILL_DIR/workflows/earnings-weekly-cron.yaml" \
  --args-json '{"lang":"en"}'

echo "[$(date)] Weekly earnings alert complete."

#!/usr/bin/env bash
# Earnings Alert Cron Job (Lobster Workflow)
# Schedule: 6:00 AM PT / 9:00 AM ET (30 min before market open)
#
# Sends today's earnings calendar to WhatsApp/Telegram.
# Alerts users about portfolio stocks reporting today.

set -e

export SKILL_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
export FINANCE_NEWS_TARGET="${FINANCE_NEWS_TARGET:-120363421796203667@g.us}"
export FINANCE_NEWS_CHANNEL="${FINANCE_NEWS_CHANNEL:-whatsapp}"

echo "[$(date)] Checking today's earnings via Lobster..."

lobster run --file "$SKILL_DIR/workflows/earnings-cron.yaml" \
  --args-json '{"lang":"en"}'

echo "[$(date)] Earnings alert complete."

#!/usr/bin/env bash
# Evening Briefing Cron Job (Lobster Workflow)
# Schedule: 1:00 PM PT (US Market Close at 4:00 PM ET)
#
# Uses Lobster workflow to generate and send briefing directly,
# bypassing LLM agent reformatting that truncates output.

set -e

export SKILL_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
export FINANCE_NEWS_TARGET="${FINANCE_NEWS_TARGET:-120363421796203667@g.us}"
export FINANCE_NEWS_CHANNEL="${FINANCE_NEWS_CHANNEL:-whatsapp}"

echo "[$(date)] Starting evening briefing via Lobster..."

lobster run --file "$SKILL_DIR/workflows/briefing-cron.yaml" \
  --args-json '{"time":"evening","lang":"de"}'

echo "[$(date)] Evening briefing complete."

#!/usr/bin/env bash
# Morning Briefing Cron Job (Lobster Workflow)
# Schedule: 6:30 AM PT (US Market Open at 9:30 AM ET)
#
# Uses Lobster workflow to generate and send briefing directly,
# bypassing LLM agent reformatting that truncates output.

set -e

export SKILL_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
export FINANCE_NEWS_TARGET="${FINANCE_NEWS_TARGET:-120363421796203667@g.us}"
export FINANCE_NEWS_CHANNEL="${FINANCE_NEWS_CHANNEL:-whatsapp}"

echo "[$(date)] Starting morning briefing via Lobster..."

lobster run --file "$SKILL_DIR/workflows/briefing-cron.yaml" \
  --args-json '{"time":"morning","lang":"de"}'

echo "[$(date)] Morning briefing complete."

[pytest]
testpaths = tests
python_files = test_*.py
python_classes = Test*
python_functions = test_*
addopts = 
    -v
    --strict-markers
    --tb=short
    --cov=scripts
    --cov-report=term-missing
    --cov-report=html

# Test dependencies
pytest>=7.4.0
pytest-cov>=4.1.0
pytest-mock>=3.12.0

feedparser>=6.0.11
yfinance

#!/usr/bin/env python3
"""
Price Target Alerts - Track buy zone alerts for stocks.

Features:
- Set price target alerts (buy zone triggers)
- Check alerts against current prices
- Snooze, update, delete alerts
- Multi-currency support (USD, EUR, JPY, SGD, MXN)

Usage:
    alerts.py list                           # Show all alerts
    alerts.py set CRWD 400 --note 'Kaufzone' # Set alert
    alerts.py check                          # Check triggered alerts
    alerts.py delete CRWD                    # Delete alert
    alerts.py snooze CRWD --days 7           # Snooze for 7 days
    alerts.py update CRWD 380                # Update target price
"""

import argparse
import json
import sys
from datetime import datetime, timedelta
from pathlib import Path

from utils import ensure_venv

ensure_venv()

# Lazy import to avoid numpy issues at module load
fetch_market_data = None

def get_fetch_market_data():
    global fetch_market_data
    if fetch_market_data is None:
        from fetch_news import fetch_market_data as fmd
        fetch_market_data = fmd
    return fetch_market_data

SCRIPT_DIR = Path(__file__).parent
CONFIG_DIR = SCRIPT_DIR.parent / "config"
ALERTS_FILE = CONFIG_DIR / "alerts.json"

SUPPORTED_CURRENCIES = ["USD", "EUR", "JPY", "SGD", "MXN"]


def load_alerts() -> dict:
    """Load alerts from JSON file."""
    if not ALERTS_FILE.exists():
        return {"_meta": {"version": 1, "supported_currencies": SUPPORTED_CURRENCIES}, "alerts": []}
    return json.loads(ALERTS_FILE.read_text())


def save_alerts(data: dict) -> None:
    """Save alerts to JSON file."""
    data["_meta"]["updated_at"] = datetime.now().isoformat()
    ALERTS_FILE.write_text(json.dumps(data, indent=2))


def get_alert_by_ticker(alerts: list, ticker: str) -> dict | None:
    """Find alert by ticker."""
    ticker = ticker.upper()
    for alert in alerts:
        if alert["ticker"] == ticker:
            return alert
    return None


def format_price(price: float, currency: str) -> str:
    """Format price with currency symbol."""
    symbols = {"USD": "$", "EUR": "€", "JPY": "¥", "SGD": "S$", "MXN": "MX$"}
    symbol = symbols.get(currency, currency + " ")
    if currency == "JPY":
        return f"{symbol}{price:,.0f}"
    return f"{symbol}{price:,.2f}"


def cmd_list(args) -> None:
    """List all alerts."""
    data = load_alerts()
    alerts = data.get("alerts", [])
    
    if not alerts:
        print("📭 No price alerts set")
        return
    
    print(f"📊 Price Alerts ({len(alerts)} total)\n")
    
    now = datetime.now()
    active = []
    snoozed = []
    
    for alert in alerts:
        snooze_until = alert.get("snooze_until")
        if snooze_until and datetime.fromisoformat(snooze_until) > now:
            snoozed.append(alert)
        else:
            active.append(alert)
    
    if active:
        print("### Active Alerts")
        for a in active:
            target = format_price(a["target_price"], a.get("currency", "USD"))
            note = f' — "{a["note"]}"' if a.get("note") else ""
            user = f" (by {a['set_by']})" if a.get("set_by") else ""
            print(f"  • {a['ticker']}: {target}{note}{user}")
        print()
    
    if snoozed:
        print("### Snoozed")
        for a in snoozed:
            target = format_price(a["target_price"], a.get("currency", "USD"))
            until = datetime.fromisoformat(a["snooze_until"]).strftime("%Y-%m-%d")
            print(f"  • {a['ticker']}: {target} (until {until})")
        print()


def cmd_set(args) -> None:
    """Set a new alert."""
    data = load_alerts()
    alerts = data.get("alerts", [])
    ticker = args.ticker.upper()
    
    # Check if alert exists
    existing = get_alert_by_ticker(alerts, ticker)
    if existing:
        print(f"⚠️ Alert for {ticker} already exists. Use 'update' to change target.")
        return
    
    # Validate target price
    if args.target <= 0:
        print(f"❌ Target price must be greater than 0")
        return
    
    currency = args.currency.upper() if args.currency else "USD"
    if currency not in SUPPORTED_CURRENCIES:
        print(f"❌ Currency {currency} not supported. Use: {', '.join(SUPPORTED_CURRENCIES)}")
        return
    
    # Warn about currency mismatch based on ticker suffix
    ticker_currency_map = {
        ".T": "JPY",      # Tokyo
        ".SI": "SGD",     # Singapore
        ".MX": "MXN",     # Mexico
        ".DE": "EUR", ".F": "EUR", ".PA": "EUR",  # Europe
    }
    expected_currency = "USD"  # Default for US stocks
    for suffix, curr in ticker_currency_map.items():
        if ticker.endswith(suffix):
            expected_currency = curr
            break
    
    if currency != expected_currency:
        print(f"⚠️ Warning: {ticker} trades in {expected_currency}, but alert set in {currency}")
    
    # Fetch current price (optional - may fail if numpy broken)
    current_price = None
    try:
        quotes = get_fetch_market_data()([ticker], timeout=10)
        if ticker in quotes and quotes[ticker].get("price"):
            current_price = quotes[ticker]["price"]
    except Exception as e:
        print(f"⚠️ Could not fetch current price: {e}", file=sys.stderr)
    
    alert = {
        "ticker": ticker,
        "target_price": args.target,
        "currency": currency,
        "note": args.note or "",
        "set_by": args.user or "",
        "set_date": datetime.now().strftime("%Y-%m-%d"),
        "status": "active",
        "snooze_until": None,
        "triggered_count": 0,
        "last_triggered": None,
    }
    
    alerts.append(alert)
    data["alerts"] = alerts
    save_alerts(data)
    
    target_str = format_price(args.target, currency)
    print(f"✅ Alert set: {ticker} under {target_str}")
    if current_price:
        pct_diff = ((current_price - args.target) / current_price) * 100
        current_str = format_price(current_price, currency)
        print(f"   Current: {current_str} ({pct_diff:+.1f}% to target)")


def cmd_delete(args) -> None:
    """Delete an alert."""
    data = load_alerts()
    alerts = data.get("alerts", [])
    ticker = args.ticker.upper()
    
    new_alerts = [a for a in alerts if a["ticker"] != ticker]
    if len(new_alerts) == len(alerts):
        print(f"❌ No alert found for {ticker}")
        return
    
    data["alerts"] = new_alerts
    save_alerts(data)
    print(f"🗑️ Alert deleted: {ticker}")


def cmd_snooze(args) -> None:
    """Snooze an alert."""
    data = load_alerts()
    alerts = data.get("alerts", [])
    ticker = args.ticker.upper()
    
    alert = get_alert_by_ticker(alerts, ticker)
    if not alert:
        print(f"❌ No alert found for {ticker}")
        return
    
    days = args.days or 7
    snooze_until = datetime.now() + timedelta(days=days)
    alert["snooze_until"] = snooze_until.isoformat()
    save_alerts(data)
    print(f"😴 Alert snoozed: {ticker} until {snooze_until.strftime('%Y-%m-%d')}")


def cmd_update(args) -> None:
    """Update alert target price."""
    data = load_alerts()
    alerts = data.get("alerts", [])
    ticker = args.ticker.upper()
    
    alert = get_alert_by_ticker(alerts, ticker)
    if not alert:
        print(f"❌ No alert found for {ticker}")
        return
    
    # Validate target price
    if args.target <= 0:
        print(f"❌ Target price must be greater than 0")
        return
    
    old_target = alert["target_price"]
    alert["target_price"] = args.target
    if args.note:
        alert["note"] = args.note
    save_alerts(data)
    
    currency = alert.get("currency", "USD")
    old_str = format_price(old_target, currency)
    new_str = format_price(args.target, currency)
    print(f"✏️ Alert updated: {ticker} {old_str} → {new_str}")


def cmd_check(args) -> None:
    """Check alerts against current prices."""
    data = load_alerts()
    alerts = data.get("alerts", [])
    
    if not alerts:
        if args.json:
            print(json.dumps({"triggered": [], "watching": []}))
        else:
            print("📭 No alerts to check")
        return
    
    now = datetime.now()
    active_alerts = []
    for alert in alerts:
        snooze_until = alert.get("snooze_until")
        if snooze_until and datetime.fromisoformat(snooze_until) > now:
            continue
        active_alerts.append(alert)
    
    if not active_alerts:
        if args.json:
            print(json.dumps({"triggered": [], "watching": []}))
        else:
            print("📭 All alerts snoozed")
        return
    
    # Fetch prices for all active alerts
    tickers = [a["ticker"] for a in active_alerts]
    quotes = get_fetch_market_data()(tickers, timeout=30)
    
    triggered = []
    watching = []
    
    for alert in active_alerts:
        ticker = alert["ticker"]
        target = alert["target_price"]
        currency = alert.get("currency", "USD")
        
        quote = quotes.get(ticker, {})
        price = quote.get("price")
        
        if price is None:
            continue
        
        # Divide-by-zero protection
        if target == 0:
            pct_diff = 0
        else:
            pct_diff = ((price - target) / target) * 100
        
        result = {
            "ticker": ticker,
            "target_price": target,
            "current_price": price,
            "currency": currency,
            "pct_from_target": round(pct_diff, 2),
            "note": alert.get("note", ""),
            "set_by": alert.get("set_by", ""),
        }
        
        if price <= target:
            triggered.append(result)
            # Update triggered count (only once per day to avoid inflation)
            last_triggered = alert.get("last_triggered")
            today = now.strftime("%Y-%m-%d")
            if not last_triggered or not last_triggered.startswith(today):
                alert["triggered_count"] = alert.get("triggered_count", 0) + 1
            alert["last_triggered"] = now.isoformat()
        else:
            watching.append(result)
    
    save_alerts(data)
    
    if args.json:
        print(json.dumps({"triggered": triggered, "watching": watching}, indent=2))
        return

    # Translations
    lang = getattr(args, 'lang', 'en')
    if lang == "de":
        labels = {
            "title": "PREISWARNUNGEN",
            "in_zone": "IN KAUFZONE",
            "buy": "KAUFEN!",
            "target": "Ziel",
            "watching": "BEOBACHTUNG",
            "to_target": "noch",
            "no_data": "Keine Preisdaten für Alerts verfügbar",
        }
    else:
        labels = {
            "title": "PRICE ALERTS",
            "in_zone": "IN BUY ZONE",
            "buy": "BUY SIGNAL",
            "target": "target",
            "watching": "WATCHING",
            "to_target": "to target",
            "no_data": "No price data available for alerts",
        }

    # Date header
    date_str = datetime.now().strftime("%b %d, %Y") if lang == "en" else datetime.now().strftime("%d. %b %Y")
    print(f"📊 {labels['title']} — {date_str}\n")

    # Human-readable output
    if triggered:
        print(f"🟢 {labels['in_zone']}:\n")
        for t in triggered:
            target_str = format_price(t["target_price"], t["currency"])
            current_str = format_price(t["current_price"], t["currency"])
            note = f'\n   "{t["note"]}"' if t.get("note") else ""
            user = f" — {t['set_by']}" if t.get("set_by") else ""
            print(f"• {t['ticker']}: {current_str} ({labels['target']}: {target_str}) ← {labels['buy']}{note}{user}")
        print()

    if watching:
        print(f"⏳ {labels['watching']}:\n")
        for w in sorted(watching, key=lambda x: x["pct_from_target"]):
            target_str = format_price(w["target_price"], w["currency"])
            current_str = format_price(w["current_price"], w["currency"])
            print(f"• {w['ticker']}: {current_str} ({labels['target']}: {target_str}) — {labels['to_target']} {abs(w['pct_from_target']):.1f}%")
        print()

    if not triggered and not watching:
        print(f"📭 {labels['no_data']}")


def check_alerts() -> dict:
    """
    Check alerts and return results for briefing integration.
    Returns: {"triggered": [...], "watching": [...]}
    """
    data = load_alerts()
    alerts = data.get("alerts", [])
    
    if not alerts:
        return {"triggered": [], "watching": []}
    
    now = datetime.now()
    active_alerts = [
        a for a in alerts
        if not a.get("snooze_until") or datetime.fromisoformat(a["snooze_until"]) <= now
    ]
    
    if not active_alerts:
        return {"triggered": [], "watching": []}
    
    tickers = [a["ticker"] for a in active_alerts]
    quotes = get_fetch_market_data()(tickers, timeout=30)
    
    triggered = []
    watching = []
    
    for alert in active_alerts:
        ticker = alert["ticker"]
        target = alert["target_price"]
        currency = alert.get("currency", "USD")
        
        quote = quotes.get(ticker, {})
        price = quote.get("price")
        
        if price is None:
            continue
        
        # Divide-by-zero protection
        if target == 0:
            pct_diff = 0
        else:
            pct_diff = ((price - target) / target) * 100
        
        result = {
            "ticker": ticker,
            "target_price": target,
            "current_price": price,
            "currency": currency,
            "pct_from_target": round(pct_diff, 2),
            "note": alert.get("note", ""),
            "set_by": alert.get("set_by", ""),
        }
        
        if price <= target:
            triggered.append(result)
            # Update triggered count (only once per day to avoid inflation)
            last_triggered = alert.get("last_triggered")
            today = now.strftime("%Y-%m-%d")
            if not last_triggered or not last_triggered.startswith(today):
                alert["triggered_count"] = alert.get("triggered_count", 0) + 1
            alert["last_triggered"] = now.isoformat()
        else:
            watching.append(result)
    
    save_alerts(data)
    return {"triggered": triggered, "watching": watching}


def main():
    parser = argparse.ArgumentParser(description="Price target alerts")
    subparsers = parser.add_subparsers(dest="command", required=True)
    
    # list
    subparsers.add_parser("list", help="List all alerts")
    
    # set
    set_parser = subparsers.add_parser("set", help="Set new alert")
    set_parser.add_argument("ticker", help="Stock ticker")
    set_parser.add_argument("target", type=float, help="Target price")
    set_parser.add_argument("--note", help="Note/reason")
    set_parser.add_argument("--user", help="Who set the alert")
    set_parser.add_argument("--currency", default="USD", help="Currency (USD, EUR, JPY, SGD, MXN)")
    
    # delete
    del_parser = subparsers.add_parser("delete", help="Delete alert")
    del_parser.add_argument("ticker", help="Stock ticker")
    
    # snooze
    snooze_parser = subparsers.add_parser("snooze", help="Snooze alert")
    snooze_parser.add_argument("ticker", help="Stock ticker")
    snooze_parser.add_argument("--days", type=int, default=7, help="Days to snooze")
    
    # update
    update_parser = subparsers.add_parser("update", help="Update alert target")
    update_parser.add_argument("ticker", help="Stock ticker")
    update_parser.add_argument("target", type=float, help="New target price")
    update_parser.add_argument("--note", help="Update note")
    
    # check
    check_parser = subparsers.add_parser("check", help="Check alerts against prices")
    check_parser.add_argument("--json", action="store_true", help="JSON output")
    check_parser.add_argument("--lang", default="en", help="Output language (en, de)")
    
    args = parser.parse_args()
    
    if args.command == "list":
        cmd_list(args)
    elif args.command == "set":
        cmd_set(args)
    elif args.command == "delete":
        cmd_delete(args)
    elif args.command == "snooze":
        cmd_snooze(args)
    elif args.command == "update":
        cmd_update(args)
    elif args.command == "check":
        cmd_check(args)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Briefing Generator - Main entry point for market briefings.
Generates and optionally sends to WhatsApp group.
"""

import argparse
import json
import os
import subprocess
import sys
from datetime import datetime
from pathlib import Path

from utils import ensure_venv

SCRIPT_DIR = Path(__file__).parent

ensure_venv()


def send_to_whatsapp(message: str, group_name: str | None = None):
    """Send message to WhatsApp group via openclaw message tool."""
    if not group_name:
        group_name = os.environ.get('FINANCE_NEWS_TARGET', '')
    if not group_name:
        print("❌ No target specified. Set FINANCE_NEWS_TARGET env var or use --group", file=sys.stderr)
        return False
    # Use openclaw message tool
    try:
        result = subprocess.run(
            [
                'openclaw', 'message', 'send',
                '--channel', 'whatsapp',
                '--target', group_name,
                '--message', message
            ],
            capture_output=True,
            text=True,
            timeout=30
        )
        
        if result.returncode == 0:
            print(f"✅ Sent to WhatsApp group: {group_name}", file=sys.stderr)
            return True
        else:
            print(f"⚠️ WhatsApp send failed: {result.stderr}", file=sys.stderr)
            return False
    
    except Exception as e:
        print(f"❌ WhatsApp error: {e}", file=sys.stderr)
        return False


def generate_and_send(args):
    """Generate briefing and optionally send to WhatsApp."""
    
    # Determine briefing type based on current time or args
    if args.time:
        briefing_time = args.time
    else:
        hour = datetime.now().hour
        briefing_time = 'morning' if hour < 12 else 'evening'
    
    # Generate the briefing
    cmd = [
        sys.executable, SCRIPT_DIR / 'summarize.py',
        '--time', briefing_time,
        '--style', args.style,
        '--lang', args.lang
    ]

    if args.deadline is not None:
        cmd.extend(['--deadline', str(args.deadline)])

    if args.fast:
        cmd.append('--fast')

    if args.llm:
        cmd.append('--llm')
        cmd.extend(['--model', args.model])

    if args.debug:
        cmd.append('--debug')
    
    # Always use JSON for internal processing to handle splits
    cmd.append('--json')
    
    print(f"📊 Generating {briefing_time} briefing...", file=sys.stderr)
    
    timeout = args.deadline if args.deadline is not None else 300
    timeout = max(1, int(timeout))
    if args.deadline is not None:
        timeout = timeout + 5
    result = subprocess.run(
        cmd,
        capture_output=True,
        text=True,
        stdin=subprocess.DEVNULL,
        timeout=timeout
    )
    
    if result.returncode != 0:
        print(f"❌ Briefing generation failed: {result.stderr}", file=sys.stderr)
        sys.exit(1)
    
    try:
        data = json.loads(result.stdout.strip())
    except json.JSONDecodeError:
        # Fallback if not JSON (shouldn't happen with --json)
        print(f"⚠️ Failed to parse briefing JSON", file=sys.stderr)
        print(result.stdout)
        return result.stdout

    # Output handling
    if args.json:
        print(json.dumps(data, indent=2))
    else:
        # Print for humans
        if data.get('macro_message'):
             print(data['macro_message'])
        if data.get('portfolio_message'):
             print("\n" + "="*20 + "\n")
             print(data['portfolio_message'])
    
    # Send to WhatsApp if requested
    if args.send and args.group:
        # Message 1: Macro
        macro_msg = data.get('macro_message') or data.get('summary', '')
        if macro_msg:
            send_to_whatsapp(macro_msg, args.group)
        
        # Message 2: Portfolio (if exists)
        portfolio_msg = data.get('portfolio_message')
        if portfolio_msg:
            send_to_whatsapp(portfolio_msg, args.group)
            
    return data.get('macro_message', '')


def main():
    parser = argparse.ArgumentParser(description='Briefing Generator')
    parser.add_argument('--time', choices=['morning', 'evening'], 
                        help='Briefing type (auto-detected if not specified)')
    parser.add_argument('--style', choices=['briefing', 'analysis', 'headlines'],
                        default='briefing', help='Summary style')
    parser.add_argument('--lang', choices=['en', 'de'], default='en',
                        help='Output language')
    parser.add_argument('--send', action='store_true',
                        help='Send to WhatsApp group')
    parser.add_argument('--group', default=os.environ.get('FINANCE_NEWS_TARGET', ''),
                        help='WhatsApp group name or JID (default: FINANCE_NEWS_TARGET env var)')
    parser.add_argument('--json', action='store_true',
                        help='Output as JSON')
    parser.add_argument('--deadline', type=int, default=None,
                        help='Overall deadline in seconds')
    parser.add_argument('--llm', action='store_true', help='Use LLM summary')
    parser.add_argument('--model', choices=['claude', 'minimax', 'gemini'],
                        default='claude', help='LLM model (only with --llm)')
    parser.add_argument('--fast', action='store_true',
                        help='Use fast mode (shorter timeouts, fewer items)')
    parser.add_argument('--debug', action='store_true',
                        help='Write debug log with sources')
    
    args = parser.parse_args()
    generate_and_send(args)


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
Earnings Calendar - Track earnings dates for portfolio stocks.

Features:
- Fetch earnings dates from FMP API
- Show upcoming earnings in daily briefing
- Alert 24h before earnings release
- Cache results to avoid API spam

Usage:
    earnings.py list              # Show all upcoming earnings
    earnings.py check             # Check what's reporting today/this week
    earnings.py refresh           # Force refresh earnings data
"""

import argparse
import csv
import json
import os
import shutil
import subprocess
import sys
from datetime import datetime, timedelta
from pathlib import Path
from urllib.request import urlopen, Request
from urllib.error import URLError, HTTPError

# Paths
SCRIPT_DIR = Path(__file__).parent
CONFIG_DIR = SCRIPT_DIR.parent / "config"
CACHE_DIR = SCRIPT_DIR.parent / "cache"
PORTFOLIO_FILE = CONFIG_DIR / "portfolio.csv"
EARNINGS_CACHE = CACHE_DIR / "earnings_calendar.json"
MANUAL_EARNINGS = CONFIG_DIR / "manual_earnings.json"  # For JP/other stocks not in Finnhub

# OpenBB binary path
OPENBB_BINARY = None
try:
    env_path = os.environ.get('OPENBB_QUOTE_BIN')
    if env_path and os.path.isfile(env_path) and os.access(env_path, os.X_OK):
        OPENBB_BINARY = env_path
    else:
        OPENBB_BINARY = shutil.which('openbb-quote')
except Exception:
    pass

# API Keys
def get_fmp_key() -> str:
    """Get FMP API key from environment or .env file."""
    key = os.environ.get("FMP_API_KEY", "")
    if not key:
        env_file = Path.home() / ".openclaw" / ".env"
        if env_file.exists():
            for line in env_file.read_text().splitlines():
                if line.startswith("FMP_API_KEY="):
                    key = line.split("=", 1)[1].strip()
                    break
    return key


def load_portfolio() -> list[dict]:
    """Load portfolio from CSV."""
    if not PORTFOLIO_FILE.exists():
        return []
    with open(PORTFOLIO_FILE, 'r') as f:
        reader = csv.DictReader(f)
        return list(reader)


def load_earnings_cache() -> dict:
    """Load cached earnings data."""
    if EARNINGS_CACHE.exists():
        try:
            return json.loads(EARNINGS_CACHE.read_text())
        except Exception:
            pass
    return {"last_updated": None, "earnings": {}}


def load_manual_earnings() -> dict:
    """
    Load manually-entered earnings dates (for JP stocks not in Finnhub).
    Format: {"6857.T": {"date": "2026-01-30", "time": "amc", "note": "Q3 FY2025"}, ...}
    """
    if MANUAL_EARNINGS.exists():
        try:
            data = json.loads(MANUAL_EARNINGS.read_text())
            # Filter out metadata keys (starting with _)
            return {k: v for k, v in data.items() if not k.startswith("_") and isinstance(v, dict)}
        except Exception:
            pass
    return {}


def save_earnings_cache(data: dict):
    """Save earnings data to cache."""
    CACHE_DIR.mkdir(exist_ok=True)
    EARNINGS_CACHE.write_text(json.dumps(data, indent=2, default=str))


def get_finnhub_key() -> str:
    """Get Finnhub API key from environment or .env file."""
    key = os.environ.get("FINNHUB_API_KEY", "")
    if not key:
        env_file = Path.home() / ".openclaw" / ".env"
        if env_file.exists():
            for line in env_file.read_text().splitlines():
                if line.startswith("FINNHUB_API_KEY="):
                    key = line.split("=", 1)[1].strip()
                    break
    return key


def fetch_all_earnings_finnhub(days_ahead: int = 60) -> dict:
    """
    Fetch all earnings for the next N days from Finnhub.
    Returns dict keyed by symbol: {"AAPL": {...}, ...}
    """
    finnhub_key = get_finnhub_key()
    if not finnhub_key:
        return {}
    
    from_date = datetime.now().strftime("%Y-%m-%d")
    to_date = (datetime.now() + timedelta(days=days_ahead)).strftime("%Y-%m-%d")
    
    url = f"https://finnhub.io/api/v1/calendar/earnings?from={from_date}&to={to_date}&token={finnhub_key}"
    
    try:
        req = Request(url, headers={"User-Agent": "finance-news/1.0"})
        with urlopen(req, timeout=30) as resp:
            data = json.loads(resp.read().decode("utf-8"))
            
            earnings_by_symbol = {}
            for entry in data.get("earningsCalendar", []):
                symbol = entry.get("symbol")
                if symbol:
                    earnings_by_symbol[symbol] = {
                        "date": entry.get("date"),
                        "time": entry.get("hour", ""),  # bmo/amc
                        "eps_estimate": entry.get("epsEstimate"),
                        "revenue_estimate": entry.get("revenueEstimate"),
                        "quarter": entry.get("quarter"),
                        "year": entry.get("year"),
                    }
            return earnings_by_symbol
    except Exception as e:
        print(f"❌ Finnhub error: {e}", file=sys.stderr)
        return {}


def normalize_ticker_for_lookup(ticker: str) -> list[str]:
    """
    Convert portfolio ticker to possible Finnhub symbols.
    Returns list of possible formats to try.
    """
    variants = [ticker]
    
    # Japanese stocks: 6857.T -> try 6857
    if ticker.endswith('.T'):
        base = ticker.replace('.T', '')
        variants.extend([base, f"{base}.T"])
    
    # Singapore stocks: D05.SI -> try D05
    elif ticker.endswith('.SI'):
        base = ticker.replace('.SI', '')
        variants.extend([base, f"{base}.SI"])
    
    return variants


def fetch_earnings_for_portfolio(portfolio: list[dict]) -> dict:
    """
    Fetch earnings dates for portfolio stocks using Finnhub bulk API.
    More efficient than per-ticker calls.
    """
    # Get all earnings for next 60 days
    all_earnings = fetch_all_earnings_finnhub(days_ahead=60)
    
    if not all_earnings:
        return {}
    
    # Match portfolio tickers to earnings data
    results = {}
    for stock in portfolio:
        ticker = stock["symbol"]
        variants = normalize_ticker_for_lookup(ticker)
        
        for variant in variants:
            if variant in all_earnings:
                results[ticker] = all_earnings[variant]
                break
    
    return results


def refresh_earnings(portfolio: list[dict], force: bool = False) -> dict:
    """Refresh earnings data for all portfolio stocks."""
    finnhub_key = get_finnhub_key()
    if not finnhub_key:
        print("❌ FINNHUB_API_KEY not found", file=sys.stderr)
        return {}
    
    cache = load_earnings_cache()
    
    # Check if cache is fresh (< 6 hours old)
    if not force and cache.get("last_updated"):
        try:
            last = datetime.fromisoformat(cache["last_updated"])
            if datetime.now() - last < timedelta(hours=6):
                print(f"📦 Using cached data (updated {last.strftime('%H:%M')})")
                return cache
        except Exception:
            pass
    
    print(f"🔄 Fetching earnings calendar from Finnhub...")
    
    # Use bulk fetch - much more efficient
    earnings = fetch_earnings_for_portfolio(portfolio)
    
    # Merge manual earnings (for JP stocks not in Finnhub)
    manual = load_manual_earnings()
    if manual:
        print(f"📝 Merging {len(manual)} manual entries...")
        for ticker, data in manual.items():
            if ticker not in earnings:  # Manual data fills gaps
                earnings[ticker] = data
    
    found = len(earnings)
    total = len(portfolio)
    print(f"✅ Found earnings data for {found}/{total} stocks")
    
    if earnings:
        for ticker, data in sorted(earnings.items(), key=lambda x: x[1].get("date", "")):
            print(f"  • {ticker}: {data.get('date', '?')}")
    
    cache = {
        "last_updated": datetime.now().isoformat(),
        "earnings": earnings
    }
    save_earnings_cache(cache)
    
    return cache


def list_earnings(args):
    """List all upcoming earnings for portfolio."""
    portfolio = load_portfolio()
    if not portfolio:
        print("📂 Portfolio empty")
        return
    
    cache = refresh_earnings(portfolio, force=args.refresh)
    earnings = cache.get("earnings", {})
    
    if not earnings:
        print("\n❌ No earnings dates found")
        return
    
    # Sort by date
    sorted_earnings = sorted(
        [(ticker, data) for ticker, data in earnings.items() if data.get("date")],
        key=lambda x: x[1]["date"]
    )
    
    print(f"\n📅 Upcoming Earnings ({len(sorted_earnings)} stocks)\n")
    
    today = datetime.now().date()
    
    for ticker, data in sorted_earnings:
        date_str = data["date"]
        try:
            ed = datetime.strptime(date_str, "%Y-%m-%d").date()
            days_until = (ed - today).days
            
            # Emoji based on timing
            if days_until < 0:
                emoji = "✅"  # Past
                timing = f"{-days_until}d ago"
            elif days_until == 0:
                emoji = "🔴"  # Today!
                timing = "TODAY"
            elif days_until == 1:
                emoji = "🟡"  # Tomorrow
                timing = "TOMORROW"
            elif days_until <= 7:
                emoji = "🟠"  # This week
                timing = f"in {days_until}d"
            else:
                emoji = "⚪"  # Later
                timing = f"in {days_until}d"
            
            # Time of day
            time_str = ""
            if data.get("time") == "bmo":
                time_str = " (pre-market)"
            elif data.get("time") == "amc":
                time_str = " (after-close)"
            
            # EPS estimate
            eps_str = ""
            if data.get("eps_estimate"):
                eps_str = f" | Est: ${data['eps_estimate']:.2f}"
            
            # Stock name from portfolio
            stock_name = next((s["name"] for s in portfolio if s["symbol"] == ticker), ticker)
            
            print(f"{emoji} {date_str} ({timing}): **{ticker}** — {stock_name}{time_str}{eps_str}")
            
        except ValueError:
            print(f"⚪ {date_str}: {ticker}")
    
    print()


def check_earnings(args):
    """Check earnings for today and this week (briefing format)."""
    portfolio = load_portfolio()
    if not portfolio:
        return

    cache = load_earnings_cache()

    # Auto-refresh if cache is stale
    if not cache.get("last_updated"):
        cache = refresh_earnings(portfolio, force=False)
    else:
        try:
            last = datetime.fromisoformat(cache["last_updated"])
            if datetime.now() - last > timedelta(hours=12):
                cache = refresh_earnings(portfolio, force=False)
        except Exception:
            cache = refresh_earnings(portfolio, force=False)

    earnings = cache.get("earnings", {})
    if not earnings:
        return

    today = datetime.now().date()
    week_only = getattr(args, 'week', False)

    # For weekly mode (Sunday cron), show Mon-Fri of upcoming week
    # Calculation: weekday() returns 0=Mon, 6=Sun. (7 - weekday) % 7 gives days until next Monday.
    # Special case: if today is Monday (result=0), we want next Monday (7 days), not today.
    if week_only:
        days_until_monday = (7 - today.weekday()) % 7
        if days_until_monday == 0 and today.weekday() != 0:
            days_until_monday = 7
        week_start = today + timedelta(days=days_until_monday)
        week_end = week_start + timedelta(days=4)  # Mon-Fri
    else:
        week_end = today + timedelta(days=7)

    today_list = []
    week_list = []

    for ticker, data in earnings.items():
        if not data.get("date"):
            continue
        try:
            ed = datetime.strptime(data["date"], "%Y-%m-%d").date()
            stock = next((s for s in portfolio if s["symbol"] == ticker), None)
            name = stock["name"] if stock else ticker
            category = stock.get("category", "") if stock else ""

            entry = {
                "ticker": ticker,
                "name": name,
                "date": ed,
                "time": data.get("time", ""),
                "eps_estimate": data.get("eps_estimate"),
                "category": category,
            }

            if week_only:
                # Weekly mode: only show week range
                if week_start <= ed <= week_end:
                    week_list.append(entry)
            else:
                # Daily mode: today + this week
                if ed == today:
                    today_list.append(entry)
                elif today < ed <= week_end:
                    week_list.append(entry)
        except ValueError:
            continue
    
    # Handle JSON output
    if getattr(args, 'json', False):
        if week_only:
            result = {
                "week_start": week_start.isoformat(),
                "week_end": week_end.isoformat(),
                "earnings": [
                    {
                        "ticker": e["ticker"],
                        "name": e["name"],
                        "date": e["date"].isoformat(),
                        "time": e["time"],
                        "eps_estimate": e.get("eps_estimate"),
                        "category": e.get("category", ""),
                    }
                    for e in sorted(week_list, key=lambda x: x["date"])
                ],
            }
        else:
            result = {
                "today": [
                    {
                        "ticker": e["ticker"],
                        "name": e["name"],
                        "date": e["date"].isoformat(),
                        "time": e["time"],
                        "eps_estimate": e.get("eps_estimate"),
                        "category": e.get("category", ""),
                    }
                    for e in sorted(today_list, key=lambda x: x.get("time", "zzz"))
                ],
                "this_week": [
                    {
                        "ticker": e["ticker"],
                        "name": e["name"],
                        "date": e["date"].isoformat(),
                        "time": e["time"],
                        "eps_estimate": e.get("eps_estimate"),
                        "category": e.get("category", ""),
                    }
                    for e in sorted(week_list, key=lambda x: x["date"])
                ],
            }
        print(json.dumps(result, indent=2))
        return

    # Translations
    lang = getattr(args, 'lang', 'en')
    if lang == "de":
        labels = {
            "today": "EARNINGS HEUTE",
            "week": "EARNINGS DIESE WOCHE",
            "week_preview": "EARNINGS NÄCHSTE WOCHE",
            "pre": "vor Börseneröffnung",
            "post": "nach Börsenschluss",
            "pre_short": "vor",
            "post_short": "nach",
            "est": "Erw",
            "none": "Keine Earnings diese Woche",
            "none_week": "Keine Earnings nächste Woche",
        }
    else:
        labels = {
            "today": "EARNINGS TODAY",
            "week": "EARNINGS THIS WEEK",
            "week_preview": "EARNINGS NEXT WEEK",
            "pre": "pre-market",
            "post": "after-close",
            "pre_short": "pre",
            "post_short": "post",
            "est": "Est",
            "none": "No earnings this week",
            "none_week": "No earnings next week",
        }

    # Date header
    date_str = datetime.now().strftime("%b %d, %Y") if lang == "en" else datetime.now().strftime("%d. %b %Y")

    # Output for briefing
    output = []

    # Daily mode: show today's earnings
    if not week_only and today_list:
        output.append(f"📅 {labels['today']} — {date_str}\n")
        for e in sorted(today_list, key=lambda x: x.get("time", "zzz")):
            time_str = f" ({labels['pre']})" if e["time"] == "bmo" else f" ({labels['post']})" if e["time"] == "amc" else ""
            eps_str = f" — {labels['est']}: ${e['eps_estimate']:.2f}" if e.get("eps_estimate") else ""
            output.append(f"• {e['ticker']} — {e['name']}{time_str}{eps_str}")
        output.append("")

    if week_list:
        # Use different header for weekly preview mode
        week_label = labels['week_preview'] if week_only else labels['week']
        if week_only:
            # Show date range for weekly preview
            week_range = f"{week_start.strftime('%b %d')} - {week_end.strftime('%b %d')}"
            output.append(f"📅 {week_label} ({week_range})\n")
        else:
            output.append(f"📅 {week_label}\n")
        for e in sorted(week_list, key=lambda x: x["date"]):
            day_name = e["date"].strftime("%a %d.%m")
            time_str = f" ({labels['pre_short']})" if e["time"] == "bmo" else f" ({labels['post_short']})" if e["time"] == "amc" else ""
            output.append(f"• {day_name}: {e['ticker']} — {e['name']}{time_str}")
        output.append("")

    if output:
        print("\n".join(output))
    else:
        if args.verbose:
            no_earnings_label = labels['none_week'] if week_only else labels['none']
            print(f"📅 {no_earnings_label}")


def get_briefing_section() -> str:
    """Get earnings section for daily briefing (called by briefing.py)."""
    from io import StringIO
    import contextlib

    # Capture check output
    class Args:
        verbose = False

    f = StringIO()
    with contextlib.redirect_stdout(f):
        check_earnings(Args())

    return f.getvalue()


def get_earnings_context(symbols: list[str]) -> list[dict]:
    """
    Get recent earnings data (beats/misses) for symbols using OpenBB.

    Returns list of dicts with: symbol, eps_actual, eps_estimate, surprise, revenue_actual, revenue_estimate
    """
    if not OPENBB_BINARY:
        return []

    results = []
    for symbol in symbols[:10]:  # Limit to 10 symbols
        try:
            result = subprocess.run(
                [OPENBB_BINARY, symbol, '--earnings'],
                capture_output=True,
                text=True,
                timeout=30
            )
            if result.returncode == 0:
                try:
                    data = json.loads(result.stdout)
                    if isinstance(data, list) and data:
                        results.append({
                            'symbol': symbol,
                            'earnings': data[0] if isinstance(data[0], dict) else {}
                        })
                except json.JSONDecodeError:
                    pass
        except Exception:
            pass
    return results


def get_analyst_ratings(symbols: list[str]) -> list[dict]:
    """
    Get analyst upgrades/downgrades for symbols using OpenBB.

    Returns list of dicts with: symbol, rating, target_price, firm, direction
    """
    if not OPENBB_BINARY:
        return []

    results = []
    for symbol in symbols[:10]:  # Limit to 10 symbols
        try:
            result = subprocess.run(
                [OPENBB_BINARY, symbol, '--rating'],
                capture_output=True,
                text=True,
                timeout=30
            )
            if result.returncode == 0:
                try:
                    data = json.loads(result.stdout)
                    if isinstance(data, list) and data:
                        results.append({
                            'symbol': symbol,
                            'rating': data[0] if isinstance(data[0], dict) else {}
                        })
                except json.JSONDecodeError:
                    pass
        except Exception:
            pass
    return results


def main():
    parser = argparse.ArgumentParser(description="Earnings Calendar Tracker")
    subparsers = parser.add_subparsers(dest="command", help="Commands")
    
    # list command
    list_parser = subparsers.add_parser("list", help="List all upcoming earnings")
    list_parser.add_argument("--refresh", "-r", action="store_true", help="Force refresh")
    list_parser.set_defaults(func=list_earnings)
    
    # check command
    check_parser = subparsers.add_parser("check", help="Check today/this week")
    check_parser.add_argument("--verbose", "-v", action="store_true")
    check_parser.add_argument("--json", action="store_true", help="JSON output")
    check_parser.add_argument("--lang", default="en", help="Output language (en, de)")
    check_parser.add_argument("--week", action="store_true", help="Show full week preview (for weekly cron)")
    check_parser.set_defaults(func=check_earnings)
    
    # refresh command
    refresh_parser = subparsers.add_parser("refresh", help="Force refresh all data")
    refresh_parser.set_defaults(func=lambda a: refresh_earnings(load_portfolio(), force=True))
    
    args = parser.parse_args()
    
    if not args.command:
        parser.print_help()
        return
    
    args.func(args)


if __name__ == "__main__":
    main()