@drico2008/fincli 0.1.9 → 0.3.0

package/fincli/app/modules/portfolio_risk.py

@@ -0,0 +1,305 @@
+"""Portfolio Risk v2 analytics."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from fincli.app.modules.user_profile import UserProfile
+
+
+@dataclass(frozen=True, slots=True)
+class AssetClassExposure:
+    asset_class: str
+    market_value: float
+    weight: float
+    count: int
+
+
+@dataclass(frozen=True, slots=True)
+class CurrencyExposure:
+    currency: str
+    market_value: float
+    weight: float
+    count: int
+
+
+@dataclass(frozen=True, slots=True)
+class ConcentrationRisk:
+    top_symbol: str
+    top_weight: float
+    level: str
+    note: str
+
+
+@dataclass(frozen=True, slots=True)
+class PortfolioHealth:
+    score: int
+    label: str
+    notes: tuple[str, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class AssetClassWarning:
+    asset_class: str
+    weight: float
+    cap: float
+    level: str
+    note: str
+
+
+@dataclass(frozen=True, slots=True)
+class RiskBudget:
+    profile_gameplay: str
+    equity: float
+    currency: str
+    risk_per_trade: float
+    max_portfolio_risk: float
+    note: str
+
+
+@dataclass(frozen=True, slots=True)
+class PortfolioRiskReport:
+    total_cost_basis: float
+    total_market_value: float
+    realized_pnl: float
+    unrealized_pnl: float
+    total_pnl: float
+    exposure_by_asset_class: dict[str, AssetClassExposure]
+    currency_exposure: dict[str, CurrencyExposure]
+    concentration: ConcentrationRisk
+    health: PortfolioHealth
+    drawdown_estimate: float
+    asset_class_warnings: tuple[AssetClassWarning, ...]
+    risk_budget: RiskBudget
+
+
+def build_portfolio_risk(
+    positions: list[dict[str, object]],
+    market_values: dict[str, tuple[float | None, float | None, float | None]],
+    realized_pnl: float,
+    profile: UserProfile | None = None,
+) -> PortfolioRiskReport:
+    """Build exposure, concentration, PnL, and health score from positions."""
+    total_cost_basis = 0.0
+    total_market_value = 0.0
+    unrealized_pnl = 0.0
+    exposure_values: dict[str, float] = {}
+    exposure_counts: dict[str, int] = {}
+    currency_values: dict[str, float] = {}
+    currency_counts: dict[str, int] = {}
+    symbol_values: dict[str, float] = {}
+    missing_prices = 0
+
+    for row in positions:
+        symbol = str(row["symbol"]).upper()
+        quantity = float(row["quantity"])
+        average_price = float(row["average_price"])
+        cost_basis = quantity * average_price
+        total_cost_basis += cost_basis
+
+        current_price, pnl, _pnl_percent = market_values.get(symbol, (None, None, None))
+        if current_price is None:
+            missing_prices += 1
+            market_value = cost_basis
+        else:
+            market_value = quantity * current_price
+        total_market_value += market_value
+        if pnl is not None:
+            unrealized_pnl += pnl
+
+        asset_class = classify_asset_class(symbol)
+        exposure_values[asset_class] = exposure_values.get(asset_class, 0.0) + market_value
+        exposure_counts[asset_class] = exposure_counts.get(asset_class, 0) + 1
+        currency = str(row.get("currency", "USD")).upper()
+        currency_values[currency] = currency_values.get(currency, 0.0) + market_value
+        currency_counts[currency] = currency_counts.get(currency, 0) + 1
+        symbol_values[symbol] = market_value
+
+    exposure_by_asset_class = {
+        asset_class: AssetClassExposure(
+            asset_class=asset_class,
+            market_value=value,
+            weight=_weight(value, total_market_value),
+            count=exposure_counts.get(asset_class, 0),
+        )
+        for asset_class, value in sorted(exposure_values.items())
+    }
+    currency_exposure = {
+        currency: CurrencyExposure(
+            currency=currency,
+            market_value=value,
+            weight=_weight(value, total_market_value),
+            count=currency_counts.get(currency, 0),
+        )
+        for currency, value in sorted(currency_values.items())
+    }
+    concentration = _concentration(symbol_values, total_market_value)
+    total_pnl = realized_pnl + unrealized_pnl
+    drawdown_estimate = _drawdown_estimate(unrealized_pnl, total_cost_basis)
+    warnings = _asset_class_warnings(exposure_by_asset_class)
+    risk_budget = _risk_budget(profile)
+    health = _health_score(
+        positions_count=len(positions),
+        top_weight=concentration.top_weight,
+        missing_prices=missing_prices,
+        total_pnl=total_pnl,
+        total_cost_basis=total_cost_basis,
+        asset_class_count=len(exposure_by_asset_class),
+        drawdown_estimate=drawdown_estimate,
+        warning_count=len(warnings),
+    )
+    return PortfolioRiskReport(
+        total_cost_basis=total_cost_basis,
+        total_market_value=total_market_value,
+        realized_pnl=realized_pnl,
+        unrealized_pnl=unrealized_pnl,
+        total_pnl=total_pnl,
+        exposure_by_asset_class=exposure_by_asset_class,
+        currency_exposure=currency_exposure,
+        concentration=concentration,
+        health=health,
+        drawdown_estimate=drawdown_estimate,
+        asset_class_warnings=warnings,
+        risk_budget=risk_budget,
+    )
+
+
+def classify_asset_class(symbol: str) -> str:
+    normalized = symbol.upper()
+    if normalized.endswith("-USD") or normalized.endswith("USDT") or normalized in {"BTC", "ETH", "SOL", "BNB"}:
+        return "crypto"
+    if normalized.endswith("=X") or len(normalized) == 6 and normalized.isalpha():
+        return "forex"
+    if normalized.startswith("^") or normalized in {"SPX", "NASDAQ", "DJI", "DAX", "NIKKEI", "HSI"}:
+        return "index"
+    if normalized.endswith("=F") or normalized in {"XAUUSD", "XAGUSD", "WTI", "BRENT", "GOLD", "SILVER"}:
+        return "commodity"
+    if normalized.endswith(".JK") or normalized.endswith(".L") or normalized.endswith(".TO") or normalized.isalpha():
+        return "equity"
+    return "other"
+
+
+def _concentration(symbol_values: dict[str, float], total_market_value: float) -> ConcentrationRisk:
+    if not symbol_values or total_market_value <= 0:
+        return ConcentrationRisk("-", 0.0, "empty", "No market value available.")
+    top_symbol, top_value = max(symbol_values.items(), key=lambda item: item[1])
+    top_weight = _weight(top_value, total_market_value)
+    if top_weight >= 60:
+        level = "high"
+        note = "Top position dominates portfolio."
+    elif top_weight >= 35:
+        level = "medium"
+        note = "Top position needs monitoring."
+    else:
+        level = "healthy"
+        note = "No single position dominates."
+    return ConcentrationRisk(top_symbol, top_weight, level, note)
+
+
+def _health_score(
+    positions_count: int,
+    top_weight: float,
+    missing_prices: int,
+    total_pnl: float,
+    total_cost_basis: float,
+    asset_class_count: int,
+    drawdown_estimate: float,
+    warning_count: int,
+) -> PortfolioHealth:
+    score = 100
+    notes: list[str] = []
+    if positions_count == 0:
+        return PortfolioHealth(0, "empty", ("No positions.",))
+    if positions_count < 3:
+        score -= 15
+        notes.append("few positions")
+    if asset_class_count < 2:
+        score -= 10
+        notes.append("single asset class")
+    if top_weight >= 60:
+        score -= 25
+        notes.append("high concentration")
+    elif top_weight >= 35:
+        score -= 10
+        notes.append("medium concentration")
+    if missing_prices:
+        score -= min(30, missing_prices * 10)
+        notes.append(f"{missing_prices} missing price(s)")
+    if warning_count:
+        score -= min(20, warning_count * 8)
+        notes.append(f"{warning_count} asset-class cap warning(s)")
+    if drawdown_estimate <= -25:
+        score -= 15
+        notes.append("deep drawdown estimate")
+    pnl_ratio = (total_pnl / total_cost_basis * 100) if total_cost_basis else 0.0
+    if pnl_ratio <= -20:
+        score -= 20
+        notes.append("large drawdown")
+    elif pnl_ratio < 0:
+        score -= 8
+        notes.append("negative total PnL")
+
+    score = max(0, min(100, score))
+    if score >= 80:
+        label = "healthy"
+    elif score >= 60:
+        label = "watch"
+    elif score >= 40:
+        label = "caution"
+    else:
+        label = "high risk"
+    return PortfolioHealth(score, label, tuple(notes) or ("balanced baseline",))
+
+
+def _weight(value: float, total: float) -> float:
+    return (value / total * 100) if total else 0.0
+
+
+def _drawdown_estimate(unrealized_pnl: float, total_cost_basis: float) -> float:
+    if total_cost_basis <= 0:
+        return 0.0
+    return min(0.0, unrealized_pnl / total_cost_basis * 100)
+
+
+def _asset_class_warnings(exposures: dict[str, AssetClassExposure]) -> tuple[AssetClassWarning, ...]:
+    caps = {"crypto": 25.0, "forex": 40.0, "commodity": 35.0, "index": 50.0, "equity": 70.0, "other": 25.0}
+    warnings: list[AssetClassWarning] = []
+    for exposure in exposures.values():
+        cap = caps.get(exposure.asset_class, 25.0)
+        if exposure.weight > cap:
+            warnings.append(
+                AssetClassWarning(
+                    asset_class=exposure.asset_class,
+                    weight=exposure.weight,
+                    cap=cap,
+                    level="high" if exposure.weight >= cap + 20 else "watch",
+                    note=f"{exposure.asset_class} exposure {exposure.weight:.2f}% exceeds cap {cap:.2f}%.",
+                )
+            )
+    return tuple(warnings)
+
+
+def _risk_budget(profile: UserProfile | None) -> RiskBudget:
+    if profile is None:
+        return RiskBudget("unprofiled", 0.0, "USD", 0.0, 0.0, "Run /profile set to enable risk budget.")
+    gameplay = profile.gameplay
+    if gameplay == "Scalper":
+        per_trade_pct = 1.0
+        max_portfolio_pct = 5.0
+    elif gameplay == "Intra day":
+        per_trade_pct = 1.25
+        max_portfolio_pct = 7.5
+    elif gameplay == "Day trade":
+        per_trade_pct = 1.5
+        max_portfolio_pct = 10.0
+    else:
+        per_trade_pct = 2.0
+        max_portfolio_pct = 12.0
+    return RiskBudget(
+        profile_gameplay=gameplay,
+        equity=profile.equity,
+        currency=profile.currency,
+        risk_per_trade=profile.equity * per_trade_pct / 100,
+        max_portfolio_risk=profile.equity * max_portfolio_pct / 100,
+        note=f"{per_trade_pct:.2f}% per trade, {max_portfolio_pct:.2f}% max portfolio risk budget.",
+    )

package/fincli/app/modules/reports.py

@@ -0,0 +1,151 @@
+"""Exportable market report helpers."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from fincli.app.services.market_overview import MarketOverview
+from fincli.app.utils.errors import CommandError
+
+
+def write_market_report(overview: MarketOverview, fmt: str, target: str | Path) -> Path:
+    report_format = fmt.lower()
+    path = _safe_report_path(target, report_format)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if report_format == "json":
+        path.write_text(json.dumps(_overview_payload(overview), indent=2, default=str), encoding="utf-8")
+        return path
+    if report_format in {"md", "markdown"}:
+        path.write_text(_overview_markdown(overview), encoding="utf-8")
+        return path
+    raise CommandError("Report format must be md or json.")
+
+
+def _safe_report_path(target: str | Path, fmt: str) -> Path:
+    path = Path(target).expanduser()
+    if any(part == ".." for part in path.parts):
+        raise CommandError("Report path must not contain '..'.")
+    allowed = {".md", ".json"} if fmt in {"md", "markdown", "json"} else set()
+    if path.suffix.lower() not in allowed:
+        raise CommandError("Report path must end with .md or .json.")
+    return path
+
+
+def _overview_payload(overview: MarketOverview) -> dict[str, Any]:
+    return {
+        "symbol": overview.symbol,
+        "timeframe": overview.timeframe,
+        "quote": {
+            "symbol": overview.quote.symbol,
+            "price": overview.quote.price,
+            "currency": overview.quote.currency,
+            "provider": overview.quote.provider,
+            "status": overview.quote.status,
+            "timestamp": overview.quote.timestamp.isoformat(),
+        },
+        "data_quality": {
+            "score": overview.data_quality.score,
+            "quote": overview.data_quality.quote,
+            "ohlcv": overview.data_quality.ohlcv,
+            "news": overview.data_quality.news,
+            "fundamentals": overview.data_quality.fundamentals,
+            "provider": overview.data_quality.provider,
+        },
+        "technical": {
+            "latest_close": overview.technical.latest_close,
+            "trend_bias": overview.technical.trend_bias,
+            "rsi": overview.technical.rsi,
+            "macd": overview.technical.macd,
+            "macd_signal": overview.technical.macd_signal,
+            "atr": overview.technical.atr,
+            "support": overview.technical.support,
+            "resistance": overview.technical.resistance,
+        },
+        "structure": {
+            "trend": overview.structure.trend,
+            "latest_pattern": overview.structure.latest_pattern,
+            "break_of_structure": overview.structure.break_of_structure,
+            "change_of_character": overview.structure.change_of_character,
+            "liquidity_area": overview.structure.liquidity_area,
+            "risk_zone": overview.structure.risk_zone,
+        },
+        "fundamentals": None
+        if overview.fundamentals is None
+        else {
+            "provider": overview.fundamentals.provider,
+            "currency": overview.fundamentals.currency,
+            "market_cap": overview.fundamentals.market_cap,
+            "pe_ratio": overview.fundamentals.pe_ratio,
+            "eps": overview.fundamentals.eps,
+            "revenue": overview.fundamentals.revenue,
+            "sector": overview.fundamentals.sector,
+            "industry": overview.fundamentals.industry,
+        },
+        "news": [
+            {
+                "title": item.title,
+                "source": item.source,
+                "url": item.url,
+                "published_at": item.published_at.isoformat() if item.published_at else None,
+                "summary": item.summary,
+            }
+            for item in overview.news
+        ],
+        "disclaimer": "Informational only. Not financial advice.",
+    }
+
+
+def _overview_markdown(overview: MarketOverview) -> str:
+    payload = _overview_payload(overview)
+    news_lines = "\n".join(
+        f"- {item['title']} ({item['source']})" + (f" - {item['url']}" if item["url"] else "")
+        for item in payload["news"]
+    )
+    fundamentals = payload["fundamentals"] or {}
+    return "\n".join(
+        [
+            f"# FinCLI Market Report: {overview.symbol}",
+            "",
+            f"- Timeframe: {overview.timeframe}",
+            f"- Provider: {overview.quote.provider} ({overview.quote.status})",
+            f"- Data Quality: {overview.data_quality.score}/100",
+            "",
+            "## Quote",
+            "",
+            f"- Price: {overview.quote.price} {overview.quote.currency}",
+            f"- Timestamp: {overview.quote.timestamp.isoformat(timespec='seconds')}",
+            "",
+            "## Technical",
+            "",
+            f"- Trend Bias: {overview.technical.trend_bias}",
+            f"- RSI: {overview.technical.rsi}",
+            f"- MACD: {overview.technical.macd} / {overview.technical.macd_signal}",
+            f"- ATR: {overview.technical.atr}",
+            f"- Support / Resistance: {overview.technical.support} / {overview.technical.resistance}",
+            "",
+            "## Market Structure",
+            "",
+            f"- Trend: {overview.structure.trend}",
+            f"- Pattern: {overview.structure.latest_pattern}",
+            f"- BOS / CHoCH: {overview.structure.break_of_structure} / {overview.structure.change_of_character}",
+            f"- Liquidity Area: {overview.structure.liquidity_area}",
+            f"- Risk Zone: {overview.structure.risk_zone}",
+            "",
+            "## Fundamentals",
+            "",
+            f"- Sector / Industry: {fundamentals.get('sector', 'N/A')} / {fundamentals.get('industry', 'N/A')}",
+            f"- Market Cap: {fundamentals.get('market_cap', 'N/A')}",
+            f"- P/E / EPS: {fundamentals.get('pe_ratio', 'N/A')} / {fundamentals.get('eps', 'N/A')}",
+            "",
+            "## Latest News",
+            "",
+            news_lines or "- No recent news returned by provider.",
+            "",
+            "## Disclaimer",
+            "",
+            "Informational only. Not financial advice.",
+            "",
+        ]
+    )

package/fincli/app/modules/scanner.py

@@ -1,105 +1,123 @@
-"""Watchlist scanner with simple technical filters."""
-
-from __future__ import annotations
-
+"""Watchlist scanner with simple technical filters."""
+
+from __future__ import annotations
+
 import asyncio
 from dataclasses import dataclass
+import re
 
 from fincli.app.analysis.indicators import TechnicalSummary, summarize_technical_indicators
 from fincli.app.providers.market.base import BaseMarketProvider
+from fincli.app.utils.errors import CommandError
+
+
+@dataclass(frozen=True, slots=True)
+class ScanResult:
+    symbol: str
+    latest_close: float
+    rsi: float | None
+    trend_bias: str
+    support: float | None
+    resistance: float | None
+    matched: bool
+    reason: str
+
+
+async def scan_symbols(
+    symbols: list[str],
+    provider: BaseMarketProvider,
+    filter_expression: str = "",
+    interval: str = "1d",
+    batch_size: int = 25,
+) -> list[ScanResult]:
+    """Scan symbols in bounded async batches."""
+    results: list[ScanResult] = []
+    for index in range(0, len(symbols), batch_size):
+        batch = symbols[index : index + batch_size]
+        scanned = await asyncio.gather(
+            *[_scan_symbol(symbol, provider, filter_expression, interval) for symbol in batch],
+            return_exceptions=True,
+        )
+        for item in scanned:
+            if isinstance(item, ScanResult) and item.matched:
+                results.append(item)
+    return results
+
+
+async def _scan_symbol(
+    symbol: str,
+    provider: BaseMarketProvider,
+    filter_expression: str,
+    interval: str,
+) -> ScanResult:
+    candles = await provider.history(symbol, period="6mo", interval=interval)
+    summary = summarize_technical_indicators(candles)
+    matched, reason = _matches_filter(summary, filter_expression)
+    return ScanResult(
+        symbol=symbol.upper(),
+        latest_close=summary.latest_close,
+        rsi=summary.rsi,
+        trend_bias=summary.trend_bias,
+        support=summary.support,
+        resistance=summary.resistance,
+        matched=matched,
+        reason=reason,
+    )
+
+
+def _matches_filter(summary: TechnicalSummary, expression: str) -> tuple[bool, str]:
+    return matches_filter_expression(summary, expression)
 
 
-@dataclass(frozen=True, slots=True)
-class ScanResult:
-    symbol: str
-    latest_close: float
-    rsi: float | None
-    trend_bias: str
-    support: float | None
-    resistance: float | None
-    matched: bool
-    reason: str
-
-
-async def scan_symbols(
-    symbols: list[str],
-    provider: BaseMarketProvider,
-    filter_expression: str = "",
-    interval: str = "1d",
-    batch_size: int = 25,
-) -> list[ScanResult]:
-    """Scan symbols in bounded async batches."""
-    results: list[ScanResult] = []
-    for index in range(0, len(symbols), batch_size):
-        batch = symbols[index : index + batch_size]
-        scanned = await asyncio.gather(
-            *[_scan_symbol(symbol, provider, filter_expression, interval) for symbol in batch],
-            return_exceptions=True,
-        )
-        for item in scanned:
-            if isinstance(item, ScanResult) and item.matched:
-                results.append(item)
-    return results
-
-
-async def _scan_symbol(
-    symbol: str,
-    provider: BaseMarketProvider,
-    filter_expression: str,
-    interval: str,
-) -> ScanResult:
-    candles = await provider.history(symbol, period="6mo", interval=interval)
-    summary = summarize_technical_indicators(candles)
-    matched, reason = _matches_filter(summary, filter_expression)
-    return ScanResult(
-        symbol=symbol.upper(),
-        latest_close=summary.latest_close,
-        rsi=summary.rsi,
-        trend_bias=summary.trend_bias,
-        support=summary.support,
-        resistance=summary.resistance,
-        matched=matched,
-        reason=reason,
-    )
-
+def matches_filter_expression(summary: TechnicalSummary, expression: str) -> tuple[bool, str]:
+    """Evaluate a small, explicit scan expression language.
 
-def _matches_filter(summary: TechnicalSummary, expression: str) -> tuple[bool, str]:
+    Supported terms: trend=<bias>, rsi<number, rsi>number.
+    Supported operators: and, or. Comma is treated as and.
+    """
     expr = expression.strip().lower()
     if not expr:
         return True, "all"
 
-    parts = expr.split()
-    if len(parts) > 1:
-        evaluations = [_matches_single_filter(summary, part) for part in parts]
-        return all(item[0] for item in evaluations), "; ".join(item[1] for item in evaluations)
-
-    return _matches_single_filter(summary, expr)
-
-
-def _matches_single_filter(summary: TechnicalSummary, expr: str) -> tuple[bool, str]:
-    if expr.startswith("trend="):
-        expected = expr.split("=", 1)[1].strip()
-        return summary.trend_bias == expected, f"trend={summary.trend_bias}"
-
-    if expr.startswith("rsi<"):
-        threshold = _parse_threshold(expr, "rsi<")
-        return summary.rsi is not None and summary.rsi < threshold, f"rsi={_fmt(summary.rsi)} < {threshold:g}"
-
-    if expr.startswith("rsi>"):
-        threshold = _parse_threshold(expr, "rsi>")
-        return summary.rsi is not None and summary.rsi > threshold, f"rsi={_fmt(summary.rsi)} > {threshold:g}"
-
-    return True, f"unsupported filter treated as all: {expr}"
-
-
-def _parse_threshold(expression: str, prefix: str) -> float:
-    try:
-        return float(expression.replace(prefix, "", 1).strip())
-    except ValueError:
-        return 0.0
-
-
-def _fmt(value: float | None) -> str:
-    if value is None:
-        return "N/A"
-    return f"{value:.2f}"
+    normalized = expr.replace(",", " and ")
+    or_groups = [group.strip() for group in re.split(r"\s+or\s+", normalized) if group.strip()]
+    group_results: list[tuple[bool, str]] = []
+    for group in or_groups:
+        terms = [term.strip() for term in re.split(r"\s+and\s+|\s+", group) if term.strip()]
+        evaluations = [_matches_single_filter(summary, term) for term in terms]
+        group_results.append((all(item[0] for item in evaluations), "; ".join(item[1] for item in evaluations)))
+
+    matched = any(item[0] for item in group_results)
+    return matched, " OR ".join(item[1] for item in group_results)
+
+
+def _matches_single_filter(summary: TechnicalSummary, expr: str) -> tuple[bool, str]:
+    if expr.startswith("trend="):
+        expected = expr.split("=", 1)[1].strip()
+        return summary.trend_bias == expected, f"trend={summary.trend_bias}"
+
+    if expr.startswith("rsi<"):
+        threshold = _parse_threshold(expr, "rsi<")
+        return summary.rsi is not None and summary.rsi < threshold, f"rsi={_fmt(summary.rsi)} < {threshold:g}"
+
+    if expr.startswith("rsi>"):
+        threshold = _parse_threshold(expr, "rsi>")
+        return summary.rsi is not None and summary.rsi > threshold, f"rsi={_fmt(summary.rsi)} > {threshold:g}"
+
+    raise CommandError(
+        f"Filter scan tidak dikenal: {expr}",
+        "Gunakan filter seperti trend=bullish, rsi<30, rsi>70, atau gabungkan dengan and/or.",
+    )
+
+
+def _parse_threshold(expression: str, prefix: str) -> float:
+    try:
+        return float(expression.replace(prefix, "", 1).strip())
+    except ValueError:
+        return 0.0
+
+
+def _fmt(value: float | None) -> str:
+    if value is None:
+        return "N/A"
+    return f"{value:.2f}"