@drico2008/fincli 0.1.3 → 0.2.2

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}"

package/fincli/app/modules/session_history.py

@@ -0,0 +1,113 @@
+"""Session history service for FinCLI commands."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import re
+from uuid import uuid4
+
+from fincli.app.storage.database import FinCLIDatabase
+
+
+_AI_NEWS_KEY_PATTERN = re.compile(r"^/(ai_model|news_model)\s+key\s+(\S+)\s+(.+)$", re.IGNORECASE)
+_PROVIDER_KEY_PATTERN = re.compile(r"^/provider\s+key\s+(\S+)\s+(.+)$", re.IGNORECASE)
+_SECRET_VALUE_PATTERNS = (
+    re.compile(r"(?i)(api[_ -]?key|token|secret|password)\s*[:=]\s*\S+"),
+)
+
+
+class SessionHistoryService:
+    """Persist local command sessions and sanitized command events."""
+
+    def __init__(self, db: FinCLIDatabase) -> None:
+        self.db = db
+
+    def start_session(self, title: str = "FinCLI session") -> str:
+        session_id = uuid4().hex[:12]
+        now = _now()
+        self.db.execute(
+            "INSERT INTO sessions (id, title, created_at, updated_at) VALUES (?, ?, ?, ?)",
+            (session_id, title, now, now),
+        )
+        return session_id
+
+    def save_session(self, session_id: str, title: str) -> None:
+        self.db.execute(
+            "UPDATE sessions SET title = ?, updated_at = ? WHERE id = ?",
+            (title.strip() or "FinCLI session", _now(), session_id),
+        )
+
+    def record_event(self, session_id: str, command: str, status: str, output_preview: str = "") -> None:
+        sanitized_command = sanitize_history_text(command.strip())
+        sanitized_output = sanitize_history_text(output_preview.strip())[:1200]
+        if not sanitized_command:
+            return
+        self.db.execute(
+            """
+            INSERT INTO session_events (session_id, command, status, output_preview, created_at)
+            VALUES (?, ?, ?, ?, ?)
+            """,
+            (session_id, sanitized_command, status, sanitized_output, _now()),
+        )
+        self.db.execute("UPDATE sessions SET updated_at = ? WHERE id = ?", (_now(), session_id))
+
+    def list_sessions(self, limit: int = 20) -> list[dict[str, object]]:
+        rows = self.db.query(
+            """
+            SELECT s.id, s.title, s.created_at, s.updated_at, COUNT(e.id) AS event_count
+            FROM sessions s
+            LEFT JOIN session_events e ON e.session_id = s.id
+            GROUP BY s.id
+            ORDER BY s.updated_at DESC
+            LIMIT ?
+            """,
+            (limit,),
+        )
+        return [dict(row) for row in rows]
+
+    def get_events(self, session_id: str, limit: int = 100) -> list[dict[str, object]]:
+        rows = self.db.query(
+            """
+            SELECT id, command, status, output_preview, created_at
+            FROM session_events
+            WHERE session_id = ?
+            ORDER BY id ASC
+            LIMIT ?
+            """,
+            (session_id, limit),
+        )
+        return [dict(row) for row in rows]
+
+    def get_session(self, session_id: str) -> dict[str, object] | None:
+        rows = self.db.query("SELECT id, title, created_at, updated_at FROM sessions WHERE id = ?", (session_id,))
+        return dict(rows[0]) if rows else None
+
+    def delete_session(self, session_id: str) -> int:
+        self.db.execute("DELETE FROM session_events WHERE session_id = ?", (session_id,))
+        self.db.execute("DELETE FROM sessions WHERE id = ?", (session_id,))
+        return 1
+
+    def clear_events(self, session_id: str) -> None:
+        self.db.execute("DELETE FROM session_events WHERE session_id = ?", (session_id,))
+        self.db.execute("UPDATE sessions SET updated_at = ? WHERE id = ?", (_now(), session_id))
+
+    def clear_all(self) -> None:
+        self.db.execute("DELETE FROM session_events")
+        self.db.execute("DELETE FROM sessions")
+
+
+def sanitize_history_text(value: str) -> str:
+    sanitized = value
+    match = _AI_NEWS_KEY_PATTERN.match(sanitized)
+    if match:
+        return f"/{match.group(1)} key {match.group(2)} <redacted>"
+    match = _PROVIDER_KEY_PATTERN.match(sanitized)
+    if match:
+        return f"/provider key {match.group(1)} <redacted>"
+    for pattern in _SECRET_VALUE_PATTERNS:
+        sanitized = pattern.sub(lambda match: f"{match.group(1)}=<redacted>", sanitized)
+    return sanitized
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")

package/fincli/app/modules/transactions.py

@@ -1,84 +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
+"""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/user_profile.py

@@ -0,0 +1,84 @@
+"""Local user profile and gameplay rules."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from fincli.app.storage.database import FinCLIDatabase
+
+
+@dataclass(frozen=True, slots=True)
+class UserProfile:
+    name: str
+    equity: float
+    currency: str
+    leverage: str
+    years_in_investment: float
+    gameplay: str
+
+
+class UserProfileService:
+    """Persist one local profile used to tailor /analyze risk context."""
+
+    def __init__(self, db: FinCLIDatabase) -> None:
+        self.db = db
+
+    def save(self, name: str, equity: float, currency: str, leverage: str, years: float) -> UserProfile:
+        profile = UserProfile(
+            name=name.strip(),
+            equity=float(equity),
+            currency=currency.strip().upper(),
+            leverage=leverage.strip(),
+            years_in_investment=float(years),
+            gameplay=classify_gameplay(float(equity)),
+        )
+        self.db.execute(
+            """
+            INSERT INTO user_profile (id, name, equity, currency, leverage, years_in_investment, gameplay, updated_at)
+            VALUES (1, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+            ON CONFLICT(id) DO UPDATE SET
+                name=excluded.name,
+                equity=excluded.equity,
+                currency=excluded.currency,
+                leverage=excluded.leverage,
+                years_in_investment=excluded.years_in_investment,
+                gameplay=excluded.gameplay,
+                updated_at=CURRENT_TIMESTAMP
+            """,
+            (
+                profile.name,
+                profile.equity,
+                profile.currency,
+                profile.leverage,
+                profile.years_in_investment,
+                profile.gameplay,
+            ),
+        )
+        return profile
+
+    def get(self) -> UserProfile | None:
+        rows = self.db.query("SELECT * FROM user_profile WHERE id = 1")
+        if not rows:
+            return None
+        row = rows[0]
+        return UserProfile(
+            name=str(row["name"]),
+            equity=float(row["equity"]),
+            currency=str(row["currency"]),
+            leverage=str(row["leverage"]),
+            years_in_investment=float(row["years_in_investment"]),
+            gameplay=str(row["gameplay"]),
+        )
+
+    def clear(self) -> None:
+        self.db.execute("DELETE FROM user_profile WHERE id = 1")
+
+
+def classify_gameplay(equity: float) -> str:
+    if equity <= 400:
+        return "Scalper"
+    if equity <= 1000:
+        return "Intra day"
+    if equity <= 5000:
+        return "Day trade"
+    return "Swing/Investor"

package/fincli/app/plugins/loader.py

@@ -0,0 +1,72 @@
+"""Local plugin discovery for FinCLI.
+
+Plugins are intentionally manifest-first in v0.2.2: 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/ai/anthropic_provider.py

@@ -1,11 +1,12 @@
-"""Anthropic provider placeholder for Phase 2."""
+"""Anthropic provider compatibility wrapper."""
 
-from fincli.app.providers.ai.base import AIRequest, AIResponse, BaseAIProvider
-from fincli.app.utils.errors import ProviderError
+from __future__ import annotations
 
+import os
 
-class AnthropicProvider(BaseAIProvider):
-    name = "anthropic"
+from fincli.app.providers.ai.http_provider import AnthropicProviderHTTP
 
-    async def complete(self, request: AIRequest) -> AIResponse:
-        raise ProviderError("Anthropic client belum diimplementasi di Phase 1.")
+
+class AnthropicProvider(AnthropicProviderHTTP):
+    def __init__(self, api_key: str | None = None) -> None:
+        super().__init__(api_key or os.getenv("ANTHROPIC_API_KEY"))