@drico2008/fincli 0.2.2 → 0.3.1

package/fincli/app/services/market_data.py

@@ -2,32 +2,41 @@
 
 from __future__ import annotations
 
-import asyncio
-from concurrent.futures import ThreadPoolExecutor
-from dataclasses import asdict
-from datetime import datetime
-from typing import Any, Awaitable
-
-from fincli.app.providers.market.base import BaseMarketProvider, Candle, FundamentalSnapshot, NewsItem, ProviderStatus, Quote
-from fincli.app.storage.market_cache import MarketCache
-from fincli.app.utils.errors import ProviderError
-
-
-class MarketDataService:
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import asdict
+from datetime import datetime
+from time import perf_counter
+from typing import Any, Awaitable
+
+from fincli.app.providers.market.base import BaseMarketProvider, Candle, FundamentalSnapshot, NewsItem, ProviderStatus, Quote
+from fincli.app.providers.reliability import ProviderResult, classify_payload, classify_provider_error
+from fincli.app.storage.market_cache import MarketCache
+from fincli.app.utils.errors import ProviderError
+
+
+class MarketDataService:
     """Fetch market data through a prioritized provider chain."""
 
     def __init__(
         self,
-        providers: list[BaseMarketProvider],
-        cache: MarketCache | None = None,
-        cache_ttl_seconds: int = 300,
-    ) -> None:
+        providers: list[BaseMarketProvider],
+        cache: MarketCache | None = None,
+        cache_ttl_seconds: int = 300,
+        metrics_store: Any | None = None,
+    ) -> None:
         if not providers:
             raise ProviderError("MarketDataService membutuhkan minimal satu provider.")
         self.providers = providers
-        self.cache = cache
-        self.cache_ttl_seconds = cache_ttl_seconds
-        self.last_errors: list[str] = []
+        self.cache = cache
+        self.cache_ttl_seconds = cache_ttl_seconds
+        self.metrics_store = metrics_store
+        self.last_errors: list[str] = []
+        self.provider_results: list[ProviderResult] = []
+        self.provider_metrics: dict[str, ProviderRuntimeMetrics] = {
+            getattr(provider, "name", "unknown"): ProviderRuntimeMetrics(getattr(provider, "name", "unknown"))
+            for provider in providers
+        }
 
     @property
     def primary_provider(self) -> BaseMarketProvider:
@@ -82,19 +91,72 @@ class MarketDataService:
                 message=str(exc),
             )
 
-    async def _with_fallback(self, method_name: str, *args: object) -> Any:
-        errors: list[str] = []
-        for provider in self.providers:
-            try:
-                method = getattr(provider, method_name)
-                return await method(*args)
-            except Exception as exc:  # noqa: BLE001
-                errors.append(f"{getattr(provider, 'name', 'unknown')}: {exc}")
-        self.last_errors = errors
-        raise ProviderError(
-            f"Semua provider gagal untuk {method_name}.",
-            "\n".join(errors),
-        )
+    async def _with_fallback(self, method_name: str, *args: object) -> Any:
+        errors: list[str] = []
+        for provider in self.providers:
+            provider_name = getattr(provider, "name", "unknown")
+            started = perf_counter()
+            try:
+                method = getattr(provider, method_name)
+                payload = await method(*args)
+                latency_ms = (perf_counter() - started) * 1000
+                status, missing = classify_payload(method_name, payload)
+                self._record_provider_metric(provider_name, success=status != "partial_data", latency_ms=latency_ms)
+                self._record_provider_result(
+                    provider=provider_name,
+                    operation=method_name,
+                    status=status,
+                    missing_fields=missing,
+                    message="ok" if not missing else f"partial payload: {', '.join(missing)}",
+                )
+                return payload
+            except Exception as exc:  # noqa: BLE001
+                latency_ms = (perf_counter() - started) * 1000
+                errors.append(f"{provider_name}: {exc}")
+                self._record_provider_metric(provider_name, success=False, latency_ms=latency_ms, fallback=True)
+                self._record_provider_result(
+                    provider=provider_name,
+                    operation=method_name,
+                    status=classify_provider_error(exc),
+                    message=str(exc),
+                )
+        self.last_errors = errors
+        raise ProviderError(
+            f"Semua provider gagal untuk {method_name}.",
+            "\n".join(errors),
+        )
+
+    def _record_provider_result(
+        self,
+        provider: str,
+        operation: str,
+        status: str,
+        missing_fields: tuple[str, ...] = (),
+        message: str = "",
+    ) -> None:
+        self.provider_results.append(
+            ProviderResult(
+                provider=provider,
+                operation=operation,
+                status=status,
+                realtime_label="unknown",
+                source=provider,
+                data_quality=status,
+                missing_fields=missing_fields,
+                message=message,
+            )
+        )
+        if len(self.provider_results) > 50:
+            self.provider_results = self.provider_results[-50:]
+
+    def _record_provider_metric(self, provider: str, success: bool, latency_ms: float, fallback: bool = False) -> None:
+        metric = self.provider_metrics.setdefault(provider, ProviderRuntimeMetrics(provider))
+        metric.record(success=success, latency_ms=latency_ms, fallback=fallback)
+        if self.metrics_store is not None:
+            self.metrics_store.record(provider, success=success, latency_ms=latency_ms, fallback=fallback)
+
+    def provider_metrics_snapshot(self) -> dict[str, "ProviderRuntimeMetrics"]:
+        return {provider: metric.copy() for provider, metric in self.provider_metrics.items()}
 
     def _cache_key(self, symbol: str, *parts: object) -> str:
         provider_chain = ",".join(provider.name for provider in self.providers)
@@ -197,7 +259,50 @@ def _parse_datetime(value: object) -> datetime:
     return datetime.fromisoformat(str(value))
 
 
-def _optional_float(value: object) -> float | None:
-    if value is None:
-        return None
-    return float(value)
+def _optional_float(value: object) -> float | None:
+    if value is None:
+        return None
+    return float(value)
+
+
+class ProviderRuntimeMetrics:
+    """Runtime metrics for one market provider."""
+
+    def __init__(self, provider: str) -> None:
+        self.provider = provider
+        self.calls = 0
+        self.successes = 0
+        self.errors = 0
+        self.fallbacks = 0
+        self.total_latency_ms = 0.0
+        self.last_status = "not_called"
+
+    @property
+    def success_rate(self) -> float:
+        return (self.successes / self.calls * 100) if self.calls else 0.0
+
+    @property
+    def avg_latency_ms(self) -> float:
+        return (self.total_latency_ms / self.calls) if self.calls else 0.0
+
+    def record(self, success: bool, latency_ms: float, fallback: bool = False) -> None:
+        self.calls += 1
+        self.total_latency_ms += max(latency_ms, 0.0)
+        if success:
+            self.successes += 1
+            self.last_status = "success"
+        else:
+            self.errors += 1
+            self.last_status = "error"
+        if fallback:
+            self.fallbacks += 1
+
+    def copy(self) -> "ProviderRuntimeMetrics":
+        duplicate = ProviderRuntimeMetrics(self.provider)
+        duplicate.calls = self.calls
+        duplicate.successes = self.successes
+        duplicate.errors = self.errors
+        duplicate.fallbacks = self.fallbacks
+        duplicate.total_latency_ms = self.total_latency_ms
+        duplicate.last_status = self.last_status
+        return duplicate

package/fincli/app/services/market_overview.py

@@ -7,6 +7,7 @@ from dataclasses import dataclass
 from fincli.app.analysis.indicators import TechnicalSummary, summarize_technical_indicators
 from fincli.app.analysis.market_structure import MarketStructureSummary, analyze_market_structure
 from fincli.app.providers.market.base import Candle, FundamentalSnapshot, NewsItem, Quote
+from fincli.app.providers.reliability import STATUS_OK, STATUS_PARTIAL_DATA, STATUS_UNAVAILABLE
 from fincli.app.services.market_data import MarketDataService
 from fincli.app.utils.errors import FinCLIError
 
@@ -19,6 +20,11 @@ class DataQuality:
     news: str
     fundamentals: str
     provider: str
+    tier: str
+    freshness: str
+    reliability_status: str
+    missing_fields: tuple[str, ...]
+    label: str
 
 
 @dataclass(frozen=True, slots=True)
@@ -73,9 +79,12 @@ def _score_data_quality(
     fundamentals: FundamentalSnapshot | None,
 ) -> DataQuality:
     score = 0
+    missing: list[str] = []
     quote_status = "ok" if quote.price is not None else "missing"
     if quote.price is not None:
         score += 25
+    else:
+        missing.append("quote")
 
     candle_count = len(candles)
     if candle_count >= 120:
@@ -89,23 +98,55 @@ def _score_data_quality(
         score += 10
     else:
         ohlcv_status = "missing"
+        missing.append("ohlcv")
 
     news_status = f"{len(news)} item(s)" if news else "missing"
     if news:
         score += 15
+    else:
+        missing.append("news")
 
     fundamentals_status = "ok" if fundamentals is not None else "missing"
     if fundamentals is not None:
         score += 20
+    else:
+        missing.append("fundamentals")
 
     if quote.status == "realtime":
         score += 5
 
+    normalized_score = min(score, 100)
+    tier = _quality_tier(normalized_score)
+    freshness = quote.status or "unknown"
+    reliability_status = _reliability_status(missing, normalized_score)
     return DataQuality(
-        score=min(score, 100),
+        score=normalized_score,
         quote=quote_status,
         ohlcv=ohlcv_status,
         news=news_status,
         fundamentals=fundamentals_status,
         provider=f"{quote.provider} ({quote.status})",
+        tier=tier,
+        freshness=freshness,
+        reliability_status=reliability_status,
+        missing_fields=tuple(missing),
+        label=f"{tier} | {reliability_status} | freshness={freshness}",
     )
+
+
+def _quality_tier(score: int) -> str:
+    if score >= 85:
+        return "strong"
+    if score >= 65:
+        return "usable"
+    if score >= 40:
+        return "partial"
+    return "weak"
+
+
+def _reliability_status(missing: list[str], score: int) -> str:
+    if "quote" in missing or "ohlcv" in missing or score < 25:
+        return STATUS_UNAVAILABLE
+    if missing:
+        return STATUS_PARTIAL_DATA
+    return STATUS_OK

package/fincli/app/services/news_aggregator.py

@@ -7,6 +7,7 @@ from datetime import datetime, timedelta, timezone
 
 from fincli.app.connectors.news_connectors import NewsConnectorManager
 from fincli.app.providers.market.base import NewsItem
+from fincli.app.providers.reliability import STATUS_OK, STATUS_PARTIAL_DATA, STATUS_UNAVAILABLE, classify_provider_error
 from fincli.app.services.market_data import MarketDataService
 
 
@@ -18,6 +19,7 @@ class NewsDesk:
     note: str
     errors: tuple[str, ...] = ()
     lookback_days: int | None = None
+    reliability_status: str = STATUS_UNAVAILABLE
 
 
 class NewsAggregator:
@@ -42,7 +44,7 @@ class NewsAggregator:
             try:
                 fetched = await self._fetch_provider(provider, normalized, max(limit - len(items), 1))
             except Exception as exc:  # noqa: BLE001 - fallback chain should continue
-                errors.append(f"{provider}: {exc}")
+                errors.append(f"{provider}: {classify_provider_error(exc)} ({exc})")
                 continue
             for item in fetched:
                 if lookback_days is not None and not _within_lookback(item, lookback_days):
@@ -57,11 +59,14 @@ class NewsAggregator:
                 break
 
         note = "Provider-backed news. Realtime/delayed status depends on provider entitlement."
+        reliability_status = STATUS_OK
         if not items:
             note = "No news returned by active providers. Try /research <symbol> --deep or configure /news_model priority."
+            reliability_status = STATUS_UNAVAILABLE if errors else STATUS_PARTIAL_DATA
         elif errors:
             note = f"{note} Fallback used after {len(errors)} provider error(s)."
-        return NewsDesk(normalized, provider_chain, items, note, tuple(errors), lookback_days)
+            reliability_status = STATUS_PARTIAL_DATA
+        return NewsDesk(normalized, provider_chain, items, note, tuple(errors), lookback_days, reliability_status)
 
     async def _fetch_provider(self, provider: str, symbol: str, limit: int) -> list[NewsItem]:
         if provider == "yfinance" or any(item.name == provider for item in self.market_service.providers):

package/fincli/app/storage/database.py

@@ -119,6 +119,17 @@ class FinCLIDatabase:
                             gameplay TEXT NOT NULL,
                             updated_at TEXT DEFAULT CURRENT_TIMESTAMP
                         );
+
+                        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)
@@ -142,7 +153,7 @@ class FinCLIDatabase:
 
 
 def _migrate_user_profile_schema(db: sqlite3.Connection) -> None:
-    """Normalize older user_profile schemas to the v0.2.2 canonical shape."""
+    """Normalize older user_profile schemas to the v0.3.1 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"}

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
+

package/fincli/app/storage/secrets.py

@@ -60,6 +60,24 @@ def save_secret(env_key: str, value: str, path: Path | None = None) -> None:
     os.environ[key] = secret
 
 
+def clear_secrets(path: Path | None = None) -> int:
+    """Clear persisted local secrets and remove them from the current process."""
+    path = path or SECRETS_FILE
+    secrets = read_secrets(path)
+    for key in secrets:
+        os.environ.pop(key, None)
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text("# FinCLI local secrets. Do not commit or share this file.\n", encoding="utf-8")
+        try:
+            os.chmod(path, 0o600)
+        except OSError:
+            pass
+    except OSError as exc:
+        raise ConfigError("Secret lokal gagal dibersihkan.", f"Path: {path}") from exc
+    return len(secrets)
+
+
 def read_secrets(path: Path | None = None) -> dict[str, str]:
     """Read local secrets without printing or masking them."""
     path = path or SECRETS_FILE

package/npm/bin/fincli.js

@@ -2,7 +2,7 @@
 
 const fs = require("fs");
 const path = require("path");
-const { spawn } = require("child_process");
+const { spawn, spawnSync } = require("child_process");
 
 const packageRoot = path.resolve(__dirname, "..", "..");
 const packageJson = require(path.join(packageRoot, "package.json"));
@@ -25,6 +25,8 @@ function run() {
     process.exit(1);
   }
 
+  ensurePythonRuntime();
+
   const child = spawn(pythonBin, ["-m", "fincli.app.main", ...args], {
     cwd: packageRoot,
     stdio: "inherit"
@@ -39,4 +41,25 @@ function run() {
   });
 }
 
+function ensurePythonRuntime() {
+  const probe = spawnSync(pythonBin, ["-c", "import textual, rich, httpx, pydantic, yfinance, pandas, numpy"], {
+    cwd: packageRoot,
+    stdio: "ignore"
+  });
+  if (probe.status === 0) {
+    return;
+  }
+
+  console.error("FinCLI Python dependencies are incomplete. Repairing local npm runtime...");
+  const repair = spawnSync(pythonBin, ["-m", "pip", "install", "."], {
+    cwd: packageRoot,
+    stdio: "inherit"
+  });
+  if (repair.status !== 0) {
+    console.error("FinCLI runtime repair failed.");
+    console.error("Try reinstalling with: npm install -g @drico2008/fincli");
+    process.exit(repair.status ?? 1);
+  }
+}
+
 run();

package/package.json

@@ -1,15 +1,17 @@
 {
   "name": "@drico2008/fincli",
-  "version": "0.2.2",
+  "version": "0.3.1",
   "description": "Modern financial CLI/TUI terminal for market monitoring and analysis.",
   "license": "MIT",
   "bin": {
     "fincli": "npm/bin/fincli.js"
   },
-  "scripts": {
-    "postinstall": "node npm/postinstall.js",
-    "check": "node --check npm/bin/fincli.js && node --check npm/postinstall.js"
-  },
+  "scripts": {
+    "postinstall": "node npm/postinstall.js",
+    "check": "node --check npm/bin/fincli.js && node --check npm/postinstall.js",
+    "prepublish:safety": "python scripts/prepublish_check.py",
+    "prepublishOnly": "python scripts/prepublish_check.py"
+  },
   "files": [
     "fincli/**/*.py",
     "npm",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fincli"
-version = "0.2.2"
+version = "0.3.1"
 description = "Modern financial CLI/TUI terminal for market monitoring and analysis."
 readme = "README.md"
 requires-python = ">=3.11"