@drico2008/fincli 0.1.9 → 0.3.0

package/fincli/app/storage/config.py

@@ -1,112 +1,146 @@
-"""Configuration loading and persistence.
-
-Secrets are read from environment variables. Non-secret preferences are stored
-in a local JSON config file under ~/.fincli by default.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-import json
-import os
-from pathlib import Path
-from typing import Any
-
+"""Configuration loading and persistence.
+
+Secrets are read from environment variables. Non-secret preferences are stored
+in a local JSON config file under ~/.fincli by default.
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+import json
+import os
+from pathlib import Path
+from typing import Any
+
 try:
-    from dotenv import load_dotenv
+    from dotenv import dotenv_values, load_dotenv
 except ImportError:  # pragma: no cover - dependency exists in normal install
     load_dotenv = None  # type: ignore[assignment]
-
-from fincli.app.utils.errors import ConfigError
-from fincli.app.utils.formatting import mask_secret
-from fincli.app.storage.config_paths import APP_DIR, CONFIG_FILE
-from fincli.app.storage.secrets import load_local_secrets
-
-
-@dataclass(slots=True)
-class FinCLISettings:
-    ai_provider: str = "openrouter"
-    ai_model: str = "openai/gpt-4o-mini"
+    dotenv_values = None  # type: ignore[assignment]
+
+from fincli.app.utils.errors import ConfigError
+from fincli.app.utils.formatting import mask_secret
+from fincli.app.storage.config_paths import APP_DIR, CONFIG_FILE
+from fincli.app.storage.secrets import load_local_secrets
+
+
+@dataclass(slots=True)
+class FinCLISettings:
+    ai_provider: str = "openrouter"
+    ai_model: str = "openai/gpt-4o-mini"
     market_provider: str = "yfinance"
     news_provider: str = "yfinance"
     market_provider_priority: list[str] = field(default_factory=lambda: ["yfinance"])
+    news_provider_priority: list[str] = field(
+        default_factory=lambda: ["yfinance", "google_news_rss", "yahoo_finance_rss", "marketaux", "newsapi", "gnews"]
+    )
     timezone: str = "Asia/Jakarta"
-    default_currency: str = "USD"
-    cache_ttl_seconds: int = 300
-    theme: str = "fincli-dark"
-
-    def safe_dict(self) -> dict[str, Any]:
-        """Return display-safe config, including masked secret status."""
-        data = asdict(self)
-        data["api_keys"] = {
-            "openrouter": mask_secret(os.getenv("OPENROUTER_API_KEY")),
-            "gemini": mask_secret(os.getenv("GEMINI_API_KEY")),
-            "anthropic": mask_secret(os.getenv("ANTHROPIC_API_KEY")),
-            "openai": mask_secret(os.getenv("OPENAI_API_KEY")),
-            "together": mask_secret(os.getenv("TOGETHER_API_KEY")),
-            "huggingface": mask_secret(os.getenv("HUGGINGFACE_API_KEY")),
-            "groq": mask_secret(os.getenv("GROQ_API_KEY")),
-            "market_data": mask_secret(os.getenv("MARKET_DATA_API_KEY")),
+    default_currency: str = "USD"
+    cache_ttl_seconds: int = 300
+    theme: str = "fincli-dark"
+
+    def safe_dict(self) -> dict[str, Any]:
+        """Return display-safe config, including masked secret status."""
+        data = asdict(self)
+        data["api_keys"] = {
+            "openrouter": mask_secret(os.getenv("OPENROUTER_API_KEY")),
+            "gemini": mask_secret(os.getenv("GEMINI_API_KEY")),
+            "anthropic": mask_secret(os.getenv("ANTHROPIC_API_KEY")),
+            "openai": mask_secret(os.getenv("OPENAI_API_KEY")),
+            "together": mask_secret(os.getenv("TOGETHER_API_KEY")),
+            "huggingface": mask_secret(os.getenv("HUGGINGFACE_API_KEY")),
+            "groq": mask_secret(os.getenv("GROQ_API_KEY")),
+            "market_data": mask_secret(os.getenv("MARKET_DATA_API_KEY")),
             "news_data": mask_secret(os.getenv("NEWS_DATA_API_KEY")),
             "finnhub": mask_secret(os.getenv("FINNHUB_API_KEY")),
             "twelvedata": mask_secret(os.getenv("TWELVE_DATA_API_KEY")),
+            "alphavantage": mask_secret(os.getenv("ALPHA_VANTAGE_API_KEY")),
+            "marketaux": mask_secret(os.getenv("MARKETAUX_API_KEY")),
+            "newsapi": mask_secret(os.getenv("NEWSAPI_API_KEY")),
+            "gnews": mask_secret(os.getenv("GNEWS_API_KEY")),
+            "stocknewsapi": mask_secret(os.getenv("STOCKNEWSAPI_API_KEY")),
+            "apitube": mask_secret(os.getenv("APITUBE_API_KEY")),
+            "benzinga": mask_secret(os.getenv("BENZINGA_API_KEY")),
+            "polygon": mask_secret(os.getenv("POLYGON_API_KEY")),
+            "tiingo": mask_secret(os.getenv("TIINGO_API_KEY")),
+            "fmp": mask_secret(os.getenv("FMP_API_KEY")),
+            "eodhd": mask_secret(os.getenv("EODHD_API_KEY")),
+            "custom_news": mask_secret(os.getenv("CUSTOM_NEWS_API_KEY") or os.getenv("NEWS_DATA_API_KEY")),
         }
         return data
-
-
-class ConfigManager:
-    """Load, update, and persist non-secret FinCLI settings."""
-
-    def __init__(self, config_file: Path = CONFIG_FILE) -> None:
-        self.config_file = config_file
-        self.settings = self.load()
-
+
+
+class ConfigManager:
+    """Load, update, and persist non-secret FinCLI settings."""
+
+    def __init__(self, config_file: Path = CONFIG_FILE) -> None:
+        self.config_file = config_file
+        self.settings = self.load()
+
     def load(self) -> FinCLISettings:
+        dotenv_loaded_keys: set[str] = set()
         if load_dotenv is not None:
+            before_env = dict(os.environ)
             load_dotenv()
-        load_local_secrets()
-
-        if not self.config_file.exists():
-            return FinCLISettings()
-
-        try:
-            raw = json.loads(self.config_file.read_text(encoding="utf-8"))
-            allowed = FinCLISettings.__dataclass_fields__.keys()
-            filtered = {key: value for key, value in raw.items() if key in allowed}
-            return FinCLISettings(**filtered)
-        except Exception as exc:  # noqa: BLE001
-            raise ConfigError(
-                "Config lokal gagal dibaca.",
-                "Periksa ~/.fincli/config.json atau hapus file tersebut untuk memakai default.",
-            ) from exc
-
-    def save(self) -> None:
-        try:
-            self.config_file.parent.mkdir(parents=True, exist_ok=True)
-            self.config_file.write_text(
-                json.dumps(asdict(self.settings), indent=2),
-                encoding="utf-8",
-            )
-        except Exception as exc:  # noqa: BLE001
-            raise ConfigError("Config lokal gagal disimpan.") from exc
-
-    def set_ai_model(self, provider: str, model: str) -> None:
-        self.settings.ai_provider = provider.strip().lower()
-        self.settings.ai_model = model.strip()
-        self.save()
-
-    def set_market_provider(self, provider: str) -> None:
-        self.settings.market_provider = provider.strip().lower()
-        self.save()
-
+            if dotenv_values is not None:
+                dotenv_loaded_keys = {
+                    key
+                    for key, value in dotenv_values().items()
+                    if key and value is not None and (key not in before_env or before_env.get(key, "") == "")
+                }
+        # API keys saved from FinCLI commands should override stale project .env values,
+        # while explicit OS/process environment variables remain respected.
+        load_local_secrets(override_keys=dotenv_loaded_keys)
+
+        if not self.config_file.exists():
+            return FinCLISettings()
+
+        try:
+            raw = json.loads(self.config_file.read_text(encoding="utf-8"))
+            allowed = FinCLISettings.__dataclass_fields__.keys()
+            filtered = {key: value for key, value in raw.items() if key in allowed}
+            return FinCLISettings(**filtered)
+        except Exception as exc:  # noqa: BLE001
+            raise ConfigError(
+                "Config lokal gagal dibaca.",
+                "Periksa ~/.fincli/config.json atau hapus file tersebut untuk memakai default.",
+            ) from exc
+
+    def save(self) -> None:
+        try:
+            self.config_file.parent.mkdir(parents=True, exist_ok=True)
+            self.config_file.write_text(
+                json.dumps(asdict(self.settings), indent=2),
+                encoding="utf-8",
+            )
+        except Exception as exc:  # noqa: BLE001
+            raise ConfigError("Config lokal gagal disimpan.") from exc
+
+    def set_ai_model(self, provider: str, model: str) -> None:
+        self.settings.ai_provider = provider.strip().lower()
+        self.settings.ai_model = model.strip()
+        self.save()
+
+    def set_market_provider(self, provider: str) -> None:
+        self.settings.market_provider = provider.strip().lower()
+        self.save()
+
     def set_news_provider(self, provider: str) -> None:
         self.settings.news_provider = provider.strip().lower()
         self.save()
 
-    def set_market_provider_priority(self, providers: list[str]) -> None:
+    def set_news_provider_priority(self, providers: list[str]) -> None:
         normalized = [provider.strip().lower() for provider in providers if provider.strip()]
         if not normalized:
-            normalized = ["yfinance"]
+            normalized = ["yfinance", "google_news_rss", "yahoo_finance_rss"]
+        self.settings.news_provider_priority = normalized
+        self.settings.news_provider = normalized[0]
+        self.save()
+
+    def set_market_provider_priority(self, providers: list[str]) -> None:
+        normalized = [provider.strip().lower() for provider in providers if provider.strip()]
+        if not normalized:
+            normalized = ["yfinance"]
         self.settings.market_provider_priority = normalized
         self.settings.market_provider = normalized[0]
         self.settings.news_provider = normalized[0]

package/fincli/app/storage/database.py

@@ -1,118 +1,228 @@
-"""SQLite storage for FinCLI local data."""
-
-from __future__ import annotations
-
-from pathlib import Path
-from contextlib import closing
-import sqlite3
-from typing import Iterable
-
-from fincli.app.storage.config import APP_DIR
-from fincli.app.utils.errors import StorageError
-
-
-DB_FILE = APP_DIR / "fincli.db"
-
-
-class FinCLIDatabase:
-    """Small SQLite wrapper for watchlist, portfolio, and journal data."""
-
-    def __init__(self, db_file: Path = DB_FILE) -> None:
-        self.db_file = db_file
-        self.db_file.parent.mkdir(parents=True, exist_ok=True)
-        self.initialize()
-
-    def connect(self) -> sqlite3.Connection:
-        connection = sqlite3.connect(self.db_file)
-        connection.row_factory = sqlite3.Row
-        return connection
-
-    def initialize(self) -> None:
-        try:
-            with closing(self.connect()) as db:
-                with db:
-                    db.executescript(
-                        """
-                        CREATE TABLE IF NOT EXISTS watchlist (
-                            symbol TEXT PRIMARY KEY,
-                            group_name TEXT DEFAULT 'default',
-                            created_at TEXT DEFAULT CURRENT_TIMESTAMP
-                        );
-
-                        CREATE TABLE IF NOT EXISTS portfolio_positions (
-                            symbol TEXT PRIMARY KEY,
-                            quantity REAL NOT NULL,
-                            average_price REAL NOT NULL,
-                            currency TEXT DEFAULT 'USD',
-                            created_at TEXT DEFAULT CURRENT_TIMESTAMP,
-                            updated_at TEXT DEFAULT CURRENT_TIMESTAMP
-                        );
-
-                        CREATE TABLE IF NOT EXISTS journal_entries (
+"""SQLite storage for FinCLI local data."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from contextlib import closing
+import sqlite3
+from typing import Iterable
+
+from fincli.app.storage.config import APP_DIR
+from fincli.app.utils.errors import StorageError
+
+
+DB_FILE = APP_DIR / "fincli.db"
+
+
+class FinCLIDatabase:
+    """Small SQLite wrapper for watchlist, portfolio, and journal data."""
+
+    def __init__(self, db_file: Path = DB_FILE) -> None:
+        self.db_file = db_file
+        self.db_file.parent.mkdir(parents=True, exist_ok=True)
+        self.initialize()
+
+    def connect(self) -> sqlite3.Connection:
+        connection = sqlite3.connect(self.db_file)
+        connection.row_factory = sqlite3.Row
+        return connection
+
+    def initialize(self) -> None:
+        try:
+            with closing(self.connect()) as db:
+                with db:
+                    db.executescript(
+                        """
+                        CREATE TABLE IF NOT EXISTS watchlist (
+                            symbol TEXT PRIMARY KEY,
+                            group_name TEXT DEFAULT 'default',
+                            created_at TEXT DEFAULT CURRENT_TIMESTAMP
+                        );
+
+                        CREATE TABLE IF NOT EXISTS portfolio_positions (
+                            symbol TEXT PRIMARY KEY,
+                            quantity REAL NOT NULL,
+                            average_price REAL NOT NULL,
+                            currency TEXT DEFAULT 'USD',
+                            created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+                            updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+                        );
+
+                        CREATE TABLE IF NOT EXISTS journal_entries (
+                            id INTEGER PRIMARY KEY AUTOINCREMENT,
+                            instrument TEXT NOT NULL,
+                            bias TEXT DEFAULT '',
+                            entry_reason TEXT DEFAULT '',
+                            exit_reason TEXT DEFAULT '',
+                            result TEXT DEFAULT '',
+                            emotion TEXT DEFAULT '',
+                            lesson TEXT DEFAULT '',
+                            tags TEXT DEFAULT '',
+                            created_at TEXT DEFAULT CURRENT_TIMESTAMP
+                        );
+
+                        CREATE TABLE IF NOT EXISTS portfolio_transactions (
+                            id INTEGER PRIMARY KEY AUTOINCREMENT,
+                            action TEXT NOT NULL,
+                            symbol TEXT NOT NULL,
+                            quantity REAL NOT NULL,
+                            price REAL NOT NULL,
+                            currency TEXT DEFAULT 'USD',
+                            realized_pnl REAL DEFAULT 0,
+                            created_at TEXT DEFAULT CURRENT_TIMESTAMP
+                        );
+
+                        CREATE TABLE IF NOT EXISTS market_cache (
+                            namespace TEXT NOT NULL,
+                            cache_key TEXT NOT NULL,
+                            payload TEXT NOT NULL,
+                            expires_at REAL NOT NULL,
+                            created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+                            PRIMARY KEY (namespace, cache_key)
+                        );
+
+                        CREATE TABLE IF NOT EXISTS sessions (
+                            id TEXT PRIMARY KEY,
+                            title TEXT NOT NULL,
+                            created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+                            updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+                        );
+
+                        CREATE TABLE IF NOT EXISTS session_events (
+                            id INTEGER PRIMARY KEY AUTOINCREMENT,
+                            session_id TEXT NOT NULL,
+                            command TEXT NOT NULL,
+                            status TEXT NOT NULL,
+                            output_preview TEXT DEFAULT '',
+                            created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+                            FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+                        );
+
+                        CREATE TABLE IF NOT EXISTS alerts (
                             id INTEGER PRIMARY KEY AUTOINCREMENT,
-                            instrument TEXT NOT NULL,
-                            bias TEXT DEFAULT '',
-                            entry_reason TEXT DEFAULT '',
-                            exit_reason TEXT DEFAULT '',
-                            result TEXT DEFAULT '',
-                            emotion TEXT DEFAULT '',
-                            lesson TEXT DEFAULT '',
-                            tags TEXT DEFAULT '',
-                            created_at TEXT DEFAULT CURRENT_TIMESTAMP
-                        );
-
-                        CREATE TABLE IF NOT EXISTS portfolio_transactions (
-                            id INTEGER PRIMARY KEY AUTOINCREMENT,
-                            action TEXT NOT NULL,
                             symbol TEXT NOT NULL,
-                            quantity REAL NOT NULL,
-                            price REAL NOT NULL,
-                            currency TEXT DEFAULT 'USD',
-                            realized_pnl REAL DEFAULT 0,
+                            condition TEXT NOT NULL,
+                            target REAL NOT NULL,
+                            note TEXT DEFAULT '',
+                            active INTEGER DEFAULT 1,
+                            triggered_at TEXT DEFAULT '',
                             created_at TEXT DEFAULT CURRENT_TIMESTAMP
                         );
 
-                        CREATE TABLE IF NOT EXISTS market_cache (
-                            namespace TEXT NOT NULL,
-                            cache_key TEXT NOT NULL,
-                            payload TEXT NOT NULL,
-                            expires_at REAL NOT NULL,
-                            created_at TEXT DEFAULT CURRENT_TIMESTAMP,
-                            PRIMARY KEY (namespace, cache_key)
-                        );
-
-                        CREATE TABLE IF NOT EXISTS sessions (
-                            id TEXT PRIMARY KEY,
-                            title TEXT NOT NULL,
-                            created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+                        CREATE TABLE IF NOT EXISTS user_profile (
+                            id INTEGER PRIMARY KEY CHECK (id = 1),
+                            name TEXT NOT NULL,
+                            equity REAL NOT NULL,
+                            currency TEXT NOT NULL,
+                            leverage TEXT NOT NULL,
+                            years_in_investment REAL NOT NULL,
+                            gameplay TEXT NOT NULL,
                             updated_at TEXT DEFAULT CURRENT_TIMESTAMP
                         );
 
-                        CREATE TABLE IF NOT EXISTS session_events (
-                            id INTEGER PRIMARY KEY AUTOINCREMENT,
-                            session_id TEXT NOT NULL,
-                            command TEXT NOT NULL,
-                            status TEXT NOT NULL,
-                            output_preview TEXT DEFAULT '',
-                            created_at TEXT DEFAULT CURRENT_TIMESTAMP,
-                            FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+                        CREATE TABLE IF NOT EXISTS provider_metrics (
+                            provider TEXT PRIMARY KEY,
+                            calls INTEGER DEFAULT 0,
+                            successes INTEGER DEFAULT 0,
+                            errors INTEGER DEFAULT 0,
+                            fallbacks INTEGER DEFAULT 0,
+                            total_latency_ms REAL DEFAULT 0,
+                            last_status TEXT DEFAULT 'not_called',
+                            updated_at TEXT DEFAULT CURRENT_TIMESTAMP
                         );
                         """
                     )
+                    _migrate_user_profile_schema(db)
         except sqlite3.Error as exc:
             raise StorageError("Database lokal gagal diinisialisasi.") from exc
-
-    def execute(self, sql: str, params: Iterable[object] = ()) -> None:
-        try:
-            with closing(self.connect()) as db:
-                with db:
-                    db.execute(sql, tuple(params))
-        except sqlite3.Error as exc:
-            raise StorageError("Operasi database gagal.") from exc
-
+
+    def execute(self, sql: str, params: Iterable[object] = ()) -> None:
+        try:
+            with closing(self.connect()) as db:
+                with db:
+                    db.execute(sql, tuple(params))
+        except sqlite3.Error as exc:
+            raise StorageError("Operasi database gagal.") from exc
+
     def query(self, sql: str, params: Iterable[object] = ()) -> list[sqlite3.Row]:
         try:
             with closing(self.connect()) as db:
                 return list(db.execute(sql, tuple(params)).fetchall())
         except sqlite3.Error as exc:
             raise StorageError("Query database gagal.") from exc
+
+
+def _migrate_user_profile_schema(db: sqlite3.Connection) -> None:
+    """Normalize older user_profile schemas to the v0.3.0 canonical shape."""
+
+    columns = {str(row["name"]) for row in db.execute("PRAGMA table_info(user_profile)").fetchall()}
+    canonical = {"id", "name", "equity", "currency", "leverage", "years_in_investment", "gameplay", "updated_at"}
+    if canonical.issubset(columns):
+        return
+
+    rows = list(db.execute("SELECT * FROM user_profile").fetchall())
+    legacy_profile = _legacy_profile_payload(rows[0]) if rows else None
+    db.execute("DROP TABLE user_profile")
+    db.execute(
+        """
+        CREATE TABLE user_profile (
+            id INTEGER PRIMARY KEY CHECK (id = 1),
+            name TEXT NOT NULL,
+            equity REAL NOT NULL,
+            currency TEXT NOT NULL,
+            leverage TEXT NOT NULL,
+            years_in_investment REAL NOT NULL,
+            gameplay TEXT NOT NULL,
+            updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+        )
+        """
+    )
+    if legacy_profile is None:
+        return
+    db.execute(
+        """
+        INSERT INTO user_profile (id, name, equity, currency, leverage, years_in_investment, gameplay, updated_at)
+        VALUES (1, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+        """,
+        legacy_profile,
+    )
+
+
+def _legacy_profile_payload(row: sqlite3.Row) -> tuple[object, ...]:
+    keys = set(row.keys())
+    name = row["name"] if "name" in keys else "User"
+    equity = row["equity"] if "equity" in keys else row["equity_amount"] if "equity_amount" in keys else 0
+    currency = row["currency"] if "currency" in keys else row["equity_currency"] if "equity_currency" in keys else "USD"
+    leverage = row["leverage"] if "leverage" in keys else "1:1"
+    years = (
+        row["years_in_investment"]
+        if "years_in_investment" in keys
+        else row["experience_years"]
+        if "experience_years" in keys
+        else 0
+    )
+    gameplay = _normalize_legacy_gameplay(str(row["gameplay"])) if "gameplay" in keys else _classify_legacy_gameplay(float(equity))
+    return (name, equity, currency, leverage, years, gameplay)
+
+
+def _normalize_legacy_gameplay(value: str) -> str:
+    normalized = value.strip().lower().replace("-", "_").replace(" ", "_")
+    return {
+        "scalper": "Scalper",
+        "intra_day": "Intra day",
+        "intraday": "Intra day",
+        "day_trade": "Day trade",
+        "day_trader": "Day trade",
+        "swing": "Swing/Investor",
+        "investor": "Swing/Investor",
+    }.get(normalized, value.strip() or "Scalper")
+
+
+def _classify_legacy_gameplay(equity: float) -> str:
+    if equity <= 400:
+        return "Scalper"
+    if equity <= 1000:
+        return "Intra day"
+    if equity <= 5000:
+        return "Day trade"
+    return "Swing/Investor"

package/fincli/app/storage/provider_metrics.py

@@ -0,0 +1,61 @@
+"""Persistent provider metrics storage."""
+
+from __future__ import annotations
+
+from fincli.app.services.market_data import ProviderRuntimeMetrics
+from fincli.app.storage.database import FinCLIDatabase
+
+
+class ProviderMetricsStore:
+    """Persist aggregate provider metrics across FinCLI sessions."""
+
+    def __init__(self, db: FinCLIDatabase) -> None:
+        self.db = db
+
+    def record(self, provider: str, success: bool, latency_ms: float, fallback: bool = False) -> None:
+        current = self.snapshot().get(provider, ProviderRuntimeMetrics(provider))
+        current.record(success=success, latency_ms=latency_ms, fallback=fallback)
+        self.db.execute(
+            """
+            INSERT INTO provider_metrics(provider, calls, successes, errors, fallbacks, total_latency_ms, last_status, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+            ON CONFLICT(provider) DO UPDATE SET
+                calls=excluded.calls,
+                successes=excluded.successes,
+                errors=excluded.errors,
+                fallbacks=excluded.fallbacks,
+                total_latency_ms=excluded.total_latency_ms,
+                last_status=excluded.last_status,
+                updated_at=CURRENT_TIMESTAMP
+            """,
+            (
+                current.provider,
+                current.calls,
+                current.successes,
+                current.errors,
+                current.fallbacks,
+                current.total_latency_ms,
+                current.last_status,
+            ),
+        )
+
+    def snapshot(self) -> dict[str, ProviderRuntimeMetrics]:
+        rows = self.db.query(
+            """
+            SELECT provider, calls, successes, errors, fallbacks, total_latency_ms, last_status
+            FROM provider_metrics
+            ORDER BY provider
+            """
+        )
+        metrics: dict[str, ProviderRuntimeMetrics] = {}
+        for row in rows:
+            metric = ProviderRuntimeMetrics(str(row["provider"]))
+            metric.calls = int(row["calls"])
+            metric.successes = int(row["successes"])
+            metric.errors = int(row["errors"])
+            metric.fallbacks = int(row["fallbacks"])
+            metric.total_latency_ms = float(row["total_latency_ms"])
+            metric.last_status = str(row["last_status"])
+            metrics[metric.provider] = metric
+        return metrics
+