Oura Analytics

name: CI

on:
  push:
    branches: [master, main]
  pull_request:
    branches: [master, main]

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'
          cache: 'pip'

      - name: Install dependencies
        run: |
          pip install -r requirements.txt
          pip install -r requirements-dev.txt

      - name: Run tests
        run: pytest tests/ -v --tb=short

      - name: Run linter
        run: ruff check scripts/ tests/

      - name: Upload coverage
        if: always() && github.event_name == 'push'
        uses: codecov/codecov-action@v4
        with:
          files: ./coverage.xml
          fail_ci_if_error: false

  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

      - name: Install ruff
        run: pip install ruff

      - name: Run ruff linter
        run: ruff check scripts/ tests/

# Python
__pycache__/
*.py[cod]
*$py.class
*.so
.Python
*.egg-info/
dist/
build/
eggs/
*.egg

# Virtual environments
venv/
.venv/
ENV/
env/

# Secrets and credentials
.env
*.env
secrets.conf
tokens.json
*.pem
*.key

# IDE and editors
.vscode/
.idea/
*.swp
*.swo
*~
.project
.pydevproject
.settings/

# OS files
.DS_Store
.DS_Store?
._*
.Spotlight-V100
.Trashes
ehthumbs.db
Thumbs.db

# Local data and cache
cache/
*.log
*.sqlite
*.db

# Test and coverage
.pytest_cache/
.coverage
htmlcov/
.tox/
.nox/

# Jupyter
.ipynb_checkpoints/

# mypy
.mypy_cache/

.ai/
.worktrees/

repos:
- repo: https://github.com/astral-sh/ruff-pre-commit
  rev: v0.14.0
  hooks:
  - id: ruff
    args: [--fix]
  - id: ruff-format

- repo: https://github.com/pre-commit/pre-commit-hooks
  rev: v5.0.0
  hooks:
  - id: trailing-whitespace
  - id: end-of-file-fixer
  - id: check-yaml
  - id: check-added-large-files
    args: ["--maxkb=100"]

#!/usr/bin/env python3
"""
Daily Oura Health Report - Hybrid Format

Combines detailed metrics with driver analysis and sends via Telegram.
This is the main daily morning briefing script.
"""

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

# Add oura-analytics scripts directory to path
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))

from oura_api import OuraClient
from drivers import DriverAnalyzer, format_drivers_report
from baseline import build_baseline


def format_hours(seconds: int) -> str:
    """Format seconds as hours and minutes."""
    if not seconds:
        return "N/A"
    hours = seconds / 3600
    h = int(hours)
    m = int((hours - h) * 60)
    return f"{h}h {m}m"


def generate_report(date_str: str = None, baseline_days: int = 30) -> str:
    """Generate the daily Oura health report."""
    
    # Default to today (Oura labels sleep by the day you wake up)
    if date_str:
        target_date = date_str
    else:
        target_date = datetime.now().strftime("%Y-%m-%d")
    
    # Get Oura token
    token = os.environ.get("OURA_API_TOKEN")
    if not token:
        return "❌ Error: OURA_API_TOKEN not set"
    
    client = OuraClient(token, use_cache=False)
    
    # Fetch target day data
    # Note: Oura API filters by bedtime_start, not day field
    # So we query a range to catch sleep starting the night before
    # Using 2-day lookback to handle timezone edge cases (travel, DST)
    # Note: Oura API end_date is EXCLUSIVE, so add 1 day to include target
    target_dt = datetime.strptime(target_date, "%Y-%m-%d")
    range_start = (target_dt - timedelta(days=2)).strftime("%Y-%m-%d")
    range_end = (target_dt + timedelta(days=1)).strftime("%Y-%m-%d")
    sleep_data = client.get_sleep(range_start, range_end)
    readiness_data = client.get_readiness(range_start, range_end)
    
    # Filter to get records for our target day
    # Note: day field comparison assumes Oura account timezone matches report timezone
    sleep_for_day = [s for s in sleep_data if s.get("day") == target_date]
    readiness_for_day = [r for r in readiness_data if r.get("day") == target_date]
    
    if not sleep_for_day:
        return f"📭 No sleep data available for {target_date}"
    
    # Prefer "long_sleep" (main sleep) over naps; fallback to longest duration
    main_sleeps = [s for s in sleep_for_day if s.get("type") == "long_sleep"]
    if main_sleeps:
        sleep = max(main_sleeps, key=lambda s: s.get("total_sleep_duration", 0))
    else:
        # No long_sleep found, pick longest duration record
        sleep = max(sleep_for_day, key=lambda s: s.get("total_sleep_duration", 0))
    
    readiness = readiness_for_day[0] if readiness_for_day else {}
    
    # Fetch baseline data
    baseline_end = datetime.strptime(target_date, "%Y-%m-%d") - timedelta(days=1)
    baseline_start = baseline_end - timedelta(days=baseline_days)
    
    baseline_sleep = client.get_sleep(
        baseline_start.strftime("%Y-%m-%d"),
        baseline_end.strftime("%Y-%m-%d")
    )
    baseline_readiness = client.get_readiness(
        baseline_start.strftime("%Y-%m-%d"),
        baseline_end.strftime("%Y-%m-%d")
    )
    
    # Calculate baseline metrics
    baseline = build_baseline(baseline_sleep, baseline_readiness, baseline_days)
    
    # Build baseline dict for driver analyzer
    baseline_dict = {
        "sleep_hours": baseline.sleep_hours.mean if baseline.sleep_hours else 7.5,
        "efficiency": baseline.efficiency.mean if baseline.efficiency else 85.0,
        "deep_sleep": 1.5,
        "rem_sleep": 1.8,
        "hrv": baseline.hrv.mean if baseline.hrv else 40.0,
        "rhr": baseline.rhr.mean if baseline.rhr else 60.0,
        "readiness": baseline.readiness.mean if baseline.readiness else 75.0
    }
    
    analyzer = DriverAnalyzer(baseline_dict)
    
    # Analyze drivers
    sleep_drivers = analyzer.analyze_sleep_drivers(sleep)
    readiness_drivers = analyzer.analyze_readiness_drivers(sleep, readiness)
    
    readiness_score = readiness.get("score", 0) if readiness else 0
    suggestion = analyzer.generate_suggestion(readiness_score, readiness_drivers)
    
    # Build the report
    lines = []
    lines.append(f"📊 *Daily Oura Report - {target_date}*")
    lines.append("━" * 30)
    
    # Readiness (lead with most important metric)
    if readiness_score:
        baseline_ready = baseline.readiness.mean if baseline.readiness else 75.0
        delta_ready = readiness_score - baseline_ready
        delta_str = f"+{delta_ready:.0f}" if delta_ready > 0 else f"{delta_ready:.0f}"
        
        if readiness_score >= 85:
            emoji = "🟢"
        elif readiness_score >= 70:
            emoji = "🟡"
        else:
            emoji = "🔴"
        
        lines.append(f"\n{emoji} *Readiness: {readiness_score}/100* ({delta_str} vs baseline)")
        
        # Show negative drivers
        negative_drivers = [d for d in readiness_drivers if d.impact == "negative"]
        if negative_drivers:
            lines.append("   └─ *Factors pulling down:*")
            for driver in negative_drivers[:3]:
                lines.append(f"      • {driver.metric}: {driver.value:.0f} (baseline: {driver.baseline:.0f})")
    
    # Sleep metrics
    duration = sleep.get("total_sleep_duration")
    efficiency = sleep.get("efficiency")
    
    if duration:
        baseline_dur = baseline.sleep_hours.mean if baseline.sleep_hours else 7.5
        actual_dur = duration / 3600
        delta_dur = actual_dur - baseline_dur
        delta_str = f"+{delta_dur:.1f}h" if delta_dur > 0 else f"{delta_dur:.1f}h"
        
        lines.append(f"\n🌙 *Sleep: {format_hours(duration)}* ({delta_str} vs baseline)")
    
    if efficiency:
        baseline_eff = baseline.efficiency.mean if baseline.efficiency else 85.0
        delta_eff = efficiency - baseline_eff
        delta_str = f"+{delta_eff:.0f}%" if delta_eff > 0 else f"{delta_eff:.0f}%"
        
        lines.append(f"   Efficiency: {efficiency}% ({delta_str})")
    
    # Sleep stages
    deep = sleep.get("deep_sleep_duration")
    rem = sleep.get("rem_sleep_duration")
    light = sleep.get("light_sleep_duration")
    
    if deep or rem or light:
        lines.append("\n   *Sleep Stages:*")
        if deep:
            lines.append(f"      🌊 Deep: {format_hours(deep)}")
        if light:
            lines.append(f"      💡 Light: {format_hours(light)}")
        if rem:
            lines.append(f"      🧠 REM: {format_hours(rem)}")
    
    # HRV & RHR
    hrv = sleep.get("average_hrv")
    rhr = sleep.get("lowest_heart_rate")
    
    if hrv or rhr:
        lines.append("\n   *Recovery Markers:*")
        if hrv:
            baseline_hrv = baseline.hrv.mean if baseline.hrv else 40.0
            delta_hrv = hrv - baseline_hrv
            delta_str = f"+{delta_hrv:.0f}ms" if delta_hrv > 0 else f"{delta_hrv:.0f}ms"
            status = "🟢" if hrv >= baseline_hrv else "🟡"
            lines.append(f"      {status} HRV: {hrv}ms ({delta_str})")
        if rhr:
            baseline_rhr = baseline.rhr.mean if baseline.rhr else 60.0
            delta_rhr = rhr - baseline_rhr
            delta_str = f"+{delta_rhr:.0f}bpm" if delta_rhr > 0 else f"{delta_rhr:.0f}bpm"
            status = "🟢" if rhr <= baseline_rhr else "🟡"
            lines.append(f"      {status} RHR: {rhr}bpm ({delta_str})")
    
    # Bedtime/ latency
    latency = sleep.get("latency")
    bedtime = sleep.get("bedtime_start")
    
    if latency:
        lat_min = int(latency / 60)
        lines.append(f"\n   ⏱️ Sleep latency: {lat_min} min")
    
    # Actionable suggestion
    lines.append(f"\n💡 *{suggestion}*")
    lines.append("\n_Good morning! Have a great day._ ☀️")
    
    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Daily Oura Health Report (Hybrid)")
    parser.add_argument("--date", help="Date (YYYY-MM-DD, default: today - the day you woke up)")
    parser.add_argument("--baseline-days", type=int, default=30, help="Days for baseline")
    args = parser.parse_args()
    
    try:
        report = generate_report(args.date, args.baseline_days)
        print(report)
    except Exception as e:
        error_msg = f"❌ Error generating report: {e}"
        print(error_msg)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env bash
set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"

export PYTHONPATH="$REPO_ROOT/scripts:${PYTHONPATH:-}"

python3 "$SCRIPT_DIR/daily-oura-report-hybrid.py" "$@"

                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

   1. Definitions.

      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.

   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.

   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.

   END OF TERMS AND CONDITIONS

   APPENDIX: How to apply the Apache License to your work.

      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

   Copyright [yyyy] [name of copyright owner]

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.

[tool.pytest.ini_options]
testpaths = ["tests"]
python_files = ["test_*.py"]
python_classes = ["Test*"]
python_functions = ["test_*"]
addopts = "-v --tb=short"

[tool.ruff]
target-version = "py311"

[tool.ruff.lint]

# Development dependencies for Oura Analytics skill
pytest>=7.0
pytest-cov
pytz  # for timezone utilities in timezone_utils.py
ruff

# Oura Analytics Skill Dependencies
# Note: Uses Python's built-in urllib.request (no external HTTP library)
pytz
pyyaml

#!/usr/bin/env python3
"""
Oura Alerts - Readiness & Sleep Alerts

Sends Telegram notifications when metrics drop below thresholds.
Uses debounce, hysteresis, and configurable thresholds.
"""

import os
import sys
import json
import argparse
import urllib.request
import urllib.error
from datetime import datetime, timedelta
from pathlib import Path

# Add scripts directory to path for imports
sys.path.insert(0, str(Path(__file__).resolve().parent))

from oura_api import OuraClient
from config import AlertState, ConfigLoader, check_thresholds_with_quality


def seconds_to_hours(seconds):
    return round(seconds / 3600, 1) if seconds else None


def check_thresholds_legacy(sleep_data, readiness_data, thresholds):
    """Legacy threshold checking (simple, no debounce)."""
    readiness_by_day = {r.get("day"): r for r in readiness_data}

    alerts = []

    for day in sleep_data:
        date = day.get("day")
        readiness_record = readiness_by_day.get(date)
        readiness_score = readiness_record.get("score") if readiness_record else None

        efficiency = day.get("efficiency", 100)
        duration_sec = day.get("total_sleep_duration", 0)
        duration_hours = seconds_to_hours(duration_sec)

        day_alerts = []

        if readiness_score is not None and readiness_score < thresholds.get("readiness", 60):
            day_alerts.append(f"Readiness {readiness_score}")

        if efficiency < thresholds.get("efficiency", 80):
            day_alerts.append(f"Efficiency {efficiency}%")

        if duration_hours and duration_hours < thresholds.get("sleep_hours", 7):
            day_alerts.append(f"Sleep {duration_hours}h")

        if day_alerts:
            alerts.append({"date": date, "alerts": day_alerts})

    return alerts


# Keep the old name as an alias for backwards compatibility
def check_thresholds(sleep_data, readiness_data, thresholds):
    """Check all days against thresholds.

    Note: For debounce and hysteresis, use check_thresholds_with_quality() from config module.
    """
    return check_thresholds_legacy(sleep_data, readiness_data, thresholds)


def format_alert_message(alerts):
    """Format alerts for Telegram"""
    if not alerts:
        return None
    
    msg = "⚠️ *Oura Alerts*\n\n"
    
    for alert in alerts[-5:]:  # Last 5 alerts
        msg += f"📅 *{alert['date']}*\n"
        for a in alert["alerts"]:
            msg += f"   • {a}\n"
        msg += "\n"
    
    msg += f"_Total: {len(alerts)} alert days_"
    return msg


def send_telegram(message, chat_id=None, bot_token=None):
    """Send to Telegram using urllib"""
    chat_id = chat_id or os.environ.get("TELEGRAM_CHAT_ID")
    bot_token = bot_token or os.environ.get("KESSLER_TELEGRAM_BOT_TOKEN") or os.environ.get("TELEGRAM_BOT_TOKEN")

    if not chat_id or not bot_token:
        print("TELEGRAM_CHAT_ID or KESSLER_TELEGRAM_BOT_TOKEN not set")
        return False

    url = f"https://api.telegram.org/bot{bot_token}/sendMessage"
    # Keep chat_id as string to support both numeric IDs and @channel usernames
    data = json.dumps({"chat_id": chat_id, "text": message, "parse_mode": "Markdown"}).encode("utf-8")

    req = urllib.request.Request(url, data=data, headers={"Content-Type": "application/json"})

    try:
        with urllib.request.urlopen(req, timeout=10) as resp:
            return resp.status == 200
    except urllib.error.HTTPError:
        return False


def main():
    parser = argparse.ArgumentParser(description="Oura Alerts")
    parser.add_argument("--days", type=int, default=7, help="Check period")
    parser.add_argument("--readiness", type=int, default=60, help="Readiness threshold (legacy)")
    parser.add_argument("--efficiency", type=int, default=80, help="Efficiency threshold (legacy)")
    parser.add_argument("--sleep-hours", type=float, default=7, help="Sleep hours threshold (legacy)")
    parser.add_argument("--config", help="Path to config.yaml")
    parser.add_argument("--telegram", action="store_true", help="Send to Telegram")
    parser.add_argument("--token", help="Oura API token")

    args = parser.parse_args()

    end_date = datetime.now().strftime("%Y-%m-%d")
    start_date = (datetime.now() - timedelta(days=args.days)).strftime("%Y-%m-%d")

    try:
        client = OuraClient(args.token)
        sleep = client.get_sleep(start_date, end_date)
        readiness = client.get_readiness(start_date, end_date)

        # Use config file if specified, otherwise use CLI args
        if args.config:
            config_loader = ConfigLoader(Path(args.config))
            config = config_loader.load()
            state = AlertState()

            alerts = check_thresholds_with_quality(
                sleep, readiness, config, state
            )
        else:
            # Legacy mode: simple thresholds
            thresholds = {
                "readiness": args.readiness,
                "efficiency": args.efficiency,
                "sleep_hours": args.sleep_hours
            }
            alerts = check_thresholds_legacy(sleep, readiness, thresholds)

        if alerts:
            mode = "Quality Mode" if args.config else "Legacy Mode"
            print(f"\n⚠️  {mode}: {len(alerts)} Alert Days Found:\n")
            for alert in alerts:
                consecutive = alert.get("consecutive_days", "")
                if consecutive:
                    print(f"  {alert['date']} ({consecutive} bad days): {', '.join(alert['alerts'])}")
                else:
                    print(f"  {alert['date']}: {', '.join(alert['alerts'])}")

            if args.telegram:
                msg = format_alert_message(alerts)
                if msg and send_telegram(msg):
                    print("\n✅ Alerts sent to Telegram!")
                else:
                    print("\n❌ Telegram failed")
        else:
            mode = "Quality Mode" if args.config else "Legacy Mode"
            print(f"\n✅ {mode}: All metrics above thresholds!")

        # Save to file (portable path)
        output_dir = os.environ.get("OURA_OUTPUT_DIR", str(Path.home() / ".oura-analytics" / "reports"))
        alert_file = f"{output_dir}/oura_alerts_{end_date}.json"
        os.makedirs(output_dir, exist_ok=True)
        with open(alert_file, "w") as f:
            json.dump({"period": f"{start_date} to {end_date}", "alerts": alerts}, f, indent=2)
        print(f"\n💾 Saved to {alert_file}")
    
    except Exception as e:
        print(f"Error: {e}")
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Oura Baseline & Comparison Analysis

Calculate baselines from historical data and compare current metrics.
Provides statistical significance (z-score, percentiles) and actionable insights.
"""

import argparse
import sys
import json
from datetime import datetime, timedelta
from pathlib import Path
from typing import Dict, List, Optional, Tuple
from dataclasses import dataclass
import statistics

# Add scripts directory to path for imports
sys.path.insert(0, str(Path(__file__).resolve().parent))

from oura_api import OuraClient
# nightRecord unused - removed


@dataclass
class BaselineMetrics:
    """Statistical baseline for a metric."""
    mean: float
    median: float
    std_dev: float
    min: float
    max: float
    p25: float  # 25th percentile
    p75: float  # 75th percentile
    sample_size: int
    
    def z_score(self, value: float) -> float:
        """Calculate z-score (standard deviations from mean)."""
        if self.std_dev == 0:
            return 0.0
        return (value - self.mean) / self.std_dev
    
    def percentile_rank(self, value: float, samples: List[float]) -> float:
        """Calculate percentile rank of value in distribution."""
        if not samples:
            return 50.0
        below = sum(1 for s in samples if s < value)
        return (below / len(samples)) * 100
    
    def interpret_delta(self, value: float) -> Tuple[str, str, str]:
        """
        Interpret delta from baseline.
        Returns: (emoji, label, severity)
        """
        z = self.z_score(value)
        
        if z >= 1.5:
            return "🔥", "Well above baseline", "excellent"
        elif z >= 0.5:
            return "↗️", "Above baseline", "good"
        elif z >= -0.5:
            return "➡️", "Within baseline", "normal"
        elif z >= -1.5:
            return "↘️", "Below baseline", "attention"
        else:
            return "⚠️", "Well below baseline", "concern"


@dataclass
class Baseline:
    """Complete baseline analysis."""
    sleep_score: BaselineMetrics
    readiness: BaselineMetrics
    sleep_hours: BaselineMetrics
    efficiency: BaselineMetrics
    hrv: Optional[BaselineMetrics]
    rhr: Optional[BaselineMetrics]
    period_days: int
    end_date: str


def calculate_baseline_metrics(values: List[float]) -> Optional[BaselineMetrics]:
    """Calculate statistical baseline from a list of values."""
    if not values or len(values) < 3:
        return None
    
    sorted_values = sorted(values)
    
    try:
        return BaselineMetrics(
            mean=round(statistics.mean(values), 1),
            median=round(statistics.median(values), 1),
            std_dev=round(statistics.stdev(values), 1) if len(values) > 1 else 0,
            min=round(min(values), 1),
            max=round(max(values), 1),
            p25=round(sorted_values[len(values) // 4], 1),
            p75=round(sorted_values[3 * len(values) // 4], 1),
            sample_size=len(values)
        )
    except Exception:
        return None


def calculate_sleep_score(sleep_data: dict) -> float:
    """Calculate sleep score from sleep data (matches weekly_report.py logic)."""
    efficiency = sleep_data.get("efficiency", 0)
    duration_hours = sleep_data.get("total_sleep_duration", 0) / 3600 if sleep_data.get("total_sleep_duration") else 0
    
    eff_score = min(efficiency, 100)
    dur_score = min(duration_hours / 8 * 100, 100)
    return round((eff_score * 0.6) + (dur_score * 0.4), 1)


def build_baseline(sleep_data: List[dict], readiness_data: List[dict], period_days: int) -> Baseline:
    """Build baseline from historical data."""
    # Build readiness lookup
    readiness_by_day = {r.get("day"): r for r in readiness_data}
    
    # Extract metrics
    sleep_scores = []
    readiness_scores = []
    sleep_hours = []
    efficiencies = []
    hrv_values = []
    rhr_values = []
    
    for sleep in sleep_data:
        day = sleep.get("day")
        
        # Sleep score
        score = calculate_sleep_score(sleep)
        if score > 0:
            sleep_scores.append(score)
        
        # Sleep hours
        duration_sec = sleep.get("total_sleep_duration", 0)
        if duration_sec:
            sleep_hours.append(round(duration_sec / 3600, 1))
        
        # Efficiency
        eff = sleep.get("efficiency")
        if eff:
            efficiencies.append(eff)
        
        # HRV
        hrv = sleep.get("average_hrv")
        if hrv:
            hrv_values.append(hrv)
        
        # RHR
        rhr = sleep.get("lowest_heart_rate")
        if rhr:
            rhr_values.append(rhr)
        
        # Readiness
        r = readiness_by_day.get(day)
        if r and r.get("score"):
            readiness_scores.append(r["score"])
    
    return Baseline(
        sleep_score=calculate_baseline_metrics(sleep_scores),
        readiness=calculate_baseline_metrics(readiness_scores),
        sleep_hours=calculate_baseline_metrics(sleep_hours),
        efficiency=calculate_baseline_metrics(efficiencies),
        hrv=calculate_baseline_metrics(hrv_values) if hrv_values else None,
        rhr=calculate_baseline_metrics(rhr_values) if rhr_values else None,
        period_days=period_days,
        end_date=sleep_data[-1].get("day") if sleep_data else ""
    )


def compare_to_baseline(current_data: dict, baseline: Baseline, metric_name: str, current_value: float, baseline_metric: BaselineMetrics) -> Dict:
    """Compare current value to baseline and generate insight."""
    delta = current_value - baseline_metric.mean
    z_score = baseline_metric.z_score(current_value)
    emoji, label, severity = baseline_metric.interpret_delta(current_value)
    
    return {
        "metric": metric_name,
        "current": round(current_value, 1),
        "baseline_mean": baseline_metric.mean,
        "baseline_range": f"{baseline_metric.p25}-{baseline_metric.p75}",
        "delta": round(delta, 1),
        "z_score": round(z_score, 2),
        "emoji": emoji,
        "label": label,
        "severity": severity
    }


def format_baseline_report(baseline: Baseline) -> str:
    """Format baseline report for console output."""
    lines = []
    lines.append(f"\n📊 Baseline Analysis ({baseline.period_days}-day period)")
    lines.append(f"   Period ending: {baseline.end_date}")
    lines.append("")
    
    metrics = [
        ("Sleep Score", baseline.sleep_score, "/100"),
        ("Readiness", baseline.readiness, "/100"),
        ("Sleep Duration", baseline.sleep_hours, "h"),
        ("Efficiency", baseline.efficiency, "%"),
    ]
    
    if baseline.hrv:
        metrics.append(("HRV", baseline.hrv, "ms"))
    if baseline.rhr:
        metrics.append(("RHR", baseline.rhr, "bpm"))
    
    for name, metric, unit in metrics:
        if metric:
            lines.append(f"   {name}:")
            lines.append(f"      Mean: {metric.mean}{unit} (±{metric.std_dev})")
            lines.append(f"      Range: {metric.min}-{metric.max}{unit}")
            lines.append(f"      P25-P75: {metric.p25}-{metric.p75}{unit}")
            lines.append(f"      Samples: {metric.sample_size}")
            lines.append("")
    
    return "\n".join(lines)


def format_comparison_report(comparisons: List[Dict], period_label: str) -> str:
    """Format comparison report for console output."""
    lines = []
    lines.append(f"\n📈 Current vs Baseline ({period_label})")
    lines.append("")
    
    for comp in comparisons:
        emoji = comp["emoji"]
        metric = comp["metric"]
        current = comp["current"]
        delta = comp["delta"]
        z = comp["z_score"]
        label = comp["label"]
        
        delta_str = f"+{delta}" if delta > 0 else str(delta)
        lines.append(f"   {emoji} {metric}: {current} ({delta_str}, z={z})")
        lines.append(f"      {label}")
        lines.append("")
    
    # Summary
    concerns = [c for c in comparisons if c["severity"] == "concern"]
    if concerns:
        lines.append("⚠️  Metrics needing attention:")
        for c in concerns:
            lines.append(f"   • {c['metric']}: {c['label']}")
    else:
        lines.append("✅ All metrics within or above baseline range")
    
    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Oura Baseline & Comparison Analysis")
    parser.add_argument("--baseline-days", type=int, default=30, help="Days for baseline calculation (default: 30)")
    parser.add_argument("--current-days", type=int, default=7, help="Days for current period comparison (default: 7)")
    parser.add_argument("--token", help="Oura API token")
    parser.add_argument("--json", action="store_true", help="Output JSON format")
    parser.add_argument("--baseline-only", action="store_true", help="Show baseline without comparison")
    
    args = parser.parse_args()
    
    try:
        client = OuraClient(args.token)
        
        # Fetch baseline period data
        baseline_end = datetime.now()
        baseline_start = baseline_end - timedelta(days=args.baseline_days)
        
        baseline_sleep = client.get_sleep(
            baseline_start.strftime("%Y-%m-%d"),
            baseline_end.strftime("%Y-%m-%d")
        )
        baseline_readiness = client.get_readiness(
            baseline_start.strftime("%Y-%m-%d"),
            baseline_end.strftime("%Y-%m-%d")
        )
        
        # Calculate baseline
        baseline = build_baseline(baseline_sleep, baseline_readiness, args.baseline_days)
        
        if args.baseline_only:
            if args.json:
                print(json.dumps({
                    "baseline": {
                        "sleep_score": baseline.sleep_score.__dict__ if baseline.sleep_score else None,
                        "readiness": baseline.readiness.__dict__ if baseline.readiness else None,
                        "sleep_hours": baseline.sleep_hours.__dict__ if baseline.sleep_hours else None,
                        "efficiency": baseline.efficiency.__dict__ if baseline.efficiency else None,
                        "hrv": baseline.hrv.__dict__ if baseline.hrv else None,
                        "rhr": baseline.rhr.__dict__ if baseline.rhr else None,
                        "period_days": baseline.period_days,
                        "end_date": baseline.end_date
                    }
                }, indent=2))
            else:
                print(format_baseline_report(baseline))
            return
        
        # Fetch current period data
        current_end = datetime.now()
        current_start = current_end - timedelta(days=args.current_days)
        
        current_sleep = client.get_sleep(
            current_start.strftime("%Y-%m-%d"),
            current_end.strftime("%Y-%m-%d")
        )
        current_readiness = client.get_readiness(
            current_start.strftime("%Y-%m-%d"),
            current_end.strftime("%Y-%m-%d")
        )
        
        # Calculate current averages
        
        current_sleep_scores = [calculate_sleep_score(s) for s in current_sleep if calculate_sleep_score(s) > 0]
        current_readiness_scores = [r.get("score") for r in current_readiness if r.get("score")]
        current_sleep_hours = [s.get("total_sleep_duration", 0) / 3600 for s in current_sleep if s.get("total_sleep_duration")]
        current_efficiencies = [s.get("efficiency") for s in current_sleep if s.get("efficiency")]
        
        avg_sleep_score = statistics.mean(current_sleep_scores) if current_sleep_scores else 0
        avg_readiness = statistics.mean(current_readiness_scores) if current_readiness_scores else 0
        avg_sleep_hours = statistics.mean(current_sleep_hours) if current_sleep_hours else 0
        avg_efficiency = statistics.mean(current_efficiencies) if current_efficiencies else 0
        
        # Generate comparisons
        comparisons = []
        
        if baseline.sleep_score and avg_sleep_score:
            comparisons.append(compare_to_baseline({}, baseline, "Sleep Score", avg_sleep_score, baseline.sleep_score))
        
        if baseline.readiness and avg_readiness:
            comparisons.append(compare_to_baseline({}, baseline, "Readiness", avg_readiness, baseline.readiness))
        
        if baseline.sleep_hours and avg_sleep_hours:
            comparisons.append(compare_to_baseline({}, baseline, "Sleep Duration", avg_sleep_hours, baseline.sleep_hours))
        
        if baseline.efficiency and avg_efficiency:
            comparisons.append(compare_to_baseline({}, baseline, "Efficiency", avg_efficiency, baseline.efficiency))
        
        # Output
        period_label = f"Last {args.current_days}d vs {args.baseline_days}d baseline"
        
        if args.json:
            print(json.dumps({
                "baseline": {
                    "period_days": baseline.period_days,
                    "end_date": baseline.end_date
                },
                "current": {
                    "period_days": args.current_days,
                    "avg_sleep_score": round(avg_sleep_score, 1),
                    "avg_readiness": round(avg_readiness, 1),
                    "avg_sleep_hours": round(avg_sleep_hours, 1),
                    "avg_efficiency": round(avg_efficiency, 1)
                },
                "comparisons": comparisons
            }, indent=2))
        else:
            print(format_comparison_report(comparisons, period_label))
    
    except Exception as e:
        print(f"Error: {e}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Morning Briefing Formatter for Oura Analytics

Generates concise, actionable daily briefings with:
- Headline metrics with baseline context
- Driver analysis (what's causing the scores)
- Recovery status (GREEN/YELLOW/RED)
- Decision recommendations
- Pattern detection (trends, streaks)
"""

import sys
from pathlib import Path
from typing import Optional, Dict, Any, List, Tuple
from datetime import datetime

# Add scripts dir to path for imports
sys.path.insert(0, str(Path(__file__).parent))

from schema import NightRecord, SleepRecord, ReadinessRecord


class Baseline:
    """Baseline metrics calculated from historical data."""
    
    def __init__(self, 
                 avg_sleep_hours: float = 7.5,
                 avg_readiness: float = 75.0,
                 avg_hrv: float = 40.0,
                 avg_rhr: float = 60.0):
        self.avg_sleep_hours = avg_sleep_hours
        self.avg_readiness = avg_readiness
        self.avg_hrv = avg_hrv
        self.avg_rhr = avg_rhr
    
    @classmethod
    def from_history(cls, nights: List[NightRecord]) -> 'Baseline':
        """Calculate baseline from historical night records with outlier removal."""
        if not nights:
            return cls()
        
        # Calculate averages with outlier removal (remove top/bottom 10% if sample is large enough)
        sleep_hours = sorted([n.sleep.total_sleep_hours for n in nights if n.sleep])
        readiness_scores = sorted([n.readiness.score for n in nights if n.readiness])
        hrv_values = sorted([n.sleep.average_hrv_ms for n in nights if n.sleep and n.sleep.average_hrv_ms])
        rhr_values = sorted([n.sleep.lowest_heart_rate_bpm for n in nights if n.sleep and n.sleep.lowest_heart_rate_bpm])
        
        def robust_avg(values: List[float], default: float) -> float:
            """Calculate average with outlier removal (trim 10% from each end if n >= 10)."""
            if not values:
                return default
            if len(values) < 10:
                # Too few samples for outlier removal
                return sum(values) / len(values)
            
            # Remove top/bottom 10%
            trim = max(1, int(len(values) * 0.1))
            trimmed = values[trim:-trim]
            return sum(trimmed) / len(trimmed)
        
        return cls(
            avg_sleep_hours=robust_avg(sleep_hours, 7.5),
            avg_readiness=robust_avg(readiness_scores, 75.0),
            avg_hrv=robust_avg(hrv_values, 40.0),
            avg_rhr=robust_avg(rhr_values, 60.0)
        )


class BriefingFormatter:
    """Formats morning briefings with context and recommendations."""
    
    def __init__(self, baseline: Optional[Baseline] = None):
        self.baseline = baseline or Baseline()
    
    def format(self, night: NightRecord, verbose: bool = False) -> str:
        """
        Format a morning briefing.
        
        Args:
            night: NightRecord for the day
            verbose: Include additional detail
        
        Returns:
            Formatted briefing string
        """
        lines = []
        
        # Header
        lines.append(self._header(night.date))
        lines.append("")
        
        # Headline metrics
        if night.sleep:
            lines.append(self._sleep_line(night.sleep))
        
        if night.readiness:
            lines.append(self._readiness_line(night.readiness))
            if verbose:
                lines.append(self._driver_analysis(night.readiness))
        
        lines.append("")
        
        # Status and recommendation
        status, recommendation = self._get_status_and_recommendation(night)
        lines.append(f"Recovery Status: {status}")
        lines.append(f"Recommendation: {recommendation}")
        
        # Pattern detection
        if verbose:
            pattern = self._detect_pattern(night)
            if pattern:
                lines.append("")
                lines.append(f"Notable: {pattern}")
        
        return "\n".join(lines)
    
    def _header(self, date: str) -> str:
        """Format header with date."""
        dt = datetime.strptime(date, "%Y-%m-%d")
        return f"☀️  Morning Briefing ({dt.strftime('%b %d')})"
    
    def _sleep_line(self, sleep: SleepRecord) -> str:
        """Format sleep line with context."""
        hours = sleep.total_sleep_hours
        
        # Delta from baseline
        delta_hours = hours - self.baseline.avg_sleep_hours
        delta_min = int(delta_hours * 60)
        
        if abs(delta_min) < 15:
            delta_str = "on target"
            indicator = "✓"
        elif delta_min > 0:
            delta_str = f"↑{delta_min}min vs avg"
            indicator = "✓"
        else:
            delta_str = f"↓{abs(delta_min)}min vs avg"
            indicator = "⚠️" if abs(delta_min) > 60 else "○"
        
        # Format duration
        h = int(hours)
        m = int((hours - h) * 60)
        
        return f"Sleep: {h}h {m}m ({delta_str}) {indicator}"
    
    def _readiness_line(self, readiness: ReadinessRecord) -> str:
        """Format readiness line with context."""
        score = readiness.score
        
        # Delta from baseline
        delta = score - self.baseline.avg_readiness
        
        if score >= 85:
            indicator = "✓"
        elif score >= 70:
            indicator = "○"
        else:
            indicator = "⚠️"
        
        if abs(delta) < 3:
            delta_str = "stable"
        elif delta > 0:
            delta_str = f"↑{int(delta)} vs baseline"
        else:
            delta_str = f"↓{abs(int(delta))} vs baseline"
        
        return f"Readiness: {score} ({delta_str}) {indicator}"
    
    def _driver_analysis(self, readiness: ReadinessRecord) -> str:
        """Analyze what's driving readiness score."""
        # Identify low contributors
        contributors = {
            "HRV balance": readiness.hrv_balance,
            "Sleep balance": readiness.sleep_balance,
            "Recovery index": readiness.recovery_index,
            "RHR": readiness.resting_heart_rate,
            "Body temp": readiness.body_temperature,
            "Activity balance": readiness.activity_balance
        }
        
        # Filter out None values and sort by score
        valid_contributors = {k: v for k, v in contributors.items() if v is not None}
        sorted_contributors = sorted(valid_contributors.items(), key=lambda x: x[1])
        
        # Identify lowest contributors (<70)
        low = [k for k, v in sorted_contributors if v < 70]
        
        if low:
            drivers = ", ".join(low[:2])  # Top 2 lowest
            return f"└─ Driven by: {drivers}"
        else:
            return "└─ All contributors balanced"
    
    def _get_status_and_recommendation(self, night: NightRecord) -> Tuple[str, str]:
        """Determine recovery status and recommendation."""
        if not night.readiness:
            return "UNKNOWN", "Insufficient data"
        
        score = night.readiness.score
        
        if score >= 85:
            status = "🟢 GREEN"
            recommendation = "Optimal day. Ready for intensity."
        elif score >= 70:
            status = "🟡 YELLOW"
            recommendation = "Moderate day. Avoid heavy training."
        else:
            status = "🔴 RED"
            recommendation = "Recovery day. Light activity only."
        
        return status, recommendation
    
    def _detect_pattern(self, night: NightRecord) -> Optional[str]:
        """Detect notable patterns (placeholder for trend analysis)."""
        # This would require historical data for real trend detection
        # For now, just highlight extremes
        
        if night.sleep and night.sleep.total_sleep_hours >= 8.5:
            return "Excellent sleep duration"
        
        if night.readiness and night.readiness.score <= 65:
            return "Low readiness - prioritize recovery"
        
        if night.sleep and night.sleep.efficiency_percent >= 90:
            return "High sleep efficiency"
        
        return None


def format_brief_briefing(night: NightRecord, baseline: Optional[Baseline] = None) -> str:
    """
    Format a brief 3-line briefing (for notifications).
    
    Args:
        night: NightRecord for the day
        baseline: Optional baseline metrics
    
    Returns:
        3-line briefing string
    """
    formatter = BriefingFormatter(baseline)
    
    lines = []
    
    if night.sleep:
        hours = night.sleep.total_sleep_hours
        h = int(hours)
        m = int((hours - h) * 60)
        lines.append(f"Sleep: {h}h {m}m")
    
    if night.readiness:
        score = night.readiness.score
        if score >= 85:
            status = "Green"
        elif score >= 70:
            status = "Yellow"
        else:
            status = "Red"
        lines.append(f"Readiness: {score} ({status})")
    
    _, recommendation = formatter._get_status_and_recommendation(night)
    lines.append(recommendation)
    
    return "\n".join(lines)


def format_json_briefing(night: NightRecord, baseline: Optional[Baseline] = None) -> Dict[str, Any]:
    """
    Format briefing as JSON for API integration.
    
    Args:
        night: NightRecord for the day
        baseline: Optional baseline metrics
    
    Returns:
        Dictionary with briefing data
    """
    formatter = BriefingFormatter(baseline)
    status, recommendation = formatter._get_status_and_recommendation(night)
    
    # Extract status code (remove emoji)
    # Status format: "🟢 GREEN" → "GREEN"
    status_code = status.split()[-1] if status else "UNKNOWN"
    
    briefing = {
        "date": night.date,
        "sleep": None,
        "readiness": None,
        "status": status_code,
        "recommendation": recommendation
    }
    
    if night.sleep:
        briefing["sleep"] = {
            "duration_hours": round(night.sleep.total_sleep_hours, 2),
            "efficiency_percent": night.sleep.efficiency_percent,
            "hrv_ms": night.sleep.average_hrv_ms
        }
    
    if night.readiness:
        briefing["readiness"] = {
            "score": night.readiness.score,
            "delta_vs_baseline": round(night.readiness.score - formatter.baseline.avg_readiness, 1) if baseline else None,
            "low_contributors": _get_low_contributors(night.readiness)
        }
    
    return briefing


def _get_low_contributors(readiness: ReadinessRecord) -> List[str]:
    """Get list of low contributors (<70)."""
    contributors = {
        "hrv_balance": readiness.hrv_balance,
        "sleep_balance": readiness.sleep_balance,
        "recovery_index": readiness.recovery_index,
        "resting_heart_rate": readiness.resting_heart_rate,
        "body_temperature": readiness.body_temperature,
        "activity_balance": readiness.activity_balance
    }
    
    return [k for k, v in contributors.items() if v is not None and v < 70]


def format_hybrid_briefing(
    night: NightRecord, 
    baseline: Optional[Baseline] = None,
    week_data: Optional[Dict[str, Any]] = None
) -> str:
    """
    Format a hybrid daily report combining morning briefing with trend snapshot.
    
    This combines:
    1) Morning Briefing (top): actionable daily guidance with driver analysis
    2) Trend Snapshot (bottom): 7-day averages + recent sleep/readiness history
    
    Args:
        night: NightRecord for the day
        baseline: Optional baseline metrics
        week_data: Optional pre-calculated 7-day statistics
    
    Returns:
        Hybrid briefing string (≤12 lines for chat readability)
    """
    formatter = BriefingFormatter(baseline)
    
    lines = []
    
    # === SECTION 1: Morning Briefing ===
    lines.append(f"🌅 *Morning Briefing — {_format_date(night.date)}*")
    lines.append("─" * 24)
    
    # Sleep line with delta
    if night.sleep:
        hours = night.sleep.total_sleep_hours
        h = int(hours)
        m = int((hours - h) * 60)
        delta_min = int((hours - formatter.baseline.avg_sleep_hours) * 60)
        if abs(delta_min) < 15:
            delta_str = "on target"
        elif delta_min > 0:
            delta_str = f"↑{delta_min}min vs avg"
        else:
            delta_str = f"↓{abs(delta_min)}min vs avg"
        sleep_indicator = "✅" if abs(delta_min) < 60 else "⚠️"
        lines.append(f"💤 *Sleep*: {h}h {m}m ({delta_str}) {sleep_indicator}")
    
    # Readiness line with delta
    if night.readiness:
        score = night.readiness.score
        delta = score - formatter.baseline.avg_readiness
        if abs(delta) < 3:
            delta_str = "stable"
        elif delta > 0:
            delta_str = f"↑{int(delta)} vs baseline"
        else:
            delta_str = f"↓{abs(int(delta))} vs baseline"
        ready_indicator = "✅" if score >= 70 else "⚠️"
        lines.append(f"⚡ *Readiness*: {score} ({delta_str}) {ready_indicator}")
        
        # Driver analysis (compact)
        drivers = _get_low_contributors(night.readiness)
        if drivers:
            lines.append(f"*Drivers*: {', '.join(drivers[:2])}")
        else:
            lines.append("*Drivers*: All balanced")
    
    # Recovery status + recommendation
    status, recommendation = formatter._get_status_and_recommendation(night)
    lines.append(f"*Recovery*: {status}")
    lines.append(f"*Rec*: {recommendation}")
    
    # === SECTION 2: Trend Snapshot ===
    if week_data:
        lines.append("")
        lines.append("*📊 7-Day Trends*")
        lines.append("─" * 24)
        
        # 7-day averages with delta arrows
        avg_sleep = week_data.get("avg_sleep_score")
        avg_readiness = week_data.get("avg_readiness")
        avg_duration = week_data.get("avg_duration")
        avg_efficiency = week_data.get("avg_efficiency")
        avg_hrv = week_data.get("avg_hrv")
        
        # Sleep score with trend
        sleep_trend = week_data.get("sleep_trend", 0)
        if avg_sleep:
            trend_arrow = _trend_arrow(sleep_trend)
            lines.append(f"*Sleep Score*: `{avg_sleep:>2}` {trend_arrow}")
        
        # Readiness with trend
        readiness_trend = week_data.get("readiness_trend", 0)
        if avg_readiness:
            trend_arrow = _trend_arrow(readiness_trend)
            lines.append(f"*Readiness*: `{avg_readiness:>2}` {trend_arrow}")
        
        # Key metrics row
        metrics = []
        if avg_duration:
            metrics.append(f"*{avg_duration}h* sleep")
        if avg_efficiency:
            metrics.append(f"*{avg_efficiency}%* eff")
        if avg_hrv:
            metrics.append(f"*{avg_hrv}ms* HRV")
        if metrics:
            lines.append(f"• {' • '.join(metrics)}")
        
        # Last 2 nights
        last_2_days = week_data.get("last_2_days", [])
        if last_2_days and len(last_2_days) >= 2:
            d1 = last_2_days[-2]
            d2 = last_2_days[-1]
            d1_sleep = d1.get("sleep_score", "N/A")
            d1_ready = d1.get("readiness", "N/A")
            d2_sleep = d2.get("sleep_score", "N/A")
            d2_ready = d2.get("readiness", "N/A")
            
            d1_date = d1.get("day", "")[-5:]  # MM-DD
            d2_date = d2.get("day", "")[-5:]
            lines.append("")
            lines.append(f"*Recent*: {d1_date} → `{d1_sleep}`/`{d1_ready}` • {d2_date} → `{d2_sleep}`/`{d2_ready}`")
    
    return "\n".join(lines)


def _format_date(date_str: str) -> str:
    """Format date string for display."""
    dt = datetime.strptime(date_str, "%Y-%m-%d")
    return dt.strftime("%b %d")


def _trend_arrow(trend: float) -> str:
    """Get arrow indicator for trend value."""
    if trend > 1:
        return "↑"  # Trending up
    elif trend < -1:
        return "↓"  # Trending down
    else:
        return "→"  # Stable


if __name__ == "__main__":
    import argparse
    from oura_api import OuraClient
    from schema import create_night_record

    parser = argparse.ArgumentParser(description="Oura Morning Briefing")
    parser.add_argument("--date", help="Date (YYYY-MM-DD, default: yesterday)")
    parser.add_argument("--format", choices=["brief", "hybrid", "json"], default="hybrid")
    parser.add_argument("--token", help="Oura API token")
    args = parser.parse_args()

    # Default to today (same-day briefing)
    if args.date:
        target_date = args.date
    else:
        target_date = datetime.now().strftime("%Y-%m-%d")

    try:
        client = OuraClient(args.token)
        sleep_data = client.get_sleep(target_date, target_date)
        readiness_data = client.get_readiness(target_date, target_date)

        if not sleep_data:
            print(f"No data for {target_date}")
            sys.exit(1)

        # Build NightRecord from API response using schema normalizer
        night = create_night_record(
            date=target_date,
            sleep=sleep_data[0] if sleep_data else None,
            readiness=readiness_data[0] if readiness_data else None
        )

        if args.format == "json":
            import json
            print(json.dumps(format_json_briefing(night), indent=2))
        elif args.format == "brief":
            print(format_brief_briefing(night))
        else:
            print(format_hybrid_briefing(night))

    except Exception as e:
        print(f"Error: {e}", file=sys.stderr)
        sys.exit(1)