@drico2008/fincli 0.1.0

package/fincli/app/tui/layout.py

@@ -0,0 +1,261 @@
+"""Textual layout for FinCLI."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from threading import Lock
+
+from textual.app import App, ComposeResult, SystemCommand
+from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.screen import Screen
+from textual.worker import Worker, WorkerState
+from textual.widgets import Header, Input, RichLog, Static
+
+from fincli import __version__
+from fincli.app.cli.autocomplete import SlashAutocomplete
+from fincli.app.cli.commands import CommandRegistry
+from fincli.app.cli.router import CommandResult, CommandRouter
+from fincli.app.providers.ai.manager import AIProviderManager
+from fincli.app.tui.components import CommandPalette, format_ai_message, format_thinking_message, format_user_message
+from fincli.app.tui.market_provider_selector import MarketProviderSelectorScreen
+from fincli.app.tui.model_selector import AIModelSelectorScreen
+from fincli.app.tui.theme import APP_CSS
+
+
+class FinCLIApp(App[None]):
+    """Modern terminal dashboard for FinCLI v0.1."""
+
+    CSS = APP_CSS
+    TITLE = f"FinCLI v{__version__}"
+    SUB_TITLE = "Financial terminal MVP"
+    BINDINGS = [
+        ("ctrl+c", "quit", "Quit"),
+        ("ctrl+l", "clear_output", "Clear"),
+        ("f1", "help", "Help"),
+    ]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.registry = CommandRegistry()
+        self.autocomplete = SlashAutocomplete(self.registry)
+        self.router = CommandRouter(registry=self.registry)
+        self._route_lock = Lock()
+        self._worker_index = 0
+        self._latest_worker_sequence = 0
+        self._worker_meta: dict[str, dict[str, str | bool]] = {}
+
+    def compose(self) -> ComposeResult:
+        yield Header(show_clock=True)
+        with Vertical(id="workspace"):
+            with Vertical(id="main"):
+                yield RichLog(id="output", wrap=True, markup=True, highlight=True)
+        yield Static("ready | /dashboard | /market AAPL | /provider status", id="status_bar")
+        with Vertical(id="command_area"):
+            with Horizontal(id="command_line"):
+                yield Static("> ", id="command_prompt")
+                yield Input(placeholder="/", id="command_input")
+            with VerticalScroll(id="command_palette_scroll"):
+                yield CommandPalette(id="command_palette")
+
+    def on_mount(self) -> None:
+        palette = self.query_one(CommandPalette)
+        palette.clear_palette()
+        self.query_one("#command_palette_scroll", VerticalScroll).styles.display = "none"
+        output = self.query_one("#output", RichLog)
+        output.write("Loading dashboard...")
+        self._submit_route("/dashboard", display_raw="/dashboard", clear_output_before_result=True)
+        self.query_one("#command_input", Input).focus()
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        palette = self.query_one(CommandPalette)
+        palette_scroll = self.query_one("#command_palette_scroll", VerticalScroll)
+        value = event.value.strip()
+        if not value.startswith("/"):
+            palette.clear_palette()
+            palette_scroll.styles.display = "none"
+            return
+
+        suggestions = self.autocomplete.suggestions_for(value)
+        palette_scroll.styles.display = "block"
+        palette_scroll.scroll_home(animate=False)
+        palette.render_commands(suggestions, value)
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        event.input.value = ""
+        palette = self.query_one(CommandPalette)
+        palette.clear_palette()
+        self.query_one("#command_palette_scroll", VerticalScroll).styles.display = "none"
+        raw = event.value.strip()
+        output = self.query_one("#output", RichLog)
+        status = self.query_one("#status_bar", Static)
+        if raw.lower() == "/ai_model":
+            self.push_screen(AIModelSelectorScreen(self.router.config, self._set_ai_model_from_selector))
+            status.update("selecting ai model | esc to close")
+            return
+        if raw.lower() == "/news_model":
+            self.push_screen(MarketProviderSelectorScreen(self.router.config, self._set_market_provider_from_selector))
+            status.update("selecting market/news provider | esc to close")
+            return
+
+        if raw and (not raw.startswith("/") or raw.lower().startswith("/ai ")):
+            prompt = raw[4:].strip() if raw.lower().startswith("/ai ") else raw
+            self._handle_ai_chat(prompt)
+            return
+
+        if raw.lower() == "/clear":
+            self._invalidate_pending_workers()
+            output.clear()
+            status.update("cleared | /help untuk command")
+            return
+        if raw.lower() == "/exit":
+            self.exit()
+            return
+
+        self._submit_route(raw, display_raw=raw)
+
+    def action_clear_output(self) -> None:
+        self._invalidate_pending_workers()
+        self.query_one("#output", RichLog).clear()
+        self.query_one("#status_bar", Static).update("cleared | /help untuk command")
+
+    def action_help(self) -> None:
+        output = self.query_one("#output", RichLog)
+        output.write(self.router.route("/help").renderable)
+
+    def get_system_commands(self, screen: Screen) -> Iterable[SystemCommand]:
+        """Return a curated command palette for FinCLI."""
+        yield SystemCommand(
+            "Keys",
+            "Show or hide FinCLI keyboard shortcuts.",
+            self._toggle_help_panel,
+        )
+        yield SystemCommand(
+            "Maximize Panel",
+            "Maximize the active FinCLI panel.",
+            screen.action_maximize,
+        )
+        yield SystemCommand(
+            "Save Screenshot",
+            "Save the current FinCLI screen as an SVG file.",
+            lambda: self.set_timer(0.1, self.deliver_screenshot),
+        )
+        yield SystemCommand(
+            "Change Theme",
+            "Open Textual theme selector for the terminal UI.",
+            self.action_change_theme,
+        )
+        yield SystemCommand(
+            "Clear Output",
+            "Clear the main output log.",
+            self.action_clear_output,
+        )
+        yield SystemCommand(
+            "Quit FinCLI",
+            "Exit FinCLI and return to the terminal.",
+            self.action_quit,
+        )
+
+    def _toggle_help_panel(self) -> None:
+        if self.screen.query("HelpPanel"):
+            self.action_hide_help_panel()
+        else:
+            self.action_show_help_panel()
+
+    def _set_ai_model_from_selector(self, provider: str, model: str) -> None:
+        self.router.ai_provider = AIProviderManager().create(provider)
+        output = self.query_one("#output", RichLog)
+        status = self.query_one("#status_bar", Static)
+        output.write(f"AI model aktif: {provider} / {model}")
+        status.update(f"ready | ai model: {provider}/{model}")
+
+    def _set_market_provider_from_selector(self, providers: tuple[str, ...]) -> None:
+        self.router._refresh_market_service()
+        self.router.cache.clear()
+        output = self.query_one("#output", RichLog)
+        status = self.query_one("#status_bar", Static)
+        output.write(f"Provider market/news priority aktif: {', '.join(providers)}")
+        status.update(f"ready | market provider: {providers[0] if providers else 'yfinance'}")
+
+    def _handle_ai_chat(self, prompt: str) -> None:
+        output = self.query_one("#output", RichLog)
+        status = self.query_one("#status_bar", Static)
+        output.write(format_user_message(prompt))
+        output.write(format_thinking_message("routing prompt to active AI provider..."))
+        self._submit_route(f"/ai {prompt}", display_raw="/ai", chat=True)
+
+    def _submit_route(
+        self,
+        raw: str,
+        *,
+        display_raw: str,
+        chat: bool = False,
+        clear_output_before_result: bool = False,
+    ) -> None:
+        """Run a router command without blocking Textual's UI thread."""
+        self._worker_index += 1
+        worker_name = f"route-{self._worker_index}"
+        self._latest_worker_sequence = self._worker_index
+        self._worker_meta[worker_name] = {
+            "raw": raw,
+            "display_raw": display_raw,
+            "chat": chat,
+            "clear_output_before_result": clear_output_before_result,
+            "sequence": str(self._worker_index),
+        }
+        self.query_one("#status_bar", Static).update(f"running | {display_raw}")
+        self.run_worker(
+            lambda: self._route_in_worker(raw),
+            name=worker_name,
+            group="router",
+            description=display_raw,
+            thread=True,
+        )
+
+    def _invalidate_pending_workers(self) -> None:
+        self._latest_worker_sequence = max(self._latest_worker_sequence, self._worker_index) + 1
+
+    def _route_in_worker(self, raw: str) -> CommandResult:
+        with self._route_lock:
+            return self.router.route(raw)
+
+    def on_worker_state_changed(self, event: Worker.StateChanged) -> None:
+        worker = event.worker
+        meta = self._worker_meta.get(worker.name or "")
+        if meta is None:
+            return
+        if event.state not in {WorkerState.SUCCESS, WorkerState.ERROR, WorkerState.CANCELLED}:
+            return
+
+        self._worker_meta.pop(worker.name or "", None)
+        sequence = int(str(meta.get("sequence", "0")))
+        if sequence < self._latest_worker_sequence:
+            return
+        output = self.query_one("#output", RichLog)
+        status = self.query_one("#status_bar", Static)
+        display_raw = str(meta["display_raw"])
+
+        if event.state == WorkerState.CANCELLED:
+            status.update(f"cancelled | {display_raw}")
+            return
+        if event.state == WorkerState.ERROR:
+            output.write(f"Error menjalankan {display_raw}: {worker.error}")
+            status.update(f"error | {display_raw}")
+            return
+
+        result = worker.result
+        if bool(meta.get("clear_output_before_result")):
+            output.clear()
+        if result.clear:
+            output.clear()
+        elif result.renderable:
+            if bool(meta.get("chat")) and result.status == "ready":
+                output.write(format_ai_message(str(result.renderable)))
+            else:
+                output.write(result.renderable)
+
+        if bool(meta.get("chat")):
+            status.update(f"{result.status} | ai chat")
+        else:
+            status.update(f"{result.status} | last: {display_raw or 'empty'}")
+        if result.should_exit:
+            self.exit()

package/fincli/app/tui/market_provider_selector.py

@@ -0,0 +1,267 @@
+"""Interactive market/news provider selector screen."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import os
+from typing import Callable
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.containers import Vertical, VerticalScroll
+from textual.events import Key
+from textual.screen import ModalScreen
+from textual.widgets import Input, Static
+
+from fincli.app.providers.market.manager import MarketProviderManager
+from fincli.app.storage.config import ConfigManager
+from fincli.app.utils.formatting import mask_secret
+
+
+@dataclass(frozen=True, slots=True)
+class MarketProviderChoice:
+    provider: str
+    label: str
+    env_keys: tuple[str, ...]
+    description: str
+
+
+@dataclass(frozen=True, slots=True)
+class PriorityChoice:
+    label: str
+    providers: tuple[str, ...]
+    description: str
+
+
+PROVIDER_LABELS = {
+    "yfinance": "Yahoo Finance",
+    "custom": "Custom API",
+    "finnhub": "Finnhub",
+    "twelvedata": "Twelve Data",
+}
+PROVIDER_ENV_KEYS = {
+    "yfinance": (),
+    "custom": ("MARKET_DATA_API_KEY", "MARKET_DATA_BASE_URL"),
+    "finnhub": ("FINNHUB_API_KEY",),
+    "twelvedata": ("TWELVE_DATA_API_KEY",),
+}
+DEFAULT_FALLBACK_ORDER = ("twelvedata", "finnhub", "custom", "yfinance")
+
+
+def market_provider_choices() -> tuple[MarketProviderChoice, ...]:
+    """Return selector choices from the market provider catalog."""
+    choices: list[MarketProviderChoice] = []
+    for info in MarketProviderManager().list_providers():
+        choices.append(
+            MarketProviderChoice(
+                provider=info.name,
+                label=PROVIDER_LABELS.get(info.name, info.name.title()),
+                env_keys=PROVIDER_ENV_KEYS.get(info.name, ()),
+                description=f"{info.status}; realtime={info.realtime}; {info.notes}",
+            )
+        )
+    return tuple(choices)
+
+
+def recommended_provider_priority(primary: str) -> tuple[str, ...]:
+    """Build a conservative fallback chain with yfinance as final fallback."""
+    normalized = primary.lower().strip()
+    if normalized == "yfinance":
+        return ("yfinance",)
+    priority = [normalized] if normalized else ["yfinance"]
+    for provider in DEFAULT_FALLBACK_ORDER:
+        if provider != "yfinance" and provider not in priority:
+            priority.append(provider)
+    if "yfinance" not in priority:
+        priority.append("yfinance")
+    return tuple(priority)
+
+
+def priority_presets(primary: str) -> tuple[PriorityChoice, ...]:
+    """Return selectable fallback presets for a primary provider."""
+    recommended = recommended_provider_priority(primary)
+    minimal = tuple(dict.fromkeys((primary.lower(), "yfinance")))
+    all_data_first = tuple(provider for provider in DEFAULT_FALLBACK_ORDER if provider in recommended)
+    return (
+        PriorityChoice("Recommended fallback", recommended, "Primary provider first, then other providers, yfinance last."),
+        PriorityChoice("Primary + yfinance", minimal, "Use selected provider and delayed yfinance fallback only."),
+        PriorityChoice("Data API priority", all_data_first, "Try realtime-capable providers before yfinance."),
+        PriorityChoice("YFinance only", ("yfinance",), "Delayed fallback only, no API key required."),
+    )
+
+
+class MarketProviderSelectorScreen(ModalScreen[tuple[str, ...] | None]):
+    """Modal selector for market/news provider and fallback priority."""
+
+    BINDINGS = [
+        ("escape", "cancel", "Cancel"),
+        ("tab", "change_provider", "Provider"),
+        ("up", "cursor_up", "Up"),
+        ("down", "cursor_down", "Down"),
+        ("enter", "select", "Select"),
+    ]
+
+    def __init__(self, config: ConfigManager, on_selected: Callable[[tuple[str, ...]], None]) -> None:
+        super().__init__()
+        self.config = config
+        self.on_selected = on_selected
+        self.mode = "provider"
+        self.selected_index = 0
+        self.selected_provider = config.settings.market_provider
+        self.search = ""
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="ai_selector_card"):
+            yield Static(id="ai_selector_title")
+            yield Static(id="ai_selector_provider")
+            yield Input(placeholder="Search providers...", id="ai_selector_search")
+            with VerticalScroll(id="ai_selector_scroll"):
+                yield Static(id="ai_selector_list")
+            yield Static(id="ai_selector_help")
+
+    def on_mount(self) -> None:
+        self._sync_search_placeholder()
+        self._render_selector()
+        self.query_one("#ai_selector_search", Input).focus()
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        self.search = event.value.strip().lower()
+        self.selected_index = 0
+        self._render_selector()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        event.stop()
+        self.action_select()
+
+    def on_key(self, event: Key) -> None:
+        if event.key == "up":
+            event.stop()
+            self.action_cursor_up()
+        elif event.key == "down":
+            event.stop()
+            self.action_cursor_down()
+        elif event.key == "tab":
+            event.stop()
+            self.action_change_provider()
+        elif event.key == "escape":
+            event.stop()
+            self.action_cancel()
+
+    def action_cursor_up(self) -> None:
+        total = len(self._visible_items())
+        if total:
+            self.selected_index = (self.selected_index - 1) % total
+            self._render_selector()
+
+    def action_cursor_down(self) -> None:
+        total = len(self._visible_items())
+        if total:
+            self.selected_index = (self.selected_index + 1) % total
+            self._render_selector()
+
+    def action_change_provider(self) -> None:
+        self._set_mode("provider")
+
+    def action_select(self) -> None:
+        items = self._visible_items()
+        if not items:
+            return
+        selected = items[self.selected_index]
+        if self.mode == "provider":
+            provider = selected.provider  # type: ignore[attr-defined]
+            self.selected_provider = provider
+            self._set_mode("priority")
+            return
+
+        providers = selected.providers  # type: ignore[attr-defined]
+        self.config.set_market_provider_priority(list(providers))
+        self.on_selected(providers)
+        self.dismiss(providers)
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+    def _set_mode(self, mode: str) -> None:
+        self.mode = mode
+        self.selected_index = 0
+        self.search = ""
+        self.query_one("#ai_selector_search", Input).value = ""
+        self._sync_search_placeholder()
+        self._render_selector()
+
+    def _sync_search_placeholder(self) -> None:
+        search = self.query_one("#ai_selector_search", Input)
+        search.placeholder = "Search fallback presets..." if self.mode == "priority" else "Search providers..."
+
+    def _visible_items(self) -> list[MarketProviderChoice] | list[PriorityChoice]:
+        if self.mode == "priority":
+            presets = list(priority_presets(self.selected_provider))
+            if self.search:
+                presets = [
+                    preset
+                    for preset in presets
+                    if self.search in preset.label.lower() or self.search in ",".join(preset.providers)
+                ]
+            return presets
+
+        choices = list(market_provider_choices())
+        if self.search:
+            choices = [
+                choice
+                for choice in choices
+                if self.search in choice.label.lower() or self.search in choice.provider or self.search in choice.description.lower()
+            ]
+        return choices
+
+    def _render_selector(self) -> None:
+        title = self.query_one("#ai_selector_title", Static)
+        provider = self.query_one("#ai_selector_provider", Static)
+        body = self.query_one("#ai_selector_list", Static)
+        help_text = self.query_one("#ai_selector_help", Static)
+
+        if self.mode == "priority":
+            title.update("Select Provider Priority")
+            provider.update(f"[cyan]Primary:[/] {self.selected_provider} [dim](tab to change provider)[/]")
+        else:
+            title.update("Select Market/News Provider")
+            provider.update("")
+
+        body.update(self._items_text(self._visible_items()))
+        help_text.update(self._help_text())
+
+    def _items_text(self, items: list[MarketProviderChoice] | list[PriorityChoice]) -> Text:
+        text = Text()
+        text.append("Providers\n" if self.mode == "provider" else "Fallback presets\n", style="bold dim")
+        for index, item in enumerate(items):
+            selected = index == self.selected_index
+            prefix = "> " if selected else "  "
+            style = "black on cyan" if selected else "white"
+            if isinstance(item, MarketProviderChoice):
+                current = " * (current)" if item.provider == self.config.settings.market_provider else ""
+                key_status = _provider_key_status(item)
+                line = f"{prefix}{item.label}{current} {key_status}\n"
+                detail = f"    {item.description}\n"
+            else:
+                chain = " -> ".join(item.providers)
+                line = f"{prefix}{item.label}: {chain}\n"
+                detail = f"    {item.description}\n"
+            text.append(line, style=style)
+            text.append(detail, style="dim" if not selected else "black on cyan")
+        if not items:
+            text.append("No matches.\n", style="dim")
+        return text
+
+    def _help_text(self) -> str:
+        if self.mode == "priority":
+            return "Type to search, up/down navigate, Enter to save priority, Tab to change provider, Esc to close"
+        return "Type to search, up/down navigate, Enter to select provider, Esc to close"
+
+
+def _provider_key_status(choice: MarketProviderChoice) -> str:
+    if not choice.env_keys:
+        return "(no key required)"
+    statuses = []
+    for key in choice.env_keys:
+        masked = mask_secret(os.getenv(key))
+        statuses.append(f"{key}={masked}")
+    return f"({', '.join(statuses)})"