main.py

"""
Main entry point — orchestrates the 4 phases end-to-end.

Usage:
    python main.py --portfolio PORTFOLIO_001
    python main.py --portfolio all
    python main.py --portfolio PORTFOLIO_002 --export outputs/briefing.json

This file is deliberately short and linear. Read it top-to-bottom to
understand how the pipeline flows:

    DATA LOAD
        ↓
    PHASE 1 (Market Intelligence)
        ↓
    PHASE 2 (Portfolio Analytics)
        ↓
    PHASE 3 (Reasoning Agent → Causal Chain)
        ↓
    LLM / TEMPLATE (natural-language briefing)
        ↓
    PHASE 4 (Self-evaluation → Confidence score)
        ↓
    DISPLAY (Rich CLI output)
"""
from __future__ import annotations

import argparse
import sys
import time
from pathlib import Path

# Load env vars from .env if present (no hard dep on python-dotenv at runtime)
try:
    from dotenv import load_dotenv
    load_dotenv()
except ImportError:
    pass

from src.data_loader import DataLoader
from src.display import render_briefing
from src.llm import synthesise_briefing
from src.models import Briefing
from src.phase1_market_intelligence import run_market_intelligence
from src.phase2_portfolio_analytics import run_portfolio_analytics
from src.phase3_reasoning_agent import run_reasoning_agent
from src.phase4_observability import (
    compute_confidence,
    export_briefing_json,
    log_phase,
    trace_run,
)


def _timed(fn, *args, **kwargs):
    """Run fn, return (result, elapsed_ms). Used to time each phase."""
    t0 = time.time()
    result = fn(*args, **kwargs)
    return result, (time.time() - t0) * 1000

DATA_DIR = Path(__file__).parent / "data" / "json"


def analyse_portfolio(loader: DataLoader, portfolio_id: str, export_path: str | None = None) -> Briefing:
    """Run the full pipeline for a single portfolio and return the Briefing.

    Wrapped in `trace_run` so Langfuse (when configured) groups all phase
    spans and the LLM generation under a single trace per portfolio run.
    """
    with trace_run(name=f"analyse_{portfolio_id}", metadata={"portfolio_id": portfolio_id}):
        # ------------------- Load raw data -------------------
        t0 = time.time()
        portfolio = loader.load_portfolio(portfolio_id)
        indices = loader.load_indices()
        sectors = loader.load_sectors()
        stocks = loader.load_stocks()
        news = loader.load_news()
        context = loader.load_market_context()
        macro_correlations = loader.macro_correlations()
        log_phase("data_load", {
            "portfolio": portfolio_id,
            "indices": len(indices),
            "sectors": len(sectors),
            "stocks": len(stocks),
            "news": len(news),
        }, latency_ms=(time.time() - t0) * 1000)

        # ------------------- Phase 1 -------------------
        market, p1_ms = _timed(run_market_intelligence, indices, sectors, context, news)
        log_phase("phase1_market_intelligence", {
            "sentiment": market.sentiment,
            "active_themes": market.active_macro_themes,
        }, latency_ms=p1_ms)

        # ------------------- Phase 2 -------------------
        analytics, p2_ms = _timed(run_portfolio_analytics, portfolio)
        log_phase("phase2_portfolio_analytics", {
            "pnl_percent": analytics.total_pnl_percent,
            "max_sector_weight": analytics.max_sector_weight,
            "risks": len(analytics.concentration_risks),
        }, latency_ms=p2_ms)

        # ------------------- Phase 3 -------------------
        causal, p3_ms = _timed(
            run_reasoning_agent, portfolio, analytics, market, stocks, macro_correlations,
        )
        log_phase("phase3_reasoning", {
            "primary_driver": causal.primary_driver,
            "stock_impacts": len(causal.stock_impacts),
            "conflicts": len(causal.conflicts),
            "counterfactuals": len(causal.counterfactuals),
            "spillover_sectors": causal.spillover_sectors,
        }, latency_ms=p3_ms)

        # ------------------- LLM / Template synthesis -------------------
        narrative, used_llm, tokens_in, tokens_out, latency_ms = synthesise_briefing(
            portfolio, analytics, market, causal
        )

        # ------------------- Phase 4 — Self-evaluation -------------------
        confidence, p4_ms = _timed(compute_confidence, portfolio, analytics, causal, stocks)
        log_phase("phase4_evaluation", {
            "confidence_overall": confidence.overall,
            "reasoning_quality": confidence.reasoning_quality,
        }, latency_ms=p4_ms)

        # ------------------- Assemble final briefing -------------------
        briefing = Briefing(
            portfolio=portfolio,
            market=market,
            analytics=analytics,
            causal=causal,
            confidence=confidence,
            narrative=narrative,
            llm_used=used_llm,
            llm_tokens_in=tokens_in,
            llm_tokens_out=tokens_out,
            llm_latency_ms=latency_ms,
        )

        if export_path:
            export_briefing_json(briefing, export_path)

        return briefing


def main() -> int:
    parser = argparse.ArgumentParser(description="Autonomous Financial Advisor Agent")
    parser.add_argument(
        "--portfolio",
        default="PORTFOLIO_001",
        help="Portfolio id (PORTFOLIO_001 / 002 / 003) or 'all'",
    )
    parser.add_argument(
        "--export",
        default=None,
        help="Optional path to save the briefing as JSON",
    )
    args = parser.parse_args()

    loader = DataLoader(DATA_DIR)

    if args.portfolio.lower() == "all":
        for pid in loader.load_all_portfolios().keys():
            briefing = analyse_portfolio(loader, pid)
            render_briefing(briefing)
            print()  # spacer between portfolios
    else:
        briefing = analyse_portfolio(loader, args.portfolio, args.export)
        render_briefing(briefing)

    return 0


if __name__ == "__main__":
    sys.exit(main())