@drico2008/fincli 0.3.0 → 0.4.0

package/fincli/app/modules/trading.py

@@ -0,0 +1,142 @@
+"""Trading capability catalog and local paper trading engine."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from fincli.app.storage.database import FinCLIDatabase
+from fincli.app.utils.errors import CommandError
+from fincli.app.utils.formatting import normalize_symbol
+
+
+@dataclass(frozen=True, slots=True)
+class RealtimeConnector:
+    name: str
+    transport: str
+    asset_classes: tuple[str, ...]
+    status: str
+    note: str
+
+
+@dataclass(frozen=True, slots=True)
+class BrokerIntegration:
+    name: str
+    region: str
+    asset_classes: tuple[str, ...]
+    mode: str
+    note: str
+
+
+class RealtimeConnectorCatalog:
+    """Connector catalog for realtime/push market data capability planning."""
+
+    def all(self) -> tuple[RealtimeConnector, ...]:
+        return (
+            RealtimeConnector(
+                "Kraken WebSocket",
+                "websocket",
+                ("crypto",),
+                "adapter_stub",
+                "Crypto realtime feed scaffold. Requires Kraken WS adapter before live streaming.",
+            ),
+            RealtimeConnector(
+                "HyperLiquid WebSocket",
+                "websocket",
+                ("crypto", "perpetuals"),
+                "adapter_stub",
+                "HyperLiquid realtime/orderbook scaffold. No live execution in v0.4.0.",
+            ),
+            RealtimeConnector(
+                "Equity Quote Feed",
+                "polling/provider",
+                ("equity", "etf", "index"),
+                "provider_backed",
+                "Uses configured market providers; realtime depends on provider entitlement.",
+            ),
+        )
+
+
+class BrokerCatalog:
+    """Catalog of planned broker integrations with safe non-live defaults."""
+
+    def all(self) -> tuple[BrokerIntegration, ...]:
+        india = ("equity", "fno", "mutual_fund")
+        global_assets = ("equity", "options", "etf")
+        return (
+            BrokerIntegration("Zerodha", "India", india, "adapter_stub", "Kite Connect adapter planned."),
+            BrokerIntegration("Angel One", "India", india, "adapter_stub", "SmartAPI adapter planned."),
+            BrokerIntegration("Upstox", "India", india, "adapter_stub", "Upstox API adapter planned."),
+            BrokerIntegration("Fyers", "India", india, "adapter_stub", "Fyers API adapter planned."),
+            BrokerIntegration("Dhan", "India", india, "adapter_stub", "Dhan API adapter planned."),
+            BrokerIntegration("Groww", "India", ("equity", "mutual_fund"), "adapter_stub", "Broker API availability varies."),
+            BrokerIntegration("Kotak", "India", india, "adapter_stub", "Kotak Neo adapter planned."),
+            BrokerIntegration("IIFL", "India", india, "adapter_stub", "IIFL API adapter planned."),
+            BrokerIntegration("5paisa", "India", india, "adapter_stub", "5paisa API adapter planned."),
+            BrokerIntegration("AliceBlue", "India", india, "adapter_stub", "Ant API adapter planned."),
+            BrokerIntegration("Shoonya", "India", india, "adapter_stub", "Shoonya/Noren adapter planned."),
+            BrokerIntegration("Motilal", "India", india, "adapter_stub", "Motilal Oswal adapter planned."),
+            BrokerIntegration("IBKR", "Global", ("equity", "options", "futures", "forex"), "adapter_stub", "TWS/Gateway adapter planned."),
+            BrokerIntegration("Alpaca", "US", global_assets, "paper_ready", "Paper/live adapter candidate; v0.4.0 remains local paper only."),
+            BrokerIntegration("Tradier", "US", global_assets, "adapter_stub", "Tradier brokerage adapter planned."),
+            BrokerIntegration("Saxo", "Global", ("equity", "forex", "cfd", "futures"), "adapter_stub", "OpenAPI adapter planned."),
+        )
+
+
+class PaperTradingEngine:
+    """Local paper trading engine. It never sends live broker orders."""
+
+    def __init__(self, db: FinCLIDatabase) -> None:
+        self.db = db
+
+    def place_order(
+        self,
+        side: str,
+        symbol: str,
+        quantity: float,
+        order_type: str = "market",
+        price: float | None = None,
+        strategy: str = "manual",
+    ) -> dict[str, object]:
+        normalized_side = side.strip().lower()
+        normalized_type = order_type.strip().lower()
+        normalized_symbol = normalize_symbol(symbol)
+        if normalized_side not in {"buy", "sell"}:
+            raise CommandError("Paper order side harus buy atau sell.")
+        if normalized_type not in {"market", "limit"}:
+            raise CommandError("Paper order type harus market atau limit.")
+        if quantity <= 0:
+            raise CommandError("Paper order quantity harus lebih besar dari 0.")
+        if price is not None and price <= 0:
+            raise CommandError("Paper order price harus lebih besar dari 0.")
+
+        status = "filled" if normalized_type == "market" or price is not None else "queued"
+        notional = float(quantity) * float(price or 0)
+        self.db.execute(
+            """
+            INSERT INTO paper_orders(side, symbol, quantity, order_type, price, notional, status, strategy)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (normalized_side, normalized_symbol, quantity, normalized_type, price, notional, status, strategy),
+        )
+        return {
+            "side": normalized_side,
+            "symbol": normalized_symbol,
+            "quantity": quantity,
+            "order_type": normalized_type,
+            "price": price,
+            "notional": notional,
+            "status": status,
+            "strategy": strategy,
+        }
+
+    def list_orders(self, limit: int = 50) -> list[dict[str, object]]:
+        rows = self.db.query(
+            """
+            SELECT id, side, symbol, quantity, order_type, price, notional, status, strategy, created_at
+            FROM paper_orders
+            ORDER BY id DESC
+            LIMIT ?
+            """,
+            (limit,),
+        )
+        return [dict(row) for row in rows]

package/fincli/app/plugins/loader.py

@@ -1,72 +1,72 @@
-"""Local plugin discovery for FinCLI.
-
-Plugins are intentionally manifest-first in v0.3.0: FinCLI reads metadata and
-exposes status, but does not execute plugin code yet. This keeps the plugin
-surface useful without creating a security footgun.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-import json
-from pathlib import Path
-from typing import Iterable
-
-from fincli.app.storage import config_paths
-
-
-@dataclass(frozen=True, slots=True)
-class PluginManifest:
-    name: str
-    version: str
-    description: str
-    commands: tuple[str, ...]
-    capabilities: tuple[str, ...]
-    path: Path
-    status: str = "available"
-
-
-class PluginLoader:
-    """Discover plugin manifests from local plugin directories."""
-
-    def __init__(self, search_paths: Iterable[Path] | None = None) -> None:
-        self.search_paths = tuple(search_paths) if search_paths is not None else (config_paths.APP_DIR / "plugins",)
-
-    def discover(self) -> list[PluginManifest]:
-        plugins: list[PluginManifest] = []
-        for root in self.search_paths:
-            if not root.exists():
-                continue
-            for manifest_path in sorted(root.glob("*/plugin.json")):
-                plugins.append(self._read_manifest(manifest_path))
-        return plugins
-
-    def _read_manifest(self, manifest_path: Path) -> PluginManifest:
-        try:
-            payload = json.loads(manifest_path.read_text(encoding="utf-8"))
-            name = str(payload["name"]).strip()
-            version = str(payload.get("version") or "0.0.0").strip()
-            description = str(payload.get("description") or "").strip()
-            commands = tuple(str(item) for item in payload.get("commands", []) if str(item).strip())
-            capabilities = tuple(str(item) for item in payload.get("capabilities", []) if str(item).strip())
-            if not name:
-                raise ValueError("name is empty")
-            return PluginManifest(
-                name=name,
-                version=version,
-                description=description,
-                commands=commands,
-                capabilities=capabilities,
-                path=manifest_path,
-                status="available",
-            )
-        except Exception as exc:  # noqa: BLE001
-            return PluginManifest(
-                name=manifest_path.parent.name,
-                version="unknown",
-                description=f"Invalid plugin manifest: {exc}",
-                commands=(),
-                capabilities=(),
-                path=manifest_path,
-                status="invalid",
-            )
+"""Local plugin discovery for FinCLI.
+
+Plugins are intentionally manifest-first in v0.4.0: FinCLI reads metadata and
+exposes status, but does not execute plugin code yet. This keeps the plugin
+surface useful without creating a security footgun.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Iterable
+
+from fincli.app.storage import config_paths
+
+
+@dataclass(frozen=True, slots=True)
+class PluginManifest:
+    name: str
+    version: str
+    description: str
+    commands: tuple[str, ...]
+    capabilities: tuple[str, ...]
+    path: Path
+    status: str = "available"
+
+
+class PluginLoader:
+    """Discover plugin manifests from local plugin directories."""
+
+    def __init__(self, search_paths: Iterable[Path] | None = None) -> None:
+        self.search_paths = tuple(search_paths) if search_paths is not None else (config_paths.APP_DIR / "plugins",)
+
+    def discover(self) -> list[PluginManifest]:
+        plugins: list[PluginManifest] = []
+        for root in self.search_paths:
+            if not root.exists():
+                continue
+            for manifest_path in sorted(root.glob("*/plugin.json")):
+                plugins.append(self._read_manifest(manifest_path))
+        return plugins
+
+    def _read_manifest(self, manifest_path: Path) -> PluginManifest:
+        try:
+            payload = json.loads(manifest_path.read_text(encoding="utf-8"))
+            name = str(payload["name"]).strip()
+            version = str(payload.get("version") or "0.0.0").strip()
+            description = str(payload.get("description") or "").strip()
+            commands = tuple(str(item) for item in payload.get("commands", []) if str(item).strip())
+            capabilities = tuple(str(item) for item in payload.get("capabilities", []) if str(item).strip())
+            if not name:
+                raise ValueError("name is empty")
+            return PluginManifest(
+                name=name,
+                version=version,
+                description=description,
+                commands=commands,
+                capabilities=capabilities,
+                path=manifest_path,
+                status="available",
+            )
+        except Exception as exc:  # noqa: BLE001
+            return PluginManifest(
+                name=manifest_path.parent.name,
+                version="unknown",
+                description=f"Invalid plugin manifest: {exc}",
+                commands=(),
+                capabilities=(),
+                path=manifest_path,
+                status="invalid",
+            )

package/fincli/app/providers/market/finnhub_provider.py

@@ -11,8 +11,10 @@ implements the endpoints FinCLI needs for stock-style symbols first:
 
 from __future__ import annotations
 
-from datetime import datetime, timedelta
-from typing import Any
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from datetime import date, datetime, timedelta
+from typing import Any, Awaitable
 
 import httpx
 
@@ -134,11 +136,34 @@ class FinnhubProvider:
             industry=data.get("finnhubIndustry"),
         )
 
+    async def insider_transactions(self, symbol: str, limit: int = 20) -> list[dict[str, object]]:
+        data = await self._get("/stock/insider-transactions", {"symbol": symbol.upper()})
+        rows = data.get("data") if isinstance(data, dict) else None
+        if not isinstance(rows, list):
+            raise ProviderError("Response Finnhub insider transactions tidak valid.")
+        return [_parse_insider_transaction(item, symbol) for item in rows[:limit] if isinstance(item, dict)]
+
+    async def ipo_calendar(self, start: date, end: date) -> list[dict[str, object]]:
+        data = await self._get("/calendar/ipo", {"from": start.isoformat(), "to": end.isoformat()})
+        rows = data.get("ipoCalendar") if isinstance(data, dict) else None
+        if not isinstance(rows, list):
+            raise ProviderError("Response Finnhub IPO calendar tidak valid.")
+        return [_parse_ipo_item(item) for item in rows if isinstance(item, dict)]
+
     async def status(self) -> ProviderStatus:
         status = "configured" if self.api_key else "unavailable"
         message = "Finnhub provider configured." if self.api_key else "Requires FINNHUB_API_KEY."
         return ProviderStatus(name=self.name, realtime=True, status=status, message=message)
 
+    def run(self, awaitable: Awaitable[Any]) -> Any:
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError:
+            return asyncio.run(awaitable)
+        with ThreadPoolExecutor(max_workers=1) as executor:
+            future = executor.submit(asyncio.run, awaitable)
+            return future.result()
+
     async def _get(self, path: str, params: dict[str, object]) -> Any:
         if not self.api_key:
             raise ProviderError("API key Finnhub belum diatur.", "Gunakan /news_model key finnhub <api_key>.")
@@ -171,6 +196,30 @@ def _safe_float(value: Any) -> float | None:
         return None
 
 
+def _parse_insider_transaction(item: dict[str, Any], symbol: str) -> dict[str, object]:
+    return {
+        "symbol": str(item.get("symbol") or symbol).upper(),
+        "name": str(item.get("name") or "-"),
+        "date": str(item.get("transactionDate") or item.get("filingDate") or "-"),
+        "transaction_code": str(item.get("transactionCode") or "-"),
+        "change": _safe_float(item.get("change")),
+        "shares": _safe_float(item.get("share")),
+        "transaction_price": _safe_float(item.get("transactionPrice")),
+    }
+
+
+def _parse_ipo_item(item: dict[str, Any]) -> dict[str, object]:
+    return {
+        "date": str(item.get("date") or "-"),
+        "exchange": str(item.get("exchange") or "-"),
+        "symbol": str(item.get("symbol") or "-"),
+        "name": str(item.get("name") or "-"),
+        "price": str(item.get("price") or "-"),
+        "shares": _safe_float(item.get("numberOfShares")),
+        "status": str(item.get("status") or "-"),
+    }
+
+
 def _period_to_delta(period: str) -> timedelta:
     normalized = period.lower()
     if normalized.endswith("mo"):

package/fincli/app/providers/market/symbols.py

@@ -129,6 +129,14 @@ class ResolvedSymbol:
     original: str
     symbol: str
     asset_class: str
+    provider_symbols: dict[str, str] | None = None
+    confidence: str = "rule"
+    source: str = "local_rules"
+    notes: str = ""
+
+    @property
+    def canonical(self) -> str:
+        return self.symbol
 
 
 @dataclass(frozen=True, slots=True)
@@ -150,8 +158,11 @@ SYMBOL_CATALOG: tuple[SymbolAlias, ...] = (
     SymbolAlias("SPY", "SPDR S&P 500 ETF Trust", "etf", "NYSE Arca", "USD", ("S&P ETF",)),
     SymbolAlias("QQQ", "Invesco QQQ Trust", "etf", "NASDAQ", "USD", ("NASDAQ ETF",)),
     SymbolAlias("SPX", "S&P 500 Index", "index", "US", "USD", ("SP500", "S&P500", "^GSPC")),
+    SymbolAlias("US500", "S&P 500 CFD alias", "index", "US", "USD", ("SPX", "SP500", "^GSPC")),
     SymbolAlias("NASDAQ", "Nasdaq Composite Index", "index", "US", "USD", ("IXIC", "^IXIC")),
+    SymbolAlias("US100", "Nasdaq 100 CFD alias", "index", "US", "USD", ("NDX", "NASDAQ100", "^NDX")),
     SymbolAlias("DOW", "Dow Jones Industrial Average", "index", "US", "USD", ("DJI", "^DJI")),
+    SymbolAlias("US30", "Dow Jones CFD alias", "index", "US", "USD", ("DOW", "DJI", "^DJI")),
     SymbolAlias("DAX", "DAX Performance Index", "index", "Germany", "EUR", ("^GDAXI",)),
     SymbolAlias("NIKKEI", "Nikkei 225 Index", "index", "Japan", "JPY", ("N225", "^N225")),
     SymbolAlias("EURUSD", "Euro / US Dollar", "forex", "FX", "USD", ("EUR/USD", "EURUSD=X")),
@@ -170,8 +181,61 @@ SYMBOL_CATALOG: tuple[SymbolAlias, ...] = (
 )
 
 
+class SymbolResolver:
+    """Resolve user-facing symbols to provider-specific symbols with a small local cache."""
+
+    def __init__(self) -> None:
+        self._cache: dict[tuple[str, str, str], ResolvedSymbol] = {}
+
+    def resolve(self, symbol: str, provider: str = "yfinance", asset_class: str | None = None) -> ResolvedSymbol:
+        provider_name = provider.lower().strip()
+        asset_hint = (asset_class or "").lower().strip()
+        cache_key = (provider_name, _normalize(symbol), asset_hint)
+        cached = self._cache.get(cache_key)
+        if cached is not None:
+            return cached
+
+        resolved = resolve_provider_symbol(provider_name, symbol)
+        if asset_hint and resolved.asset_class != asset_hint:
+            resolved = ResolvedSymbol(
+                original=resolved.original,
+                symbol=resolved.symbol,
+                asset_class=asset_hint,
+                provider_symbols=resolved.provider_symbols,
+                confidence=resolved.confidence,
+                source=resolved.source,
+                notes=f"Asset class forced by user: {asset_hint}.",
+            )
+        self._cache[cache_key] = resolved
+        return resolved
+
+    def provider_symbol(self, provider: str, symbol: str, asset_class: str | None = None) -> str:
+        return self.resolve(symbol, provider=provider, asset_class=asset_class).symbol
+
+    def matrix(self, symbol: str, providers: tuple[str, ...] | None = None) -> dict[str, ResolvedSymbol]:
+        names = providers or ("yfinance", "twelvedata", "finnhub", "alphavantage", "custom")
+        return {name: self.resolve(symbol, provider=name) for name in names}
+
+    def search(self, query: str, limit: int = 12) -> list[SymbolSearchResult]:
+        return search_symbol_catalog(query, limit=limit)
+
+
 def resolve_yfinance_symbol(symbol: str) -> ResolvedSymbol:
     normalized = _normalize(symbol)
+    if normalized in {"US500", "SPX500"}:
+        return ResolvedSymbol(symbol, "^GSPC", "index")
+    if normalized in {"US100", "NASDAQ100"}:
+        return ResolvedSymbol(symbol, "^NDX", "index")
+    if normalized == "US30":
+        return ResolvedSymbol(symbol, "^DJI", "index")
+    if normalized in {"XAUUSD", "GOLD"}:
+        return ResolvedSymbol(symbol, "GC=F", "commodity", notes="Yahoo Finance uses gold futures as the practical free fallback for XAUUSD.")
+    if normalized in {"XAGUSD", "SILVER"}:
+        return ResolvedSymbol(symbol, "SI=F", "commodity", notes="Yahoo Finance uses silver futures as the practical free fallback for XAGUSD.")
+    if normalized in {"BTCUSD", "BTCUSDT", "BTC"}:
+        return ResolvedSymbol(symbol, "BTC-USD", "crypto")
+    if normalized in {"ETHUSD", "ETHUSDT", "ETH"}:
+        return ResolvedSymbol(symbol, "ETH-USD", "crypto")
     if normalized in YFINANCE_ALIASES:
         return ResolvedSymbol(symbol, YFINANCE_ALIASES[normalized], _alias_class(normalized))
     if normalized in IDX_ALIASES:
@@ -183,6 +247,16 @@ def resolve_yfinance_symbol(symbol: str) -> ResolvedSymbol:
 
 def resolve_twelvedata_symbol(symbol: str) -> ResolvedSymbol:
     normalized = _normalize(symbol)
+    if normalized in {"US500", "SPX500"}:
+        return ResolvedSymbol(symbol, "SPX", "index")
+    if normalized in {"US100", "NASDAQ100"}:
+        return ResolvedSymbol(symbol, "NDX", "index")
+    if normalized == "US30":
+        return ResolvedSymbol(symbol, "DJI", "index")
+    if normalized in {"BTCUSD", "BTCUSDT", "BTC"}:
+        return ResolvedSymbol(symbol, "BTC/USD", "crypto")
+    if normalized in {"ETHUSD", "ETHUSDT", "ETH"}:
+        return ResolvedSymbol(symbol, "ETH/USD", "crypto")
     if normalized in TWELVEDATA_ALIASES:
         return ResolvedSymbol(symbol, TWELVEDATA_ALIASES[normalized], _alias_class(normalized))
     if _is_metal_pair(normalized) or _is_forex_pair(normalized):
@@ -194,6 +268,16 @@ def resolve_twelvedata_symbol(symbol: str) -> ResolvedSymbol:
 
 def resolve_finnhub_symbol(symbol: str) -> ResolvedSymbol:
     normalized = _normalize(symbol)
+    if normalized in {"US500", "SPX", "SP500", "SPX500"}:
+        return ResolvedSymbol(symbol, "^GSPC", "index")
+    if normalized in {"US100", "NDX", "NASDAQ100"}:
+        return ResolvedSymbol(symbol, "^NDX", "index")
+    if normalized in {"US30", "DOW", "DJI"}:
+        return ResolvedSymbol(symbol, "^DJI", "index")
+    if normalized in {"BTCUSD", "BTCUSDT", "BTC"}:
+        return ResolvedSymbol(symbol, "BINANCE:BTCUSDT", "crypto")
+    if normalized in {"ETHUSD", "ETHUSDT", "ETH"}:
+        return ResolvedSymbol(symbol, "BINANCE:ETHUSDT", "crypto")
     if _is_metal_pair(normalized):
         return ResolvedSymbol(symbol, f"OANDA:{normalized[:3]}_{normalized[3:]}", "commodity")
     if _is_forex_pair(normalized):
@@ -215,6 +299,16 @@ def resolve_provider_symbol(provider: str, symbol: str) -> ResolvedSymbol:
         return resolve_finnhub_symbol(symbol)
     if provider_name == "alphavantage":
         normalized = _normalize(symbol)
+        if normalized in {"US500", "SPX500"}:
+            return ResolvedSymbol(symbol, "SPX", "index")
+        if normalized in {"US100", "NASDAQ100"}:
+            return ResolvedSymbol(symbol, "NDX", "index")
+        if normalized == "US30":
+            return ResolvedSymbol(symbol, "DJI", "index")
+        if normalized in {"BTC", "BTCUSD", "BTCUSDT"}:
+            return ResolvedSymbol(symbol, "BTCUSD", "crypto")
+        if normalized in {"ETH", "ETHUSD", "ETHUSDT"}:
+            return ResolvedSymbol(symbol, "ETHUSD", "crypto")
         if _is_metal_pair(normalized):
             return ResolvedSymbol(symbol, normalized, "commodity")
         if _is_forex_pair(normalized):
@@ -229,8 +323,7 @@ def resolve_provider_symbol(provider: str, symbol: str) -> ResolvedSymbol:
 
 
 def provider_symbol_matrix(symbol: str, providers: tuple[str, ...] | None = None) -> dict[str, ResolvedSymbol]:
-    names = providers or ("yfinance", "twelvedata", "finnhub", "alphavantage", "custom")
-    return {name: resolve_provider_symbol(name, symbol) for name in names}
+    return SymbolResolver().matrix(symbol, providers)
 
 
 def search_symbol_catalog(query: str, limit: int = 12) -> list[SymbolSearchResult]: