aipa-cli 0.1.0__py3-none-any.whl

aipriceaction_terminal/chat.py

@@ -0,0 +1,345 @@
+"""Chat tab: message history + input + slash commands."""
+
+import asyncio
+from datetime import datetime
+from pathlib import Path
+
+from textual import work
+from textual.widgets import RichLog, Input, Static
+from textual.containers import Vertical, VerticalScroll
+from textual.screen import Screen
+
+from .widgets import ChatInput
+from .utils import write_context_result, write_error, write_export_result
+
+
+class ThinkingModal(Screen[None]):
+    """Modal overlay showing full thinking text."""
+
+    BINDINGS = [("ctrl+o", "close")]
+
+    DEFAULT_CSS = """
+    ThinkingModal {
+        align: center middle;
+    }
+
+    #thinking-dialog {
+        width: 90%;
+        height: 80%;
+        max-width: 160;
+        border: thick $accent;
+        background: $surface;
+        padding: 0;
+    }
+
+    #thinking-title {
+        height: 3;
+        width: 100%;
+        content-align: center middle;
+        color: $text;
+        text-style: bold;
+        border-bottom: solid $accent;
+        padding: 0 1;
+    }
+
+    #thinking-scroll {
+        width: 100%;
+        height: 1fr;
+        padding: 1;
+        color: $text-muted;
+    }
+    """
+
+    def __init__(self, history: list[tuple[str, str]]) -> None:
+        super().__init__()
+        self._history = history
+
+    def compose(self):
+        count = len(self._history)
+        with Vertical(id="thinking-dialog"):
+            yield Static(
+                f"Thinking ({count} {'entry' if count == 1 else 'entries'}) (Esc / Ctrl+O to close)",
+                id="thinking-title",
+            )
+            with VerticalScroll(id="thinking-scroll"):
+                for i, (ts, text) in enumerate(self._history):
+                    if i > 0:
+                        yield Static("─" * 60, classes="thinking-separator")
+                    yield Static(f"[bold]{ts}[/bold]", classes="thinking-ts")
+                    yield Static(text, classes="thinking-text")
+
+    def on_mount(self) -> None:
+        scroll = self.query_one("#thinking-scroll", VerticalScroll)
+        scroll.can_focus = True
+        scroll.focus()
+
+    def action_close(self) -> None:
+        self.app.pop_screen()
+
+
+class ChatTab(Vertical):
+    """Chat interface for AI ticker analysis."""
+
+    BINDINGS = [("ctrl+o", "show_thinking", "Thinking")]
+
+    DEFAULT_CSS = """
+    ChatTab {
+        height: 100%;
+    }
+    #chat-log {
+        height: 1fr;
+        border: solid $accent;
+        padding: 1;
+        overflow-x: hidden;
+    }
+    #thinking-area {
+        height: 3;
+        border: solid $accent;
+        padding: 0 1;
+        overflow-y: hidden;
+        color: $text-muted;
+        text-style: italic;
+    }
+    #thinking-area.hidden {
+        display: none;
+    }
+    #chat-input {
+        height: 3;
+    }
+    """
+
+    def compose(self):
+        yield RichLog(id="chat-log", highlight=True, markup=True, wrap=True, min_width=1)
+        yield Static(id="thinking-area", classes="hidden")
+        yield ChatInput(id="chat-input")
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._thinking_history: list[tuple[str, str]] = []
+
+    def on_mount(self) -> None:
+        log = self.query_one("#chat-log", RichLog)
+        log.can_focus = False
+        log.write(
+            "[bold cyan]AIPriceAction Terminal[/bold cyan]\n"
+            "Type [bold]/help[/bold] for available commands.\n"
+        )
+
+    def _show_thinking_area(self, text: str) -> None:
+        """Show the thinking area with truncated text."""
+        area = self.query_one("#thinking-area", Static)
+        area.remove_class("hidden")
+        truncated = text[-200:] if len(text) > 200 else text
+        area.update(truncated)
+
+    def _hide_thinking_area(self) -> None:
+        """Hide the thinking area and clear its content."""
+        area = self.query_one("#thinking-area", Static)
+        area.add_class("hidden")
+        area.update("")
+
+    def _store_thinking(self, text: str) -> None:
+        """Store complete thinking text with timestamp for later viewing with Ctrl+O."""
+        ts = datetime.now().strftime("%H:%M:%S")
+        self._thinking_history.append((ts, text))
+
+    def action_show_thinking(self) -> None:
+        """Push a modal with full thinking history, or pop if already showing."""
+        if isinstance(self.app.screen_stack[-1], ThinkingModal):
+            self.app.pop_screen()
+            return
+        if self._thinking_history:
+            self.app.push_screen(ThinkingModal(self._thinking_history))
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        text = event.value.strip()
+        if not text:
+            return
+        event.input.value = ""
+
+        # Save to history via ChatInput
+        chat_input = self.query_one("#chat-input", ChatInput)
+        chat_input.push_history(text)
+
+        log = self.query_one("#chat-log", RichLog)
+
+        if text.startswith("/"):
+            self._handle_slash_command(text)
+        else:
+            log.write(f"[bold cyan]You:[/bold cyan] {text}")
+            self._run_agent_chat(text)
+
+    def _handle_slash_command(self, text: str) -> None:
+        parts = text.split(maxsplit=2)
+        cmd = parts[0].lower()
+        arg = parts[1] if len(parts) > 1 else None
+
+        log = self.query_one("#chat-log", RichLog)
+
+        if cmd == "/help":
+            log.write(
+                "[bold yellow]Available commands:[/bold yellow]\n"
+                "  /analyze <ticker> [interval] - Build AI context (e.g. /analyze VIC or /analyze STB 1h)\n"
+                "  /export <ticker> [tickers...] [--interval 1D] [--path ~/dir/]\n"
+                "                        - Export AI context to markdown file\n"
+                "  /deep-research [q]   - Multi-agent deep research (not yet implemented)\n"
+                "  /exit                - Quit the application\n"
+                "  /help                - Show this help message\n"
+                "  /clear               - Clear chat history\n"
+            )
+        elif cmd == "/clear":
+            log.clear()
+            self.app.agent.clear_history()
+        elif cmd == "/exit":
+            self.app.exit()
+        elif cmd == "/analyze":
+            if not arg:
+                log.write("[bold red]Usage: /analyze <ticker> [interval][/bold red] (e.g. /analyze VIC or /analyze STB 1h)")
+                return
+            interval = parts[2] if len(parts) > 2 else self.app.interval
+            ticker = arg
+            log.write(f"[bold cyan]You:[/bold cyan] /analyze {ticker} {interval}")
+            log.write("[dim]Building context...[/dim]")
+            self._run_analyze(ticker, interval)
+        elif cmd == "/deep-research":
+            question = " ".join(parts[1:]) if len(parts) > 1 else ""
+            log.write("[bold cyan]You:[/bold cyan] /deep-research" + (f" {question}" if question else ""))
+            log.write(
+                "[bold yellow]Deep research is not yet implemented.[/bold yellow]\n"
+                "[dim]This will eventually run the multi-agent LangGraph pipeline "
+                "(supervisor -> parallel workers -> aggregator -> reviewer).[/dim]\n"
+            )
+        elif cmd == "/export":
+            args = text.split()[1:]  # skip /export
+            tickers: list[str] = []
+            interval: str | None = None
+            out_path: str | None = None
+            i = 0
+            while i < len(args):
+                if args[i] == "--interval" and i + 1 < len(args):
+                    interval = args[i + 1]
+                    i += 2
+                elif args[i] == "--path" and i + 1 < len(args):
+                    out_path = args[i + 1]
+                    i += 2
+                else:
+                    tickers.append(args[i])
+                    i += 1
+            if not tickers:
+                log.write(
+                    "[bold red]Usage: /export <ticker> [tickers...] "
+                    "[--interval 1D] [--path ~/dir/][/bold red]"
+                )
+                return
+            interval = interval or self.app.interval
+            export_dir = Path(out_path).expanduser() if out_path else Path("~/aipriceaction-exports").expanduser()
+            ticker_label = "_".join(tickers)
+            log.write(f"[bold cyan]You:[/bold cyan] /export {ticker_label} --interval {interval}")
+            log.write("[dim]Building context and exporting...[/dim]")
+            self._run_export(tickers, interval, export_dir)
+        else:
+            log.write(f"[bold red]Unknown command:[/bold red] {cmd}")
+
+    @work(exclusive=True)
+    async def _run_analyze(self, ticker: str, interval: str) -> None:
+        """Build AI context for a ticker in a background worker."""
+        try:
+            builder = self.app.builder
+
+            context = await asyncio.to_thread(
+                builder.build, ticker=ticker, interval=interval
+            )
+
+            log = self.query_one("#chat-log", RichLog)
+            write_context_result(log, ticker, interval, context)
+        except Exception as e:
+            log = self.query_one("#chat-log", RichLog)
+            write_error(log, e)
+
+    @work(exclusive=True)
+    async def _run_export(
+        self, tickers: list[str], interval: str, export_dir: Path
+    ) -> None:
+        """Build AI context and export to markdown file."""
+        try:
+            builder = self.app.builder
+
+            if len(tickers) == 1:
+                context = await asyncio.to_thread(
+                    builder.build, ticker=tickers[0], interval=interval
+                )
+            else:
+                context = await asyncio.to_thread(
+                    builder.build, tickers=tickers, interval=interval
+                )
+
+            export_dir.mkdir(parents=True, exist_ok=True)
+            ticker_label = "_".join(tickers)
+            date_str = datetime.now().strftime("%Y-%m-%d")
+            filename = f"{ticker_label}_{interval}_{date_str}.md"
+            filepath = export_dir / filename
+
+            await asyncio.to_thread(filepath.write_text, context, encoding="utf-8")
+
+            log = self.query_one("#chat-log", RichLog)
+            write_export_result(log, str(filepath), len(context))
+        except Exception as e:
+            log = self.query_one("#chat-log", RichLog)
+            write_error(log, e)
+
+    @work(exclusive=True)
+    async def _run_agent_chat(self, message: str) -> None:
+        """Stream an agent response into the chat log."""
+        log = self.query_one("#chat-log", RichLog)
+        try:
+            from .agents.callbacks import StreamEventType
+            buffer: list[str] = []
+            thinking_buf: list[str] = []
+
+            def flush() -> None:
+                """Write buffered tokens as a single line to the RichLog."""
+                if buffer:
+                    log.write("".join(buffer))
+                    buffer.clear()
+
+            def collapse_thinking() -> None:
+                """Collapse thinking area: write summary to log, store text."""
+                if thinking_buf:
+                    text = "".join(thinking_buf)
+                    thinking_buf.clear()
+                    # Skip trivial fragments (e.g. trailing "." from the model)
+                    if len(text.strip()) <= 1:
+                        self._hide_thinking_area()
+                        return
+                    self._store_thinking(text)
+                    self._hide_thinking_area()
+                    log.write(f"[dim]Thought for {len(text)} chars (Ctrl+O to view)[/dim]")
+
+            async for event in self.app.agent.stream(message):
+                if event.type == StreamEventType.THINKING:
+                    thinking_buf.append(event.content)
+                    self._show_thinking_area("".join(thinking_buf))
+
+                elif event.type == StreamEventType.TOKEN:
+                    if thinking_buf:
+                        collapse_thinking()
+                    buffer.append(event.content)
+                    if "\n" in event.content:
+                        flush()
+
+                elif event.type == StreamEventType.DONE:
+                    if thinking_buf:
+                        collapse_thinking()
+                    flush()
+                    log.write("")
+
+                else:
+                    flush()
+                    if event.type == StreamEventType.TOOL_CALL_START:
+                        log.write(f"[dim italic]{event.content}[/dim italic]")
+                    elif event.type == StreamEventType.TOOL_RESULT:
+                        log.write(f"[dim]{event.content}[/dim]")
+                    elif event.type == StreamEventType.ERROR:
+                        log.write(f"[bold red]{event.content}[/bold red]")
+        except Exception as e:
+            log.write(f"[bold red]Agent error: {e}[/bold red]\n")

aipriceaction_terminal/cli.py

@@ -0,0 +1,54 @@
+"""CLI dispatcher: routes to TUI or subcommands."""
+
+import argparse
+
+
+def run():
+    parser = argparse.ArgumentParser(prog="aipa", description="AIPriceAction terminal")
+    sub = parser.add_subparsers(dest="command")
+
+    # aipa analyze VCB [tickers...] [--interval 1D] [--limit N]
+    #   [--source vn] [--start-date] [--end-date] [--reference-ticker VNINDEX]
+    #   [--lang en] [--ma-type ema]
+    p_analyze = sub.add_parser("analyze", help="Build AI context for a ticker")
+    p_analyze.add_argument("tickers", nargs="+", help="Ticker symbol(s)")
+    p_analyze.add_argument("--interval", default="1D")
+    p_analyze.add_argument("--limit", type=int, default=None)
+    p_analyze.add_argument("--source", default=None)
+    p_analyze.add_argument("--start-date", default=None)
+    p_analyze.add_argument("--end-date", default=None)
+    p_analyze.add_argument("--reference-ticker", default="VNINDEX")
+    p_analyze.add_argument("--lang", default="en", choices=["en", "vn"])
+    p_analyze.add_argument("--ma-type", default="ema", choices=["ema", "sma"])
+
+    # aipa get-ohlcv-data TICKER [--interval 1D] [--limit N]
+    #   [--start-date] [--end-date] [--source] [--ma] [--ema]
+    p_ohlcv = sub.add_parser("get-ohlcv-data", help="Fetch raw OHLCV data")
+    p_ohlcv.add_argument("ticker", help="Ticker symbol")
+    p_ohlcv.add_argument("--interval", default="1D")
+    p_ohlcv.add_argument("--limit", type=int, default=None)
+    p_ohlcv.add_argument("--start-date", default=None)
+    p_ohlcv.add_argument("--end-date", default=None)
+    p_ohlcv.add_argument("--source", default=None)
+    p_ohlcv.add_argument("--ma", action="store_true", default=True)
+    p_ohlcv.add_argument("--no-ma", dest="ma", action="store_false")
+    p_ohlcv.add_argument("--ema", action="store_true", default=False)
+
+    # aipa deep-research [question]
+    p_deep = sub.add_parser("deep-research", help="Multi-agent deep research (not yet implemented)")
+    p_deep.add_argument("question", nargs="*", help="Research question")
+
+    args = parser.parse_args()
+
+    if args.command == "analyze":
+        from .cli_commands import cmd_analyze
+        cmd_analyze(args)
+    elif args.command == "get-ohlcv-data":
+        from .cli_commands import cmd_get_ohlcv
+        cmd_get_ohlcv(args)
+    elif args.command == "deep-research":
+        from .cli_commands import cmd_deep_research
+        cmd_deep_research(" ".join(args.question) if args.question else "")
+    else:
+        from .app import main
+        main()

aipriceaction_terminal/cli_commands.py

@@ -0,0 +1,51 @@
+"""CLI subcommand implementations — thin wrappers around SDK methods."""
+
+
+def cmd_analyze(args) -> None:
+    from aipriceaction import AIContextBuilder
+
+    builder = AIContextBuilder(lang=args.lang, ma_type=args.ma_type)
+    if len(args.tickers) == 1:
+        context = builder.build(
+            ticker=args.tickers[0],
+            interval=args.interval,
+            limit=args.limit,
+            source=args.source,
+            start_date=args.start_date,
+            end_date=args.end_date,
+            reference_ticker=args.reference_ticker,
+            include_system_prompt=False,
+        )
+    else:
+        context = builder.build(
+            tickers=args.tickers,
+            interval=args.interval,
+            limit=args.limit,
+            source=args.source,
+            start_date=args.start_date,
+            end_date=args.end_date,
+            reference_ticker=args.reference_ticker,
+            include_system_prompt=False,
+        )
+    print(context)
+
+
+def cmd_get_ohlcv(args) -> None:
+    from aipriceaction import AIPriceAction
+
+    client = AIPriceAction()
+    df = client.get_ohlcv(
+        ticker=args.ticker,
+        interval=args.interval,
+        limit=args.limit,
+        start_date=args.start_date,
+        end_date=args.end_date,
+        source=args.source,
+        ma=args.ma,
+        ema=args.ema,
+    )
+    print(df.to_string(index=False))
+
+
+def cmd_deep_research(question: str) -> None:
+    print("deep-research is not yet implemented.")

aipriceaction_terminal/settings_tab.py

@@ -0,0 +1,76 @@
+"""Settings tab: placeholder for configuration."""
+
+from textual.containers import Vertical, Horizontal
+from textual.widgets import Static, Input, Button, Select
+
+from .user_settings import save_settings
+
+
+class SettingsTab(Vertical):
+    """Settings configuration."""
+
+    DEFAULT_CSS = """
+    SettingsTab {
+        padding: 1 2;
+    }
+    .setting-row {
+        height: auto;
+        margin-bottom: 1;
+    }
+    #apply-btn {
+        margin-top: 1;
+    }
+    .setting-label {
+        width: 12;
+    }
+    .setting-input {
+        width: 20;
+    }
+    #setting-language {
+        width: 20;
+    }
+    """
+
+    def compose(self):
+        yield Static("[bold]Settings[/bold] (placeholder)")
+        yield Static("")
+        with Horizontal(classes="setting-row"):
+            yield Static("Ref Ticker:", classes="setting-label")
+            yield Input(value="VNINDEX", id="setting-ticker", classes="setting-input")
+        with Horizontal(classes="setting-row"):
+            yield Static("Interval:", classes="setting-label")
+            yield Select(
+                [("1m", "1m"), ("1h", "1h"), ("1D", "1D")],
+                value="1D",
+                allow_blank=False,
+                id="setting-interval",
+            )
+        with Horizontal(classes="setting-row"):
+            yield Static("Language:", classes="setting-label")
+            yield Select(
+                [("English", "en"), ("Tiếng Việt", "vn")],
+                value="en",
+                allow_blank=False,
+                id="setting-language",
+            )
+        yield Button("Apply", id="apply-btn", variant="primary")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "apply-btn":
+            ticker = self.query_one("#setting-ticker", Input).value.strip().upper()
+            interval = self.query_one("#setting-interval", Select).value
+            language = self.query_one("#setting-language", Select).value
+
+            if ticker:
+                self.app.ticker = ticker
+            if interval:
+                self.app.interval = interval
+            if language:
+                self.app.language = language
+                from aipriceaction import AIContextBuilder
+                self.app.builder = AIContextBuilder(lang=language)
+                from .agents import AgentSession, AgentConfig
+                self.app.agent = AgentSession(AgentConfig(lang=language))
+
+            self.app.notify(f"Settings applied: {ticker} / {interval} / {language}")
+            save_settings({"ticker": ticker, "interval": interval, "language": language})

aipriceaction_terminal/theme.py

@@ -0,0 +1,29 @@
+"""Custom Dracula-inspired green theme and screen CSS."""
+
+from textual.theme import Theme
+
+AI_GREEN = Theme(
+    name="ai-green",
+    primary="#50fa7b",
+    secondary="#8be9fd",
+    accent="#50fa7b",
+    warning="#f1fa8c",
+    error="#ff5555",
+    success="#50fa7b",
+    background="#1a1e2e",
+    surface="#282a36",
+    panel="#44475a",
+    dark=True,
+)
+
+SCREEN_CSS = """
+Screen {
+    layout: vertical;
+}
+TabbedContent {
+    height: 1fr;
+}
+TabbedContent TabPane {
+    height: 1fr;
+}
+"""

aipriceaction_terminal/ticker_data.py

@@ -0,0 +1,33 @@
+"""Ticker data tab: placeholder for raw OHLCV data view."""
+
+from textual.containers import Vertical
+from textual.widgets import Static
+
+_MODE_LABELS = {
+    "vn": "VN Tickers",
+    "crypto": "Crypto",
+    "global": "Global",
+}
+
+
+class TickerDataTab(Vertical):
+    """Display raw OHLCV data for a ticker source."""
+
+    DEFAULT_CSS = """
+    TickerDataTab {
+        padding: 1 2;
+    }
+    """
+
+    def __init__(self, mode: str = "vn", **kwargs):
+        super().__init__(**kwargs)
+        self.mode = mode
+
+    def compose(self):
+        label = _MODE_LABELS.get(self.mode, self.mode)
+        yield Static(f"[bold]{label}[/bold]", id="td-title")
+        yield Static(
+            "[dim italic]This tab will display ticker data in a table format.\n"
+            "Not yet implemented.[/dim italic]",
+            id="td-hint",
+        )

aipriceaction_terminal/user_settings.py

@@ -0,0 +1,27 @@
+"""Persistent user settings stored in ~/.aipriceaction/settings.json."""
+
+import json
+from pathlib import Path
+
+_CONFIG_DIR = Path.home() / ".aipriceaction"
+_SETTINGS_FILE = _CONFIG_DIR / "settings.json"
+
+_DEFAULTS = {
+    "ticker": "VNINDEX",
+    "interval": "1D",
+    "language": "en",
+}
+
+
+def load_settings() -> dict:
+    """Load settings from disk, falling back to defaults for missing keys."""
+    if _SETTINGS_FILE.exists():
+        data = json.loads(_SETTINGS_FILE.read_text())
+        return {**_DEFAULTS, **data}
+    return dict(_DEFAULTS)
+
+
+def save_settings(data: dict) -> None:
+    """Persist settings to disk, creating the config directory if needed."""
+    _CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    _SETTINGS_FILE.write_text(json.dumps(data, indent=2))

aipriceaction_terminal/utils.py

@@ -0,0 +1,29 @@
+"""Shared display helpers for RichLog output formatting."""
+
+from textual.widgets import RichLog
+
+
+def write_context_result(
+    log: RichLog, ticker: str, interval: str, context: str
+) -> None:
+    """Write a formatted context build result to a RichLog."""
+    lines = context.split("\n")
+    log.write(
+        f"[bold green]Context built[/bold green] for [bold]{ticker}[/bold] "
+        f"({interval}) - {len(context):,} chars, {len(lines)} lines\n"
+    )
+    log.write("[dim]" + context + "[/dim]")
+    log.write("")
+
+
+def write_error(log: RichLog, error: Exception) -> None:
+    """Write a formatted error to a RichLog."""
+    log.write(f"[bold red]Error:[/bold red] {error}")
+
+
+def write_export_result(log: RichLog, filepath: str, context_len: int) -> None:
+    """Write a formatted export success message to a RichLog."""
+    log.write(
+        f"[bold green]Exported[/bold green] {context_len:,} chars to "
+        f"[bold]{filepath}[/bold]\n"
+    )

aipriceaction_terminal/widgets/__init__.py

@@ -0,0 +1,6 @@
+"""Reusable widgets for aipriceaction-terminal."""
+
+from .ticker_select import TickerSelect
+from .chat_input import ChatInput
+
+__all__ = ["TickerSelect", "ChatInput"]