@drico2008/fincli 0.1.2 → 0.1.9

package/fincli/app/cli/router.py

@@ -6,16 +6,19 @@ import asyncio
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
 from datetime import date
+import io
 import os
 import shlex
 from typing import Any
 
+from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
 
 from fincli.app.cli.commands import CommandRegistry
 from fincli.app.analysis.analyzer import build_market_analysis_prompt, build_technical_ai_summary
 from fincli.app.analysis.assistant_context import (
+    build_web_research_answer_prompt,
     build_fincli_assistant_prompt,
     coding_refusal,
     extract_market_symbols,
@@ -37,6 +40,7 @@ from fincli.app.modules.journal_analytics import JournalStats, build_journal_rev
 from fincli.app.modules.journal import JournalService
 from fincli.app.modules.portfolio import PortfolioService
 from fincli.app.modules.scanner import ScanResult, scan_symbols
+from fincli.app.modules.session_history import SessionHistoryService
 from fincli.app.modules.transactions import TransactionService
 from fincli.app.modules.watchlist import WatchlistService
 from fincli.app.providers.ai.base import AIRequest, AIResponse, BaseAIProvider
@@ -46,11 +50,19 @@ from fincli.app.providers.market.manager import MarketProviderManager
 from fincli.app.providers.market.yfinance_provider import YahooTable, YFinanceProvider
 from fincli.app.services.market_data import MarketDataService
 from fincli.app.services.market_overview import MarketOverview, build_market_overview
+from fincli.app.services.web_research import (
+    WebResearchService,
+    WebSearchResult,
+    build_web_research_context,
+    should_use_web_research,
+)
 from fincli.app.storage.cache import TTLCache
 from fincli.app.storage.config import ConfigManager
 from fincli.app.storage.database import FinCLIDatabase
 from fincli.app.storage.market_cache import MarketCache
+from fincli.app.storage.secrets import save_secret
 from fincli.app.utils.errors import CommandError, FinCLIError
+from fincli.app.utils.formatting import AIResponseView, MarkdownBlock
 
 
 @dataclass(slots=True)
@@ -85,8 +97,16 @@ class CommandRouter:
         self.portfolio = PortfolioService(self.db)
         self.transactions = TransactionService(self.db, self.portfolio)
         self.journal = JournalService(self.db)
+        self.history = SessionHistoryService(self.db)
+        self.session_id = self.history.start_session()
+        self.web_research = WebResearchService()
 
     def route(self, raw: str) -> CommandResult:
+        result = self._route(raw)
+        self._record_history(raw, result)
+        return result
+
+    def _route(self, raw: str) -> CommandResult:
         raw = raw.strip()
         if not raw:
             return CommandResult(Panel("Ketik /help untuk melihat command.", title="FinCLI"))
@@ -116,6 +136,8 @@ class CommandRouter:
                 return CommandResult("Keluar dari FinCLI.", should_exit=True)
             if root == "/config":
                 return CommandResult(self._config_panel())
+            if root == "/history":
+                return self._history(args)
             if root == "/ai_model":
                 return self._ai_model(args)
             if root == "/news_model":
@@ -132,8 +154,8 @@ class CommandRouter:
                 return self._tx(args)
             if root == "/journal":
                 return self._journal(args)
-            if root in {"/price", "/quote"}:
-                return self._price(args)
+            if root == "/quote":
+                return self._quote(args)
             if root == "/market":
                 return self._market(args)
             if root == "/technical":
@@ -142,6 +164,8 @@ class CommandRouter:
                 return self._structure(args)
             if root == "/news":
                 return self._news(args)
+            if root == "/web":
+                return self._web(args)
             if root == "/funda":
                 return self._fundamentals(args)
             if root == "/yahoo":
@@ -179,6 +203,57 @@ class CommandRouter:
             table.add_row(command.name, command.group, command.description, command.example)
         return table
 
+    def _record_history(self, raw: str, result: CommandResult) -> None:
+        normalized = raw.strip().lower()
+        if not normalized or normalized.startswith("/history"):
+            return
+        try:
+            preview = _render_history_preview(result.renderable)
+            self.history.record_event(self.session_id, raw, result.status, preview)
+        except FinCLIError:
+            return
+
+    def _history(self, args: list[str]) -> CommandResult:
+        action = args[0].lower() if args else "current"
+        if action in {"current", "show"}:
+            session_id = self.session_id if action == "current" or len(args) == 1 else args[1]
+            if action == "show" and len(args) < 2:
+                raise CommandError("Format: /history show <session_id>")
+            session = self.history.get_session(session_id)
+            if not session:
+                raise CommandError(f"Session tidak ditemukan: {session_id}")
+            events = self.history.get_events(session_id)
+            return CommandResult(_format_session_events(session, events, current=session_id == self.session_id))
+        if action in {"sessions", "list"}:
+            sessions = self.history.list_sessions()
+            return CommandResult(_format_sessions(sessions, self.session_id))
+        if action == "save":
+            title = " ".join(args[1:]).strip()
+            if not title:
+                raise CommandError("Format: /history save <session_title>")
+            self.history.save_session(self.session_id, title)
+            return CommandResult(Panel(f"Current session disimpan sebagai: {title}", title="History", border_style="green"))
+        if action == "delete":
+            if len(args) < 2:
+                raise CommandError("Format: /history delete <session_id>")
+            if args[1] == self.session_id:
+                self.history.clear_events(self.session_id)
+                self.history.save_session(self.session_id, "FinCLI session")
+                return CommandResult(Panel("Current session dikosongkan.", title="History", border_style="yellow"))
+            self.history.delete_session(args[1])
+            return CommandResult(Panel(f"Session dihapus: {args[1]}", title="History", border_style="green"))
+        if action == "clear":
+            target = args[1].lower() if len(args) >= 2 else "current"
+            if target == "all":
+                self.history.clear_all()
+                self.session_id = self.history.start_session()
+                return CommandResult(Panel("Semua history session dihapus. Session baru dibuat.", title="History"))
+            self.history.clear_events(self.session_id)
+            return CommandResult(Panel("Current session history dikosongkan.", title="History"))
+        raise CommandError(
+            "Format: /history [current|sessions|show <id>|save <title>|delete <id>|clear current|clear all]"
+        )
+
     def _dashboard(self) -> Table:
         return _format_dashboard(
             provider_chain=[provider.name for provider in self.market_service.providers],
@@ -211,6 +286,28 @@ class CommandRouter:
         if len(args) == 0:
             current = self.config.settings
             return CommandResult(Panel(f"{current.ai_provider} / {current.ai_model}", title="Active AI Model"))
+        if args[0].lower() == "key":
+            if len(args) < 3:
+                raise CommandError("Format: /ai_model key <provider> <api_key>")
+            provider = args[1].lower()
+            info = AIProviderManager().get(provider)
+            if info is None:
+                raise CommandError(f"AI provider tidak dikenal: {provider}")
+            save_secret(info.env_key, args[2])
+            model = self.config.settings.ai_model if self.config.settings.ai_provider == provider else info.default_model
+            self.config.set_ai_model(provider, model)
+            self.ai_provider = AIProviderManager().create(provider)
+            return CommandResult(
+                Panel(
+                    (
+                        f"API key AI untuk {provider} disimpan global di ~/.fincli/secrets.env.\n"
+                        f"Provider aktif disimpan: {provider} / {model}.\n"
+                        "Key tidak ditampilkan di terminal dan dipakai lintas session."
+                    ),
+                    title="AI API Key Saved",
+                    border_style="green",
+                )
+            )
         if len(args) < 2:
             raise CommandError("Format: /ai_model <provider> <model>")
         self.config.set_ai_model(args[0], args[1])
@@ -232,6 +329,31 @@ class CommandRouter:
                     title="Active Data Provider",
                 )
             )
+        if args[0].lower() == "key":
+            if len(args) < 3:
+                raise CommandError("Format: /news_model key <provider> <api_key> [base_url untuk custom]")
+            provider = args[1].lower()
+            env_keys = _market_provider_secret_keys(provider)
+            if not env_keys:
+                raise CommandError(f"Provider {provider} tidak membutuhkan API key atau tidak dikenal.")
+            save_secret(env_keys[0], args[2])
+            if provider == "custom" and len(args) >= 4:
+                save_secret("MARKET_DATA_BASE_URL", args[3])
+            self.config.set_market_provider_priority([provider, *self._priority_tail(provider)])
+            self._refresh_market_service()
+            self.cache.clear()
+            extra = "\nBase URL custom juga disimpan." if provider == "custom" and len(args) >= 4 else ""
+            return CommandResult(
+                Panel(
+                    (
+                        f"API key market/news untuk {provider} disimpan global di ~/.fincli/secrets.env.{extra}\n"
+                        f"Provider market/news aktif disimpan: {provider}.\n"
+                        "Key tidak ditampilkan di terminal dan dipakai lintas session."
+                    ),
+                    title="Market API Key Saved",
+                    border_style="green",
+                )
+            )
         self.config.set_market_provider(args[0])
         self.config.set_news_provider(args[0])
         self.config.set_market_provider_priority([args[0], *self._priority_tail(args[0])])
@@ -442,7 +564,9 @@ class CommandRouter:
             response = self._run_async(self.ai_provider.complete(AIRequest(prompt=prompt, model=self.config.settings.ai_model)))
             if not isinstance(response, AIResponse):
                 raise CommandError("AI provider mengembalikan data tidak valid.")
-            return CommandResult(f"Journal Review\n{_format_ai_response(response)}\n\nDisclaimer: bukan nasihat keuangan.")
+            return CommandResult(
+                MarkdownBlock("Journal Review", _format_ai_response(response), "Disclaimer: bukan nasihat keuangan.")
+            )
 
         if args[0].lower() == "add":
             if len(args) < 3:
@@ -472,9 +596,9 @@ class CommandRouter:
             table.add_row("-", "-", "-", 'Belum ada journal. Gunakan /journal add BTC-USD bullish "Alasan entry"', "-")
         return table
 
-    def _price(self, args: list[str]) -> CommandResult:
+    def _quote(self, args: list[str]) -> CommandResult:
         if not args:
-            raise CommandError("Format: /price <symbol>")
+            raise CommandError("Format: /quote <symbol>")
         symbol = args[0].upper()
         cache_key = f"quote:{symbol}"
         cached = self.cache.get(cache_key)
@@ -556,6 +680,9 @@ class CommandRouter:
             return CommandResult(_format_ai_response(response))
 
         market_context = self._freechat_market_context(prompt)
+        web_context = self._freechat_web_context(prompt)
+        if web_context:
+            market_context = f"{market_context}\n\n{web_context}".strip()
         assistant_prompt = build_fincli_assistant_prompt(prompt, market_context)
         request = AIRequest(prompt=assistant_prompt, model=self.config.settings.ai_model)
         response = self._run_async(self.ai_provider.complete(request))
@@ -563,6 +690,26 @@ class CommandRouter:
             raise CommandError("AI provider mengembalikan data tidak valid.")
         return CommandResult(_format_ai_response(response))
 
+    def _web(self, args: list[str]) -> CommandResult:
+        if not args:
+            raise CommandError("Format: /web <query>")
+        if args[0].lower() in {"sources", "source", "raw"}:
+            source_query = " ".join(args[1:]).strip()
+            if not source_query:
+                raise CommandError("Format: /web sources <query>")
+            results = self._run_async(self.web_research.research(source_query, limit=5))
+            return CommandResult(_format_web_results(source_query, results))
+
+        query = " ".join(args)
+        results = self._run_async(self.web_research.research(query, limit=5))
+        context = build_web_research_context(results)
+        assistant_prompt = build_web_research_answer_prompt(query, context)
+        request = AIRequest(prompt=assistant_prompt, model=self.config.settings.ai_model)
+        response = self._run_async(self.ai_provider.complete(request))
+        if not isinstance(response, AIResponse):
+            raise CommandError("AI provider mengembalikan data tidak valid.")
+        return CommandResult(_format_ai_response(response))
+
     def _analyze(self, args: list[str]) -> CommandResult:
         if not args:
             raise CommandError("Format: /analyze <symbol> [timeframe]")
@@ -579,7 +726,9 @@ class CommandRouter:
         response = self._run_async(self.ai_provider.complete(request))
         if not isinstance(response, AIResponse):
             raise CommandError("AI provider mengembalikan data tidak valid.")
-        return CommandResult(f"AI Market Analysis: {symbol}\n{_format_ai_response(response)}\n\nDisclaimer: bukan nasihat keuangan.")
+        return CommandResult(
+            MarkdownBlock(f"AI Market Analysis: {symbol}", _format_ai_response(response), "Disclaimer: bukan nasihat keuangan.")
+        )
 
     def _scan(self, args: list[str]) -> CommandResult:
         if not args or args[0].lower() != "watchlist":
@@ -718,6 +867,21 @@ class CommandRouter:
             sections.append(self._symbol_freechat_context(symbol))
         return "\n\n".join(sections)
 
+    def _freechat_web_context(self, prompt: str) -> str:
+        if not should_use_web_research(prompt):
+            return ""
+        cache_key = f"web:{prompt.lower()[:180]}"
+        cached = self.cache.get(cache_key)
+        if isinstance(cached, str):
+            return cached
+        try:
+            results = self._run_async(self.web_research.research(prompt, limit=3))
+        except FinCLIError as exc:
+            return f"Web Research: unavailable ({exc})"
+        context = build_web_research_context(results)
+        self.cache.set(cache_key, context)
+        return context
+
     def _symbol_freechat_context(self, symbol: str) -> str:
         lines = [f"Symbol: {symbol}"]
         try:
@@ -840,6 +1004,63 @@ def _format_quote(quote: Quote) -> str:
     )
 
 
+def _format_sessions(sessions: list[dict[str, object]], current_session_id: str) -> Table:
+    table = Table(title="FinCLI Sessions", expand=True)
+    table.add_column("Current", justify="center", width=7)
+    table.add_column("Session ID", style="cyan", no_wrap=True)
+    table.add_column("Title", style="white")
+    table.add_column("Events", justify="right")
+    table.add_column("Updated", style="dim")
+    for session in sessions:
+        session_id = str(session["id"])
+        table.add_row(
+            "*" if session_id == current_session_id else "",
+            session_id,
+            str(session["title"]),
+            str(session["event_count"]),
+            str(session["updated_at"]),
+        )
+    if not sessions:
+        table.add_row("-", "-", "Belum ada session.", "0", "-")
+    table.caption = "/history current | /history show <session_id> | /history delete <session_id>"
+    return table
+
+
+def _format_session_events(session: dict[str, object], events: list[dict[str, object]], current: bool = False) -> Table:
+    marker = "current" if current else "saved"
+    table = Table(title=f"Session {session['id']} ({marker}) - {session['title']}", expand=True)
+    table.add_column("#", justify="right", width=4)
+    table.add_column("Time", style="dim", no_wrap=True)
+    table.add_column("Status", style="cyan", no_wrap=True)
+    table.add_column("Command", style="white")
+    table.add_column("Output Preview", style="dim")
+    for event in events:
+        table.add_row(
+            str(event["id"]),
+            str(event["created_at"]),
+            str(event["status"]),
+            str(event["command"]),
+            str(event["output_preview"] or "")[:180],
+        )
+    if not events:
+        table.add_row("-", "-", "-", "Belum ada command di session ini.", "")
+    table.caption = "/history sessions | /history save <title> | /history clear current"
+    return table
+
+
+def _render_history_preview(renderable: Any) -> str:
+    if renderable is None:
+        return ""
+    if isinstance(renderable, str):
+        return renderable[:1200]
+    console = Console(width=100, record=True, force_terminal=False, file=io.StringIO())
+    try:
+        console.print(renderable)
+        return console.export_text(clear=False).strip()[:1200]
+    except Exception:
+        return str(renderable)[:1200]
+
+
 def _format_dashboard(
     provider_chain: list[str],
     watchlist_rows: list[dict[str, object]],
@@ -1121,6 +1342,14 @@ def _format_provider_key_status(manager: MarketProviderManager) -> Table:
     return table
 
 
+def _market_provider_secret_keys(provider: str) -> tuple[str, ...]:
+    return {
+        "custom": ("MARKET_DATA_API_KEY", "MARKET_DATA_BASE_URL"),
+        "finnhub": ("FINNHUB_API_KEY",),
+        "twelvedata": ("TWELVE_DATA_API_KEY",),
+    }.get(provider.lower(), ())
+
+
 def _format_transactions(rows: list[dict[str, object]]) -> Table:
     table = Table(title="Transaction Ledger", expand=True)
     table.add_column("ID", justify="right")
@@ -1171,6 +1400,21 @@ def _format_news(symbol: str, items: list[NewsItem]) -> str:
     return "\n".join(lines)
 
 
+def _format_web_results(query: str, results: list[WebSearchResult]) -> Table:
+    table = Table(title=f"Web Research: {query}", expand=True)
+    table.add_column("#", justify="right", width=3)
+    table.add_column("Title", style="cyan", overflow="fold")
+    table.add_column("Snippet / Extract", overflow="fold")
+    table.add_column("URL", style="dim", overflow="fold")
+    for index, result in enumerate(results, start=1):
+        extract = result.content[:500] if result.content else result.snippet
+        table.add_row(str(index), result.title, extract or "-", result.url)
+    if not results:
+        table.add_row("-", "No results", "Search providers returned no public context.", "-")
+    table.caption = "Web context is public web data; verify source quality before using it for financial decisions."
+    return table
+
+
 def _format_fundamentals(snapshot: FundamentalSnapshot) -> str:
     return (
         f"Fundamental Snapshot: {snapshot.symbol}\n"
@@ -1230,12 +1474,8 @@ def _format_fundamental_context(snapshot: FundamentalSnapshot) -> str:
     )
 
 
-def _format_ai_response(response: AIResponse) -> str:
-    return (
-        f"Provider: {response.provider}\n"
-        f"Model: {response.model}\n"
-        f"Response:\n{response.content}"
-    )
+def _format_ai_response(response: AIResponse) -> AIResponseView:
+    return AIResponseView(response)
 
 
 def _fmt(value: float | None) -> str:
@@ -1253,5 +1493,5 @@ class UnavailableAIProvider:
     async def complete(self, request: AIRequest) -> AIResponse:
         raise CommandError(
             f"AI provider {self.name} belum siap dipakai.",
-            "Set API key di .env dan gunakan provider client Phase 2 lanjutan, atau injeksi provider untuk testing.",
+            "Gunakan /ai_model untuk memilih provider dan /ai_model key <provider> <api_key> untuk menyimpan API key.",
         )

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/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"))

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

@@ -1,11 +1,12 @@
-"""Gemini provider placeholder for Phase 2."""
+"""Gemini 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 GeminiProvider(BaseAIProvider):
-    name = "gemini"
+from fincli.app.providers.ai.http_provider import GeminiProviderHTTP
 
-    async def complete(self, request: AIRequest) -> AIResponse:
-        raise ProviderError("Gemini client belum diimplementasi di Phase 1.")
+
+class GeminiProvider(GeminiProviderHTTP):
+    def __init__(self, api_key: str | None = None) -> None:
+        super().__init__(api_key or os.getenv("GEMINI_API_KEY"))

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

@@ -1,11 +1,12 @@
-"""Groq provider placeholder for Phase 2."""
+"""Groq 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 GroqProvider(BaseAIProvider):
-    name = "groq"
+from fincli.app.providers.ai.http_provider import OpenAICompatibleProvider
 
-    async def complete(self, request: AIRequest) -> AIResponse:
-        raise ProviderError("Groq client belum diimplementasi di Phase 1.")
+
+class GroqProvider(OpenAICompatibleProvider):
+    def __init__(self, api_key: str | None = None) -> None:
+        super().__init__("groq", "https://api.groq.com/openai/v1", api_key or os.getenv("GROQ_API_KEY"))

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

@@ -27,7 +27,7 @@ class OpenAICompatibleProvider(BaseAIProvider):
         if not self.api_key:
             raise ProviderError(
                 f"API key untuk provider {self.name} belum diatur.",
-                "Isi API key di .env lalu jalankan ulang FinCLI.",
+                f"Gunakan /ai_model key {self.name} <api_key> atau set environment variable.",
             )
 
         payload = {
@@ -69,7 +69,7 @@ class GeminiProviderHTTP(BaseAIProvider):
 
     async def complete(self, request: AIRequest) -> AIResponse:
         if not self.api_key:
-            raise ProviderError("API key untuk provider gemini belum diatur.")
+            raise ProviderError("API key untuk provider gemini belum diatur.", "Gunakan /ai_model key gemini <api_key>.")
         url = f"{self.base_url}/models/{request.model}:generateContent?key={self.api_key}"
         payload = {"contents": [{"parts": [{"text": request.prompt}]}]}
         try:
@@ -100,7 +100,7 @@ class AnthropicProviderHTTP(BaseAIProvider):
 
     async def complete(self, request: AIRequest) -> AIResponse:
         if not self.api_key:
-            raise ProviderError("API key untuk provider anthropic belum diatur.")
+            raise ProviderError("API key untuk provider anthropic belum diatur.", "Gunakan /ai_model key anthropic <api_key>.")
         payload = {
             "model": request.model,
             "max_tokens": 1200,

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

@@ -1,11 +1,12 @@
-"""HuggingFace provider placeholder for Phase 2."""
+"""HuggingFace 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 HuggingFaceProvider(BaseAIProvider):
-    name = "huggingface"
+from fincli.app.providers.ai.http_provider import OpenAICompatibleProvider
 
-    async def complete(self, request: AIRequest) -> AIResponse:
-        raise ProviderError("HuggingFace client belum diimplementasi di Phase 1.")
+
+class HuggingFaceProvider(OpenAICompatibleProvider):
+    def __init__(self, api_key: str | None = None) -> None:
+        super().__init__("huggingface", "https://router.huggingface.co/v1", api_key or os.getenv("HUGGINGFACE_API_KEY"))

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

@@ -1,11 +1,12 @@
-"""OpenAI provider placeholder for Phase 2."""
+"""OpenAI 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 OpenAIProvider(BaseAIProvider):
-    name = "openai"
+from fincli.app.providers.ai.http_provider import OpenAICompatibleProvider
 
-    async def complete(self, request: AIRequest) -> AIResponse:
-        raise ProviderError("OpenAI client belum diimplementasi di Phase 1.")
+
+class OpenAIProvider(OpenAICompatibleProvider):
+    def __init__(self, api_key: str | None = None) -> None:
+        super().__init__("openai", "https://api.openai.com/v1", api_key or os.getenv("OPENAI_API_KEY"))