@drico2008/fincli 0.1.0

package/fincli/app/main.py

@@ -0,0 +1,16 @@
+"""FinCLI application entrypoint."""
+
+from __future__ import annotations
+
+from fincli.app.tui.layout import FinCLIApp
+from fincli.app.utils.logger import configure_logging
+
+
+def main() -> None:
+    """Run the FinCLI TUI application."""
+    configure_logging()
+    FinCLIApp().run()
+
+
+if __name__ == "__main__":
+    main()

package/fincli/app/modules/__init__.py

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

package/fincli/app/modules/economic_calendar.py

@@ -0,0 +1,139 @@
+"""Economic calendar fetching and fallback formatting data."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date, datetime, timedelta
+from typing import Any
+
+import httpx
+
+from fincli.app.utils.errors import ProviderError, RateLimitError
+
+
+@dataclass(frozen=True, slots=True)
+class EconomicEvent:
+    event: str
+    country: str
+    impact: str
+    time: datetime | None
+    actual: str | None = None
+    estimate: str | None = None
+    previous: str | None = None
+    unit: str | None = None
+
+
+class EconomicCalendarService:
+    """Fetch economic calendar events with Finnhub support."""
+
+    def __init__(
+        self,
+        api_key: str | None,
+        base_url: str = "https://finnhub.io/api/v1",
+        client: httpx.AsyncClient | None = None,
+    ) -> None:
+        self.api_key = api_key or ""
+        self.base_url = base_url.rstrip("/")
+        self._client = client
+
+    async def events(self, start: date, end: date) -> list[EconomicEvent]:
+        if not self.api_key:
+            raise ProviderError(
+                "Economic calendar provider belum dikonfigurasi.",
+                "Isi FINNHUB_API_KEY di .env untuk mengambil economic calendar aktual.",
+            )
+
+        close_client = self._client is None
+        client = self._client or httpx.AsyncClient(timeout=30)
+        try:
+            response = await client.get(
+                f"{self.base_url}/calendar/economic",
+                params={"from": start.isoformat(), "to": end.isoformat(), "token": self.api_key},
+            )
+            if response.status_code == 429:
+                raise RateLimitError("Finnhub economic calendar terkena rate limit.")
+            response.raise_for_status()
+            payload = response.json()
+        except httpx.TimeoutException as exc:
+            raise ProviderError("Finnhub economic calendar timeout.") from exc
+        except httpx.HTTPStatusError as exc:
+            raise ProviderError(f"Finnhub economic calendar gagal: HTTP {exc.response.status_code}.") from exc
+        except ValueError as exc:
+            raise ProviderError("Response economic calendar bukan JSON valid.") from exc
+        finally:
+            if close_client:
+                await client.aclose()
+
+        raw_events = payload.get("economicCalendar") if isinstance(payload, dict) else None
+        if not isinstance(raw_events, list):
+            raise ProviderError("Response Finnhub economic calendar tidak valid.")
+        return [_parse_event(item) for item in raw_events if isinstance(item, dict)]
+
+
+def default_calendar_window(mode: str | None = None) -> tuple[date, date]:
+    today = date.today()
+    if mode == "today":
+        return today, today
+    if mode == "week":
+        return today, today + timedelta(days=7)
+    return today, today + timedelta(days=7)
+
+
+def fallback_events(start: date, end: date) -> list[EconomicEvent]:
+    """Return non-date-specific event categories when no provider is configured."""
+
+    return [
+        EconomicEvent("Central bank rate decisions", "Global", "high", None, unit="event group"),
+        EconomicEvent("Inflation releases: CPI/PCE", "Global", "high", None, unit="event group"),
+        EconomicEvent("Labor market data: payrolls/unemployment", "Global", "high", None, unit="event group"),
+        EconomicEvent("GDP, PMI, retail sales, consumer sentiment", "Global", "medium", None, unit="event group"),
+        EconomicEvent(
+            f"Provider window requested: {start.isoformat()} to {end.isoformat()}",
+            "FinCLI",
+            "info",
+            None,
+            unit="fallback",
+        ),
+    ]
+
+
+def filter_events(events: list[EconomicEvent], country: str | None = None, impact: str | None = None) -> list[EconomicEvent]:
+    filtered = events
+    if country:
+        normalized_country = country.lower()
+        filtered = [event for event in filtered if event.country.lower() == normalized_country]
+    if impact:
+        normalized_impact = impact.lower()
+        filtered = [event for event in filtered if event.impact.lower() == normalized_impact]
+    return filtered
+
+
+def _parse_event(item: dict[str, Any]) -> EconomicEvent:
+    return EconomicEvent(
+        event=str(item.get("event") or item.get("name") or "Untitled event"),
+        country=str(item.get("country") or "N/A"),
+        impact=str(item.get("impact") or "N/A").lower(),
+        time=_parse_time(item.get("time")),
+        actual=_optional_text(item.get("actual")),
+        estimate=_optional_text(item.get("estimate")),
+        previous=_optional_text(item.get("prev") if "prev" in item else item.get("previous")),
+        unit=_optional_text(item.get("unit")),
+    )
+
+
+def _parse_time(value: object) -> datetime | None:
+    if not value:
+        return None
+    if isinstance(value, (int, float)):
+        return datetime.fromtimestamp(value)
+    text = str(value).replace("Z", "+00:00")
+    try:
+        return datetime.fromisoformat(text)
+    except ValueError:
+        return None
+
+
+def _optional_text(value: object) -> str | None:
+    if value is None or value == "":
+        return None
+    return str(value)

package/fincli/app/modules/exporter.py

@@ -0,0 +1,51 @@
+"""CSV and JSON export helpers."""
+
+from __future__ import annotations
+
+import csv
+import json
+from pathlib import Path
+from typing import Any
+
+from fincli.app.utils.errors import CommandError
+
+
+def export_rows(rows: list[dict[str, Any]], fmt: str, target: str | Path) -> Path:
+    """Export rows to CSV or JSON and return the written path."""
+    export_format = fmt.lower()
+    path = _safe_export_path(target)
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    if export_format == "json":
+        path.write_text(json.dumps(rows, indent=2, default=str), encoding="utf-8")
+        return path
+
+    if export_format == "csv":
+        fieldnames = _fieldnames(rows)
+        with path.open("w", newline="", encoding="utf-8") as handle:
+            writer = csv.DictWriter(handle, fieldnames=fieldnames)
+            writer.writeheader()
+            writer.writerows(rows)
+        return path
+
+    raise CommandError("Format export harus csv atau json.")
+
+
+def _fieldnames(rows: list[dict[str, Any]]) -> list[str]:
+    if not rows:
+        return []
+    fields: list[str] = []
+    for row in rows:
+        for key in row:
+            if key not in fields:
+                fields.append(key)
+    return fields
+
+
+def _safe_export_path(target: str | Path) -> Path:
+    path = Path(target).expanduser()
+    if any(part == ".." for part in path.parts):
+        raise CommandError("Path export tidak boleh mengandung '..'.")
+    if path.suffix.lower() not in {".csv", ".json"}:
+        raise CommandError("Path export harus berakhiran .csv atau .json.")
+    return path

package/fincli/app/modules/journal.py

@@ -0,0 +1,65 @@
+"""Trading journal service."""
+
+from __future__ import annotations
+
+from fincli.app.storage.database import FinCLIDatabase
+from fincli.app.utils.formatting import normalize_symbol
+
+
+class JournalService:
+    def __init__(self, db: FinCLIDatabase) -> None:
+        self.db = db
+
+    def add(
+        self,
+        instrument: str,
+        bias: str = "",
+        entry_reason: str = "",
+        exit_reason: str = "",
+        result: str = "",
+        emotion: str = "",
+        lesson: str = "",
+        tags: str = "",
+    ) -> None:
+        self.db.execute(
+            """
+            INSERT INTO journal_entries(
+                instrument, bias, entry_reason, exit_reason, result, emotion, lesson, tags
+            )
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                normalize_symbol(instrument),
+                bias,
+                entry_reason,
+                exit_reason,
+                result,
+                emotion,
+                lesson,
+                tags,
+            ),
+        )
+
+    def list(self, instrument: str | None = None, limit: int = 20) -> list[dict[str, object]]:
+        if instrument:
+            rows = self.db.query(
+                """
+                SELECT id, instrument, bias, entry_reason, result, emotion, lesson, tags, created_at
+                FROM journal_entries
+                WHERE instrument = ?
+                ORDER BY created_at DESC
+                LIMIT ?
+                """,
+                (normalize_symbol(instrument), limit),
+            )
+        else:
+            rows = self.db.query(
+                """
+                SELECT id, instrument, bias, entry_reason, result, emotion, lesson, tags, created_at
+                FROM journal_entries
+                ORDER BY created_at DESC
+                LIMIT ?
+                """,
+                (limit,),
+            )
+        return [dict(row) for row in rows]

package/fincli/app/modules/journal_analytics.py

@@ -0,0 +1,70 @@
+"""Journal statistics and AI review prompt helpers."""
+
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class JournalStats:
+    total_entries: int
+    wins: int
+    losses: int
+    win_rate: float
+    top_instrument: str
+    top_emotion: str
+    top_tags: list[str]
+
+
+def calculate_journal_stats(entries: list[dict[str, object]]) -> JournalStats:
+    total = len(entries)
+    wins = sum(1 for entry in entries if str(entry.get("result", "")).lower() == "win")
+    losses = sum(1 for entry in entries if str(entry.get("result", "")).lower() == "loss")
+    win_rate = (wins / total * 100) if total else 0.0
+
+    instruments = Counter(str(entry.get("instrument", "")) for entry in entries if entry.get("instrument"))
+    emotions = Counter(str(entry.get("emotion", "")) for entry in entries if entry.get("emotion"))
+    tags = Counter()
+    for entry in entries:
+        for tag in str(entry.get("tags", "")).split(","):
+            cleaned = tag.strip()
+            if cleaned:
+                tags[cleaned] += 1
+
+    return JournalStats(
+        total_entries=total,
+        wins=wins,
+        losses=losses,
+        win_rate=win_rate,
+        top_instrument=instruments.most_common(1)[0][0] if instruments else "N/A",
+        top_emotion=emotions.most_common(1)[0][0] if emotions else "N/A",
+        top_tags=[tag for tag, _ in tags.most_common(5)],
+    )
+
+
+def build_journal_review_prompt(entries: list[dict[str, object]], stats: JournalStats) -> str:
+    recent_lines = []
+    for entry in entries[:20]:
+        recent_lines.append(
+            (
+                f"- {entry.get('instrument')} | bias={entry.get('bias')} | result={entry.get('result')} | "
+                f"emotion={entry.get('emotion')} | reason={entry.get('entry_reason')} | lesson={entry.get('lesson')}"
+            )
+        )
+    return (
+        "You are FinCLI's trading journal review assistant.\n"
+        "Review the user's journal based only on the provided entries. Do not invent trades.\n"
+        "Focus on process quality, recurring mistakes, emotional patterns, risk control, and concrete improvements.\n"
+        "Do not provide financial advice or guaranteed trading signals.\n\n"
+        f"Total Entries: {stats.total_entries}\n"
+        f"Wins: {stats.wins}\n"
+        f"Losses: {stats.losses}\n"
+        f"Win Rate: {stats.win_rate:.4f}\n"
+        f"Top Instrument: {stats.top_instrument}\n"
+        f"Top Emotion: {stats.top_emotion}\n"
+        f"Top Tags: {', '.join(stats.top_tags) if stats.top_tags else 'N/A'}\n\n"
+        "Recent Entries:\n"
+        f"{chr(10).join(recent_lines) if recent_lines else 'No entries.'}\n\n"
+        "Return sections: Summary, Strengths, Repeated Mistakes, Risk Notes, Process Improvements, Disclaimer."
+    )

package/fincli/app/modules/portfolio.py

@@ -0,0 +1,34 @@
+"""Portfolio management service."""
+
+from __future__ import annotations
+
+from fincli.app.storage.database import FinCLIDatabase
+from fincli.app.utils.formatting import normalize_symbol
+
+
+class PortfolioService:
+    def __init__(self, db: FinCLIDatabase) -> None:
+        self.db = db
+
+    def add(self, symbol: str, quantity: float, average_price: float, currency: str = "USD") -> None:
+        self.db.execute(
+            """
+            INSERT INTO portfolio_positions(symbol, quantity, average_price, currency)
+            VALUES (?, ?, ?, ?)
+            ON CONFLICT(symbol) DO UPDATE SET
+                quantity = excluded.quantity,
+                average_price = excluded.average_price,
+                currency = excluded.currency,
+                updated_at = CURRENT_TIMESTAMP
+            """,
+            (normalize_symbol(symbol), quantity, average_price, currency.upper()),
+        )
+
+    def remove(self, symbol: str) -> None:
+        self.db.execute("DELETE FROM portfolio_positions WHERE symbol = ?", (normalize_symbol(symbol),))
+
+    def list(self) -> list[dict[str, object]]:
+        rows = self.db.query(
+            "SELECT symbol, quantity, average_price, currency, updated_at FROM portfolio_positions ORDER BY symbol"
+        )
+        return [dict(row) for row in rows]

package/fincli/app/modules/scanner.py

@@ -0,0 +1,105 @@
+"""Watchlist scanner with simple technical filters."""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+
+from fincli.app.analysis.indicators import TechnicalSummary, summarize_technical_indicators
+from fincli.app.providers.market.base import BaseMarketProvider
+
+
+@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]:
+    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}"

package/fincli/app/modules/transactions.py

@@ -0,0 +1,84 @@
+"""Portfolio transaction ledger."""
+
+from __future__ import annotations
+
+from fincli.app.modules.portfolio import PortfolioService
+from fincli.app.storage.database import FinCLIDatabase
+from fincli.app.utils.errors import CommandError
+from fincli.app.utils.formatting import normalize_symbol
+
+
+class TransactionService:
+    def __init__(self, db: FinCLIDatabase, portfolio: PortfolioService) -> None:
+        self.db = db
+        self.portfolio = portfolio
+
+    def add(self, action: str, symbol: str, quantity: float, price: float, currency: str = "USD") -> dict[str, object]:
+        normalized_action = action.lower()
+        normalized_symbol = normalize_symbol(symbol)
+        if normalized_action not in {"buy", "sell"}:
+            raise CommandError("Action transaksi harus buy atau sell.")
+        if quantity <= 0 or price <= 0:
+            raise CommandError("Quantity dan price harus lebih besar dari 0.")
+
+        current = self._position(normalized_symbol)
+        realized_pnl = 0.0
+
+        if normalized_action == "buy":
+            old_qty = float(current["quantity"]) if current else 0.0
+            old_avg = float(current["average_price"]) if current else 0.0
+            new_qty = old_qty + quantity
+            new_avg = ((old_qty * old_avg) + (quantity * price)) / new_qty
+            self.portfolio.add(normalized_symbol, new_qty, new_avg, currency)
+        else:
+            if current is None:
+                raise CommandError(f"Tidak ada posisi {normalized_symbol} untuk dijual.")
+            old_qty = float(current["quantity"])
+            old_avg = float(current["average_price"])
+            if quantity > old_qty:
+                raise CommandError(f"Quantity sell melebihi posisi {normalized_symbol}.")
+            realized_pnl = (price - old_avg) * quantity
+            remaining = old_qty - quantity
+            if remaining == 0:
+                self.portfolio.remove(normalized_symbol)
+            else:
+                self.portfolio.add(normalized_symbol, remaining, old_avg, currency)
+
+        self.db.execute(
+            """
+            INSERT INTO portfolio_transactions(action, symbol, quantity, price, currency, realized_pnl)
+            VALUES (?, ?, ?, ?, ?, ?)
+            """,
+            (normalized_action, normalized_symbol, quantity, price, currency.upper(), realized_pnl),
+        )
+        return {
+            "action": normalized_action,
+            "symbol": normalized_symbol,
+            "quantity": quantity,
+            "price": price,
+            "currency": currency.upper(),
+            "realized_pnl": realized_pnl,
+        }
+
+    def list(self, limit: int = 50) -> list[dict[str, object]]:
+        rows = self.db.query(
+            """
+            SELECT id, action, symbol, quantity, price, currency, realized_pnl, created_at
+            FROM portfolio_transactions
+            ORDER BY id DESC
+            LIMIT ?
+            """,
+            (limit,),
+        )
+        return [dict(row) for row in rows]
+
+    def realized_pnl_total(self) -> float:
+        rows = self.db.query("SELECT COALESCE(SUM(realized_pnl), 0) AS total FROM portfolio_transactions")
+        return float(rows[0]["total"]) if rows else 0.0
+
+    def _position(self, symbol: str) -> dict[str, object] | None:
+        rows = self.db.query(
+            "SELECT symbol, quantity, average_price, currency FROM portfolio_positions WHERE symbol = ?",
+            (symbol,),
+        )
+        return dict(rows[0]) if rows else None

package/fincli/app/modules/watchlist.py

@@ -0,0 +1,25 @@
+"""Watchlist commands backed by local SQLite."""
+
+from __future__ import annotations
+
+from fincli.app.storage.database import FinCLIDatabase
+from fincli.app.utils.formatting import normalize_symbol
+
+
+class WatchlistService:
+    def __init__(self, db: FinCLIDatabase) -> None:
+        self.db = db
+
+    def add(self, symbol: str, group_name: str = "default") -> None:
+        normalized = normalize_symbol(symbol)
+        self.db.execute(
+            "INSERT OR REPLACE INTO watchlist(symbol, group_name) VALUES (?, ?)",
+            (normalized, group_name),
+        )
+
+    def remove(self, symbol: str) -> None:
+        self.db.execute("DELETE FROM watchlist WHERE symbol = ?", (normalize_symbol(symbol),))
+
+    def list(self) -> list[dict[str, str]]:
+        rows = self.db.query("SELECT symbol, group_name, created_at FROM watchlist ORDER BY symbol")
+        return [dict(row) for row in rows]

package/fincli/app/providers/__init__.py

@@ -0,0 +1 @@
+"""Provider abstractions."""

package/fincli/app/providers/ai/__init__.py

@@ -0,0 +1 @@
+"""AI provider modules."""

package/fincli/app/providers/ai/anthropic_provider.py

@@ -0,0 +1,11 @@
+"""Anthropic provider placeholder for Phase 2."""
+
+from fincli.app.providers.ai.base import AIRequest, AIResponse, BaseAIProvider
+from fincli.app.utils.errors import ProviderError
+
+
+class AnthropicProvider(BaseAIProvider):
+    name = "anthropic"
+
+    async def complete(self, request: AIRequest) -> AIResponse:
+        raise ProviderError("Anthropic client belum diimplementasi di Phase 1.")

package/fincli/app/providers/ai/base.py

@@ -0,0 +1,29 @@
+"""Base AI provider contract for future provider implementations."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class AIRequest:
+    prompt: str
+    model: str
+    temperature: float = 0.2
+    timeout_seconds: int = 45
+
+
+@dataclass(frozen=True, slots=True)
+class AIResponse:
+    provider: str
+    model: str
+    content: str
+
+
+class BaseAIProvider(ABC):
+    name: str
+
+    @abstractmethod
+    async def complete(self, request: AIRequest) -> AIResponse:
+        """Return a completion response from the provider."""

package/fincli/app/providers/ai/gemini_provider.py

@@ -0,0 +1,11 @@
+"""Gemini provider placeholder for Phase 2."""
+
+from fincli.app.providers.ai.base import AIRequest, AIResponse, BaseAIProvider
+from fincli.app.utils.errors import ProviderError
+
+
+class GeminiProvider(BaseAIProvider):
+    name = "gemini"
+
+    async def complete(self, request: AIRequest) -> AIResponse:
+        raise ProviderError("Gemini client belum diimplementasi di Phase 1.")

package/fincli/app/providers/ai/groq_provider.py

@@ -0,0 +1,11 @@
+"""Groq provider placeholder for Phase 2."""
+
+from fincli.app.providers.ai.base import AIRequest, AIResponse, BaseAIProvider
+from fincli.app.utils.errors import ProviderError
+
+
+class GroqProvider(BaseAIProvider):
+    name = "groq"
+
+    async def complete(self, request: AIRequest) -> AIResponse:
+        raise ProviderError("Groq client belum diimplementasi di Phase 1.")