@drico2008/fincli 0.1.0

package/fincli/app/services/market_overview.py

@@ -0,0 +1,111 @@
+"""Market overview orchestration."""
+
+from __future__ import annotations
+
+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.services.market_data import MarketDataService
+from fincli.app.utils.errors import FinCLIError
+
+
+@dataclass(frozen=True, slots=True)
+class DataQuality:
+    score: int
+    quote: str
+    ohlcv: str
+    news: str
+    fundamentals: str
+    provider: str
+
+
+@dataclass(frozen=True, slots=True)
+class MarketOverview:
+    symbol: str
+    timeframe: str
+    quote: Quote
+    candles: list[Candle]
+    technical: TechnicalSummary
+    structure: MarketStructureSummary
+    news: list[NewsItem]
+    fundamentals: FundamentalSnapshot | None
+    data_quality: DataQuality
+
+
+async def build_market_overview(symbol: str, market_service: MarketDataService, timeframe: str = "1d") -> MarketOverview:
+    """Build a compact market overview from available provider data."""
+    normalized = symbol.upper()
+    quote = await market_service.quote(normalized)
+    candles = await market_service.history(normalized, period="6mo", interval=timeframe)
+    technical = summarize_technical_indicators(candles)
+    structure = analyze_market_structure(candles)
+
+    try:
+        news = await market_service.news(normalized, limit=3)
+    except FinCLIError:
+        news = []
+
+    try:
+        fundamentals = await market_service.fundamentals(normalized)
+    except FinCLIError:
+        fundamentals = None
+
+    quality = _score_data_quality(quote, candles, news, fundamentals)
+    return MarketOverview(
+        symbol=normalized,
+        timeframe=timeframe,
+        quote=quote,
+        candles=candles,
+        technical=technical,
+        structure=structure,
+        news=news,
+        fundamentals=fundamentals,
+        data_quality=quality,
+    )
+
+
+def _score_data_quality(
+    quote: Quote,
+    candles: list[Candle],
+    news: list[NewsItem],
+    fundamentals: FundamentalSnapshot | None,
+) -> DataQuality:
+    score = 0
+    quote_status = "ok" if quote.price is not None else "missing"
+    if quote.price is not None:
+        score += 25
+
+    candle_count = len(candles)
+    if candle_count >= 120:
+        ohlcv_status = f"strong ({candle_count} candles)"
+        score += 35
+    elif candle_count >= 20:
+        ohlcv_status = f"usable ({candle_count} candles)"
+        score += 25
+    elif candle_count:
+        ohlcv_status = f"weak ({candle_count} candles)"
+        score += 10
+    else:
+        ohlcv_status = "missing"
+
+    news_status = f"{len(news)} item(s)" if news else "missing"
+    if news:
+        score += 15
+
+    fundamentals_status = "ok" if fundamentals is not None else "missing"
+    if fundamentals is not None:
+        score += 20
+
+    if quote.status == "realtime":
+        score += 5
+
+    return DataQuality(
+        score=min(score, 100),
+        quote=quote_status,
+        ohlcv=ohlcv_status,
+        news=news_status,
+        fundamentals=fundamentals_status,
+        provider=f"{quote.provider} ({quote.status})",
+    )

package/fincli/app/storage/__init__.py

@@ -0,0 +1 @@
+"""Storage modules."""

package/fincli/app/storage/cache.py

@@ -0,0 +1,38 @@
+"""Lightweight in-memory cache scaffold for provider responses."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from time import monotonic
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+
+
+@dataclass(slots=True)
+class CacheEntry(Generic[T]):
+    value: T
+    expires_at: float
+
+
+class TTLCache(Generic[T]):
+    """Simple TTL cache for Phase 1. Provider modules can replace this later."""
+
+    def __init__(self, default_ttl: int = 300) -> None:
+        self.default_ttl = default_ttl
+        self._items: dict[str, CacheEntry[T]] = {}
+
+    def get(self, key: str) -> T | None:
+        entry = self._items.get(key)
+        if entry is None:
+            return None
+        if entry.expires_at < monotonic():
+            self._items.pop(key, None)
+            return None
+        return entry.value
+
+    def set(self, key: str, value: T, ttl: int | None = None) -> None:
+        self._items[key] = CacheEntry(value=value, expires_at=monotonic() + (ttl or self.default_ttl))
+
+    def clear(self) -> None:
+        self._items.clear()

package/fincli/app/storage/config.py

@@ -0,0 +1,114 @@
+"""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
+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
+
+
+APP_DIR = Path.home() / ".fincli"
+CONFIG_FILE = APP_DIR / "config.json"
+
+
+@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"])
+    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")),
+            "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")),
+        }
+        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()
+
+    def load(self) -> FinCLISettings:
+        if load_dotenv is not None:
+            load_dotenv()
+
+        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:
+        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]
+        self.save()

package/fincli/app/storage/database.py

@@ -0,0 +1,101 @@
+"""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)
+                        );
+                        """
+                    )
+        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 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

package/fincli/app/storage/market_cache.py

@@ -0,0 +1,92 @@
+"""Persistent SQLite cache for market provider responses."""
+
+from __future__ import annotations
+
+import json
+from time import time
+from typing import Any
+
+from fincli.app.storage.database import FinCLIDatabase
+from fincli.app.utils.errors import StorageError
+
+
+class MarketCache:
+    """Provider response cache with TTL persisted in SQLite."""
+
+    def __init__(self, db: FinCLIDatabase) -> None:
+        self.db = db
+
+    def get(self, namespace: str, cache_key: str) -> dict[str, Any] | list[Any] | None:
+        rows = self.db.query(
+            "SELECT payload, expires_at FROM market_cache WHERE namespace = ? AND cache_key = ?",
+            (namespace, cache_key),
+        )
+        if not rows:
+            return None
+
+        row = rows[0]
+        if float(row["expires_at"]) <= time():
+            self.delete(namespace, cache_key)
+            return None
+
+        try:
+            payload = json.loads(str(row["payload"]))
+        except json.JSONDecodeError as exc:
+            self.delete(namespace, cache_key)
+            raise StorageError("Payload cache market rusak dan sudah dihapus.") from exc
+
+        if isinstance(payload, (dict, list)):
+            return payload
+        return None
+
+    def set(self, namespace: str, cache_key: str, payload: dict[str, Any] | list[Any], ttl_seconds: int) -> None:
+        encoded = json.dumps(payload, separators=(",", ":"))
+        expires_at = time() + max(1, ttl_seconds)
+        self.db.execute(
+            """
+            INSERT INTO market_cache (namespace, cache_key, payload, expires_at)
+            VALUES (?, ?, ?, ?)
+            ON CONFLICT(namespace, cache_key)
+            DO UPDATE SET payload = excluded.payload, expires_at = excluded.expires_at, created_at = CURRENT_TIMESTAMP
+            """,
+            (namespace, cache_key, encoded, expires_at),
+        )
+
+    def delete(self, namespace: str, cache_key: str) -> None:
+        self.db.execute(
+            "DELETE FROM market_cache WHERE namespace = ? AND cache_key = ?",
+            (namespace, cache_key),
+        )
+
+    def clear(self, namespace: str | None = None) -> int:
+        if namespace:
+            count = int(self.db.query("SELECT COUNT(*) AS total FROM market_cache WHERE namespace = ?", (namespace,))[0]["total"])
+            self.db.execute("DELETE FROM market_cache WHERE namespace = ?", (namespace,))
+            return count
+        count = int(self.db.query("SELECT COUNT(*) AS total FROM market_cache")[0]["total"])
+        self.db.execute("DELETE FROM market_cache")
+        return count
+
+    def prune_expired(self) -> int:
+        count = int(self.db.query("SELECT COUNT(*) AS total FROM market_cache WHERE expires_at <= ?", (time(),))[0]["total"])
+        self.db.execute("DELETE FROM market_cache WHERE expires_at <= ?", (time(),))
+        return count
+
+    def stats(self) -> dict[str, int]:
+        self.prune_expired()
+        rows = self.db.query(
+            """
+            SELECT namespace, COUNT(*) AS total
+            FROM market_cache
+            GROUP BY namespace
+            ORDER BY namespace
+            """
+        )
+        by_namespace = {str(row["namespace"]): int(row["total"]) for row in rows}
+        return {
+            "total": sum(by_namespace.values()),
+            "quote": by_namespace.get("quote", 0),
+            "history": by_namespace.get("history", 0),
+            "news": by_namespace.get("news", 0),
+            "fundamentals": by_namespace.get("fundamentals", 0),
+        }

package/fincli/app/tui/__init__.py

@@ -0,0 +1 @@
+"""Textual TUI modules."""

package/fincli/app/tui/components.py

@@ -0,0 +1,55 @@
+"""Reusable TUI components."""
+
+from __future__ import annotations
+
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+from textual.widgets import Static
+
+from fincli.app.cli.commands import CommandSpec
+
+
+class CommandPalette(Static):
+    """Slash command palette shown near the command input."""
+
+    def render_commands(self, commands: list[CommandSpec], query: str = "") -> None:
+        table = Table.grid(expand=True)
+        table.add_column("Command", style="white", no_wrap=True, ratio=1)
+        table.add_column("Description", style="bright_black", justify="right", ratio=3)
+
+        for index, command in enumerate(commands):
+            command_text = command.name
+            description = command.description
+            if index == 0:
+                command_text = f"[black on cyan]> {command.name}[/]"
+                description = f"[black on cyan]{command.description}[/]"
+            table.add_row(command_text, description)
+
+        if len(commands) > 6:
+            table.add_row("[bright_black]v more[/]", "[bright_black]Ketik command lebih spesifik[/]")
+
+        title = f"[cyan]>[/] {query or '/'}"
+        self.update(Panel(table, title=title, border_style="bright_black", padding=(0, 1)))
+
+    def clear_palette(self) -> None:
+        self.update("")
+
+
+def format_user_message(message: str) -> Panel:
+    text = Text()
+    text.append("> ", style="bold cyan")
+    text.append(message, style="bold white")
+    return Panel(text, border_style="#2f332f", style="on #2b2f2b", padding=(0, 1))
+
+
+def format_thinking_message(message: str) -> Text:
+    text = Text()
+    text.append("> Thinking: ", style="dim")
+    text.append(message, style="italic dim")
+    return text
+
+
+def format_ai_message(message: str) -> Markdown:
+    return Markdown(f"* {message}")