aipa-cli 0.1.0__py3-none-any.whl

aipriceaction_terminal/widgets/chat_input.py

@@ -0,0 +1,179 @@
+"""Chat input with slash command autocomplete and message history."""
+
+from __future__ import annotations
+
+from textual.containers import Vertical
+from textual.widgets import Input
+from textual_autocomplete import AutoComplete, DropdownItem
+
+
+_COMMANDS: list[tuple[str, str]] = [
+    ("/analyze <ticker> [interval]", "/analyze"),
+    ("/clear", "/clear"),
+    ("/deep-research [question]", "/deep-research"),
+    ("/exit", "/exit"),
+    ("/export <ticker> [ticker...] [--interval] [--path]", "/export"),
+    ("/help", "/help"),
+]
+
+# Keys that should trigger app-level actions (tab switch, help) even when
+# an Input is focused. Textual filters these from the binding chain, so we
+# handle them manually in the Input's on_key.
+_GLOBAL_KEYS = frozenset(("1", "2", "3", "4", "5", "6", "question_mark"))
+_TAB_MAP: dict[str, str] = {
+    "1": "chat",
+    "2": "tickers-vn",
+    "3": "tickers-crypto",
+    "4": "tickers-global",
+    "5": "workflows",
+    "6": "settings",
+}
+
+
+class _GlobalKeyInput(Input):
+    """Input that forwards global shortcut keys (1-6, ?) to the App.
+
+    Textual removes typeable-key bindings from the binding chain when an
+    Input is focused. This subclass overrides _on_key to intercept global
+    keys before Input processes them as typed characters.
+    """
+
+    async def _on_key(self, event) -> None:
+        if event.key in _GLOBAL_KEYS:
+            event.stop()
+            if event.key in _TAB_MAP:
+                self.app.action_switch_tab(_TAB_MAP[event.key])
+            elif event.key == "question_mark":
+                self.app.action_show_help()
+        else:
+            await super()._on_key(event)
+
+
+class _CommandAutoComplete(AutoComplete):
+    """AutoComplete that only activates for slash commands."""
+
+    DEFAULT_CSS = """
+    _CommandAutoComplete AutoCompleteList {
+        max-height: 10;
+    }
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(prevent_default_enter=True, **kwargs)
+
+    def should_show_dropdown(self, search_string: str) -> bool:
+        """Only show dropdown when input starts with /."""
+        return search_string.startswith("/") and self.option_list.option_count > 0
+
+    def _complete(self, option_index: int) -> None:
+        """Fill input with command name + trailing space."""
+        if not self.display or self.option_list.option_count == 0:
+            return
+        option_list = self.option_list
+        option = option_list.get_option_at_index(option_index)
+        completion_value = getattr(option, "id", None) or option.value
+        # Append trailing space so user can immediately type args
+        completion_value += " "
+        with self.prevent(Input.Changed):
+            self.apply_completion(completion_value, self._get_target_state())
+        self.post_completion()
+
+
+class ChatInput(Vertical):
+    """Chat input with slash command autocomplete and message history."""
+
+    DEFAULT_CSS = """
+    ChatInput {
+        height: auto;
+    }
+    ChatInput Input {
+        width: 1fr;
+    }
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._history: list[str] = []
+        self._history_index: int = -1
+
+    def compose(self):
+        yield _GlobalKeyInput(placeholder="Type a message or /analyze <ticker>...", id="chat-input-field")
+        yield _CommandAutoComplete(
+            target="#chat-input-field",
+            candidates=self._get_candidates,
+        )
+
+    # --- value property -------------------------------------------------------
+
+    @property
+    def value(self) -> str:
+        return self.query_one("#chat-input-field", Input).value
+
+    @value.setter
+    def value(self, val: str) -> None:
+        self.query_one("#chat-input-field", Input).value = val
+
+    # --- Candidate provider for AutoComplete -----------------------------------
+
+    def _get_candidates(self, state) -> list[DropdownItem]:
+        """Return matching slash commands based on input text."""
+        text = state.text.strip()
+        if not text.startswith("/"):
+            return []
+        # Extract the command word (before any space / args)
+        cmd_word = text.split()[0]
+        query = cmd_word[1:].lower()
+        # If the command is already a complete match, no need to suggest
+        for _, cmd in _COMMANDS:
+            if cmd[1:].lower() == query:
+                return []
+        matches = []
+        for label, cmd in _COMMANDS:
+            if query in cmd[1:].lower():
+                matches.append(DropdownItem(label, id=cmd))
+        return matches
+
+    # --- History management ---------------------------------------------------
+
+    def push_history(self, text: str) -> None:
+        """Add a submitted message to history (call from ChatTab on submit)."""
+        if text and (not self._history or self._history[-1] != text):
+            self._history.append(text)
+        self._history_index = -1
+
+    def _history_up(self) -> None:
+        if not self._history:
+            return
+        if self._history_index == -1:
+            self._draft = self.query_one("#chat-input-field", Input).value
+            self._history_index = len(self._history) - 1
+        elif self._history_index > 0:
+            self._history_index -= 1
+        else:
+            return
+        self.query_one("#chat-input-field", Input).value = self._history[self._history_index]
+
+    def _history_down(self) -> None:
+        if self._history_index == -1:
+            return
+        self._history_index += 1
+        if self._history_index >= len(self._history):
+            self._history_index = -1
+            self.query_one("#chat-input-field", Input).value = getattr(self, "_draft", "")
+        else:
+            self.query_one("#chat-input-field", Input).value = self._history[self._history_index]
+
+    def on_key(self, event) -> None:
+        """Arrow up/down for history (only when autocomplete dropdown is closed)."""
+        if self.app.focused != self.query_one("#chat-input-field", Input):
+            return
+        autocomplete = self.query_one(_CommandAutoComplete)
+        # Let autocomplete handle arrow keys when dropdown is visible
+        if autocomplete.display:
+            return
+        if event.key == "up":
+            self._history_up()
+            event.stop()
+        elif event.key == "down":
+            self._history_down()
+            event.stop()

aipriceaction_terminal/widgets/ticker_select.py

@@ -0,0 +1,168 @@
+"""Ticker autocomplete widget using textual-autocomplete."""
+
+from __future__ import annotations
+
+from textual.containers import Vertical
+from textual.widgets import Input
+from textual_autocomplete import AutoComplete, DropdownItem
+
+
+class _TickerAutoComplete(AutoComplete):
+    """AutoComplete that fills the input with the ticker symbol (option.id) on selection."""
+
+    DEFAULT_CSS = """
+    _TickerAutoComplete AutoCompleteList {
+        max-height: 20;
+    }
+    """
+
+    def _complete(self, option_index: int) -> None:
+        """Override to use option.id (ticker symbol) instead of option.value (label)."""
+        if not self.display or self.option_list.option_count == 0:
+            return
+        option_list = self.option_list
+        option = option_list.get_option_at_index(option_index)
+        # Use option.id (the ticker symbol) if available, fall back to option.value (label)
+        completion_value = getattr(option, "id", None) or option.value
+        with self.prevent(Input.Changed):
+            self.apply_completion(completion_value, self._get_target_state())
+        self.post_completion()
+
+    def should_show_dropdown(self, search_string: str) -> bool:
+        """Show dropdown even when search string is empty (show all on focus)."""
+        return self.option_list.option_count > 0
+
+    def get_matches(
+        self,
+        target_state,
+        candidates: list[DropdownItem],
+        search_string: str,
+    ) -> list[DropdownItem]:
+        """Override to boost ticker symbol matches above company name matches.
+
+        The default fuzzy matcher only sees the label (e.g. '[VN] VIC - Tập đoàn
+        VINGROUP') and can rank VICEM companies above the actual VIC ticker.
+        We add a score boost when the query matches the ticker symbol (option.id).
+        """
+        if not search_string:
+            return list(candidates)
+
+        query_lower = search_string.lower()
+        boosted: list[tuple[DropdownItem, float]] = []
+        match = self._fuzzy_search.match
+
+        for candidate in candidates:
+            label_score, offsets = match(query_lower, candidate.value)
+            # Check if query matches the ticker symbol (option.id)
+            ticker_id = getattr(candidate, "id", None) or ""
+            id_match = query_lower in ticker_id.lower() if ticker_id else False
+
+            if id_match and label_score > 0:
+                # Ticker symbol match + label match → highest priority
+                final_score = 2.0 + label_score
+            elif id_match:
+                # Ticker symbol matches but label doesn't (e.g. short ticker)
+                final_score = 1.5
+            elif label_score > 0:
+                final_score = label_score
+            else:
+                continue
+
+            highlighted = self.apply_highlights(candidate.main, offsets)
+            item = type(candidate)(
+                main=highlighted,
+                prefix=candidate.prefix,
+                id=candidate.id,
+                disabled=candidate.disabled,
+            )
+            boosted.append((item, final_score))
+
+        boosted.sort(key=lambda x: x[1], reverse=True)
+        return [item for item, _ in boosted]
+
+
+class TickerSelect(Vertical):
+    """Autocomplete ticker input with filtered dropdown."""
+
+    DEFAULT_CSS = """
+    TickerSelect {
+        width: 1fr;
+        height: auto;
+    }
+    TickerSelect Input {
+        width: 1fr;
+    }
+    """
+
+    def __init__(self, value: str = "VNINDEX", **kwargs):
+        super().__init__(**kwargs)
+        self._desired_value = value
+        self._all_options: list[tuple[str, str]] = [(value, value)]
+
+    def compose(self):
+        yield Input(value=self._desired_value, id="ticker-input")
+        yield _TickerAutoComplete(
+            target="#ticker-input",
+            candidates=self._get_candidates,
+            id="ticker-autocomplete",
+        )
+
+    def on_mount(self) -> None:
+        self.watch(self.app, "ticker_options", self._on_ticker_options, init=False)
+
+    _GLOBAL_KEYS = frozenset(("1", "2", "3", "4", "5", "6", "question_mark"))
+    _TAB_MAP: dict[str, str] = {
+        "1": "chat",
+        "2": "tickers-vn",
+        "3": "tickers-crypto",
+        "4": "tickers-global",
+        "5": "workflows",
+        "6": "settings",
+    }
+
+    def on_key(self, event) -> None:
+        """Intercept global shortcut keys when ticker Input is focused.
+
+        Textual filters typeable-key bindings when an Input is focused,
+        so we handle tab-switch and help keys manually.
+        """
+        if self.app.focused != self.query_one("#ticker-input", Input):
+            return
+        autocomplete = self.query_one(_TickerAutoComplete)
+        if autocomplete.display:
+            return
+        if event.key in self._GLOBAL_KEYS:
+            input_widget = self.query_one("#ticker-input", Input)
+            if input_widget.value:
+                input_widget.value = input_widget.value[:-1]
+            if event.key in self._TAB_MAP:
+                self.app.action_switch_tab(self._TAB_MAP[event.key])
+            elif event.key == "question_mark":
+                self.app.action_show_help()
+            event.stop()
+
+    # --- value property -------------------------------------------------------
+
+    @property
+    def value(self) -> str:
+        return self.query_one("#ticker-input", Input).value.strip()
+
+    @value.setter
+    def value(self, val: str) -> None:
+        self.query_one("#ticker-input", Input).value = val
+
+    # --- Options loading ------------------------------------------------------
+
+    def _on_ticker_options(self, old_value, new_value: list[tuple[str, str]]) -> None:
+        """React when the app loads ticker options."""
+        self._all_options = new_value
+        if self._desired_value and any(v == self._desired_value for _, v in new_value):
+            self.value = self._desired_value
+        else:
+            self.value = new_value[0][1] if new_value else ""
+
+    # --- Candidate provider for AutoComplete -----------------------------------
+
+    def _get_candidates(self, state) -> list[DropdownItem]:
+        """Return all options; the library's fuzzy matcher handles filtering."""
+        return [DropdownItem(label, id=val) for label, val in self._all_options]

aipriceaction_terminal/workflows.py

@@ -0,0 +1,172 @@
+"""Workflows tab: nested tabs for different workflow types."""
+
+import asyncio
+
+from textual import work
+from textual.containers import Vertical, Horizontal
+from textual.widgets import (
+    Static, RichLog, Input, Button, Select, TabbedContent, TabPane,
+)
+
+from .utils import write_context_result, write_error
+from .widgets import TickerSelect
+
+
+class AnalyzePane(Vertical):
+    """Single-ticker context analysis workflow."""
+
+    DEFAULT_CSS = """
+    AnalyzePane {
+        padding: 1 2;
+    }
+    .wf-row {
+        height: auto;
+        margin-bottom: 1;
+    }
+    #wf-output {
+        height: 1fr;
+        border: solid $accent;
+        padding: 1;
+    }
+    .wf-label {
+        width: 10;
+        height: auto;
+    }
+    """
+
+
+    def compose(self):
+        with Horizontal(classes="wf-row"):
+            yield Static("Ticker:", classes="wf-label")
+            yield TickerSelect(value="VNINDEX", id="wf-ticker")
+            yield Static("Interval:", classes="wf-label")
+            yield Select(
+                [("1m", "1m"), ("1h", "1h"), ("1D", "1D")],
+                value="1D",
+                allow_blank=False,
+                id="wf-interval",
+            )
+        with Horizontal(classes="wf-row"):
+            yield Button("Analyze", id="wf-analyze-btn", variant="primary")
+        yield RichLog(id="wf-output", highlight=True, markup=True)
+
+    def on_mount(self) -> None:
+        self.query_one("#wf-interval", Select).value = self.app.interval
+        self.query_one("#wf-output", RichLog).write(
+            "[dim italic]Select a ticker and click Analyze to build AI context.[/dim italic]\n"
+        )
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id != "wf-analyze-btn":
+            return
+        self._do_analyze()
+
+    def _do_analyze(self) -> None:
+        ticker = self.query_one("#wf-ticker", TickerSelect).value
+        interval = self.query_one("#wf-interval", Select).value
+        log = self.query_one("#wf-output", RichLog)
+        log.write(f"[bold cyan]Analyze:[/bold cyan] {ticker} ({interval})")
+        log.write("[dim]Building context...[/dim]")
+        self._run_analyze(ticker, interval)
+
+    @work(exclusive=True)
+    async def _run_analyze(self, ticker: str, interval: str) -> None:
+        try:
+            builder = self.app.builder
+            context = await asyncio.to_thread(
+                builder.build, ticker=ticker, interval=interval
+            )
+            log = self.query_one("#wf-output", RichLog)
+            write_context_result(log, ticker, interval, context)
+        except Exception as e:
+            log = self.query_one("#wf-output", RichLog)
+            write_error(log, e)
+
+
+class DeepResearchPane(Vertical):
+    """Multi-agent deep research workflow."""
+
+    DEFAULT_CSS = """
+    DeepResearchPane {
+        padding: 1 2;
+    }
+    .dr-row {
+        height: auto;
+        margin-bottom: 1;
+    }
+    .dr-label {
+        width: 10;
+        height: auto;
+    }
+    #dr-question {
+        width: 1fr;
+    }
+    #dr-output {
+        height: 1fr;
+        border: solid $accent;
+        padding: 1;
+    }
+    #dr-btn {
+        margin-left: 1;
+    }
+    """
+
+    def compose(self):
+        with Horizontal(classes="dr-row"):
+            yield Static("Question:", classes="dr-label")
+            yield Input(
+                value="",
+                placeholder="Enter research question...",
+                id="dr-question",
+            )
+            yield Button("Deep Research", id="dr-btn", variant="success")
+        yield RichLog(id="dr-output", highlight=True, markup=True)
+
+    def on_mount(self) -> None:
+        self.query_one("#dr-output", RichLog).write(
+            "[bold yellow]Deep research is not yet implemented.[/bold yellow]\n\n"
+            "[dim]This will run the multi-agent LangGraph pipeline:\n"
+            "  supervisor -> parallel workers -> aggregator -> reviewer\n\n"
+            "Enter a question and click Deep Research when ready.[/dim]\n"
+        )
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id != "dr-btn":
+            return
+        self._do_deep_research()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        if event.input.id == "dr-question":
+            self._do_deep_research()
+
+    def _do_deep_research(self) -> None:
+        question = self.query_one("#dr-question", Input).value.strip()
+        log = self.query_one("#dr-output", RichLog)
+        log.write(
+            f"[bold cyan]Deep Research:[/bold cyan]"
+            + (f" {question}" if question else "")
+        )
+        log.write(
+            "[bold yellow]Not yet implemented.[/bold yellow]\n"
+            "[dim]Will trigger multi_agent.main() in a future update.[/dim]\n"
+        )
+
+
+class WorkflowsTab(Vertical):
+    """Workflows container with nested tabs for each workflow type."""
+
+    DEFAULT_CSS = """
+    WorkflowsTab {
+        height: 100%;
+    }
+    WorkflowsTab TabbedContent {
+        height: 1fr;
+    }
+    """
+
+    def compose(self):
+        with TabbedContent(initial="wf-analyze"):
+            with TabPane("Analyze", id="wf-analyze"):
+                yield AnalyzePane()
+            with TabPane("Deep Research", id="wf-deep-research"):
+                yield DeepResearchPane()