aipa-cli 0.1.3__tar.gz → 0.1.4__tar.gz

{aipa_cli-0.1.3 → aipa_cli-0.1.4}/CHANGELOG.md

@@ -5,6 +5,27 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.4] - 2026-05-09
+
+### Added
+- Add unified LLM-powered analyze flow: `aipa analyze` now invokes LLM with question bank by default instead of dumping raw context
+- Add `--question TEXT`, `--questions`, and `--context-only` flags to `aipa analyze` CLI command
+- Add question bank `Select` dropdown and custom question `Input` to AnalyzePane in Workflows tab
+- Add `deep_research.py` module adapting multi-agent pipeline (supervisor -> parallel workers -> aggregator -> reviewer) from examples into a proper importable module
+- Add `--resume`, `--output`, and `--lang` flags to `aipa deep-research` command
+- Extract `stream_agent_to_log()` shared helper from chat into utils.py, used by both ChatTab and AnalyzePane
+- Extend `/analyze` slash command to support template index (`/analyze VCB 2`) and custom questions (`/analyze VCB --question ...`)
+
+### Changed
+- Resolve effective language from saved `settings.json` when `--lang` is not explicitly passed on CLI
+- Default analyze limit changed from 60 to 20 bars to reduce context size for smaller models
+- Require `aipriceaction>=0.1.9`
+
+### Fixed
+- Add retry logic (up to 3 attempts) for transient LLM failures in `cmd_analyze`
+- Handle string/JSON args in deep-research supervisor tool calls for LLMs that don't parse tool args properly
+- Increment `review_round` on each aggregator cycle so reviewer displays correct round numbers
+
 ## [0.1.3] - 2026-05-09
 
 ### Fixed

{aipa_cli-0.1.3 → aipa_cli-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aipa-cli
-Version: 0.1.3
+Version: 0.1.4
 Summary: Terminal TUI for AI-powered ticker analysis
 Project-URL: Homepage, https://github.com/quanhua92/aipriceaction
 Project-URL: Repository, https://github.com/quanhua92/aipriceaction
@@ -15,7 +15,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Office/Business :: Financial
 Requires-Python: >=3.13
-Requires-Dist: aipriceaction>=0.1.8
+Requires-Dist: aipriceaction>=0.1.9
 Requires-Dist: langchain-core
 Requires-Dist: langchain-openai
 Requires-Dist: langgraph

{aipa_cli-0.1.3 → aipa_cli-0.1.4}/pyproject.toml

@@ -9,7 +9,7 @@ license = "MIT"
 readme = "README.md"
 requires-python = ">=3.13"
 dependencies = [
-    "aipriceaction>=0.1.8",
+    "aipriceaction>=0.1.9",
     "textual>=3.0.0",
     "textual-autocomplete>=4.0.6",
     "langchain-core",

{aipa_cli-0.1.3 → aipa_cli-0.1.4}/src/aipriceaction_terminal/__init__.py

@@ -1,4 +1,4 @@
 """AIPriceAction Terminal - TUI chat interface for ticker analysis."""
 
-__version__ = "0.1.3"
+__version__ = "0.1.4"
 

aipa_cli-0.1.4/src/aipriceaction_terminal/agents/config.py

@@ -0,0 +1,57 @@
+"""Agent configuration: reads from env vars, then settings.json, then SDK defaults."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+
+from aipriceaction.settings import settings
+
+from ..user_settings import load_settings
+
+
+def _resolve(field_name: str, env_var: str, sdk_default: str) -> str:
+    """Resolve a config field: env var > settings.json > SDK default."""
+    env_val = os.environ.get(env_var, "")
+    if env_val:
+        return env_val
+    saved = load_settings().get(field_name, "")
+    if saved:
+        return saved
+    return sdk_default
+
+
+@dataclass(frozen=True)
+class AgentConfig:
+    """Configuration for an agent session.
+
+    Resolution order per field: environment variable > settings.json > SDK default.
+    """
+
+    api_key: str = field(
+        default_factory=lambda: _resolve("api_key", "OPENAI_API_KEY", settings.openai_api_key),
+    )
+    base_url: str = field(
+        default_factory=lambda: _resolve("openai_base_url", "OPENAI_BASE_URL", settings.openai_base_url),
+    )
+    model: str = field(
+        default_factory=lambda: _resolve("openai_model", "OPENAI_MODEL", settings.openai_model),
+    )
+    lang: str = field(
+        default_factory=lambda: _resolve("language", "AI_CONTEXT_LANG", settings.ai_context_lang),
+    )
+    max_retries: int = 3
+    base_retry_delay: float = 5.0
+    max_retry_delay: float = 60.0
+
+
+TRANSIENT_ERROR_KEYWORDS: tuple[str, ...] = (
+    "429",
+    "500",
+    "502",
+    "503",
+    "504",
+    "timeout",
+    "connection",
+    "overloaded",
+)

{aipa_cli-0.1.3 → aipa_cli-0.1.4}/src/aipriceaction_terminal/chat.py

@@ -10,7 +10,31 @@ 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
+from .utils import write_error, write_export_result, stream_agent_to_log
+
+
+def _resolve_tui_question(
+    builder: object,
+    ticker: str,
+    question_index: int | None,
+    custom_question: str | None,
+) -> str:
+    """Resolve the analysis question for TUI /analyze command."""
+    if custom_question:
+        return custom_question
+
+    templates = builder.questions("single")
+    if not templates:
+        return f"Analyze {ticker} based on the provided data."
+
+    idx = question_index if question_index is not None else 0
+    idx = max(0, min(idx, len(templates) - 1))
+    template = templates[idx]
+
+    try:
+        return template["question"].format(ticker=ticker)
+    except KeyError:
+        return template["question"]
 
 
 class ThinkingModal(Screen[None]):
@@ -179,10 +203,13 @@ class ChatTab(Vertical):
         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"
+                "  /analyze <ticker> [interval|index] [--question TEXT]\n"
+                "             Analyze ticker with AI (e.g. /analyze VIC)\n"
+                "             Use index 0-5 to pick question template\n"
+                "             Use --question for custom question\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"
+                "  /deep-research [q]   - Multi-agent deep research\n"
                 "  /exit                - Quit the application\n"
                 "  /help                - Show this help message\n"
                 "  /clear               - Clear chat history\n"
@@ -193,14 +220,15 @@ class ChatTab(Vertical):
         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)
+            self._handle_analyze(text, parts)
+        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 == "/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 ""))
@@ -240,20 +268,90 @@ class ChatTab(Vertical):
         else:
             log.write(f"[bold red]Unknown command:[/bold red] {cmd}")
 
+    _KNOWN_INTERVALS = frozenset(("1m", "5m", "15m", "30m", "1h", "4h", "1D", "1W", "1M"))
+
+    def _handle_analyze(self, text: str, parts: list[str]) -> None:
+        """Parse /analyze command and dispatch to _run_analyze."""
+        log = self.query_one("#chat-log", RichLog)
+        rest = text[len("/analyze"):].strip()
+
+        if not rest:
+            log.write(
+                "[bold red]Usage:[/bold red] /analyze <ticker> [interval|index] [--question TEXT]\n"
+                "  e.g. /analyze VIC\n"
+                "       /analyze STB 1h\n"
+                "       /analyze VCB 2\n"
+                "       /analyze VCB --question What is the support level?"
+            )
+            return
+
+        # Parse --question flag
+        custom_question: str | None = None
+        if "--question" in rest:
+            rest, _, custom_question = rest.partition("--question")
+            custom_question = custom_question.strip()
+            rest = rest.strip()
+
+        tokens = rest.split()
+        ticker = tokens[0].upper()
+
+        # Determine question_index and interval
+        question_index: int | None = None
+        interval = self.app.interval
+
+        if len(tokens) > 1:
+            second = tokens[1]
+            if second in self._KNOWN_INTERVALS:
+                interval = second
+            elif second.isdigit():
+                question_index = int(second)
+
+        log.write(f"[bold cyan]You:[/bold cyan] /analyze {ticker} {interval}")
+        log.write("[dim]Building context and analyzing...[/dim]")
+        self._run_analyze(ticker, interval, question_index=question_index, custom_question=custom_question)
+
     @work(exclusive=True)
-    async def _run_analyze(self, ticker: str, interval: str) -> None:
-        """Build AI context for a ticker in a background worker."""
+    async def _run_analyze(
+        self,
+        ticker: str,
+        interval: str,
+        *,
+        question_index: int | None = None,
+        custom_question: str | None = None,
+    ) -> None:
+        """Build context and stream AI analysis for a ticker."""
+        log = self.query_one("#chat-log", RichLog)
         try:
             builder = self.app.builder
 
+            # Build context without system prompt (agent has it already)
             context = await asyncio.to_thread(
-                builder.build, ticker=ticker, interval=interval
+                builder.build, ticker=ticker, interval=interval,
+                include_system_prompt=False,
             )
 
-            log = self.query_one("#chat-log", RichLog)
-            write_context_result(log, ticker, interval, context)
+            log.write(f"[dim]Context ready: {len(context):,} chars[/dim]")
+
+            # Resolve question
+            question = _resolve_tui_question(
+                builder, ticker, question_index, custom_question,
+            )
+
+            # Compose the message for the agent
+            message = (
+                f"<analysis_context>\n{context}\n</analysis_context>\n\n"
+                f"{question}\n\n"
+                f"Base your analysis ONLY on the provided data above."
+            )
+
+            await stream_agent_to_log(
+                log,
+                self.app.agent,
+                message,
+                on_thinking_update=self._show_thinking_area,
+                on_thinking_done=self._on_thinking_done,
+            )
         except Exception as e:
-            log = self.query_one("#chat-log", RichLog)
             write_error(log, e)
 
     @work(exclusive=True)
@@ -292,54 +390,22 @@ class ChatTab(Vertical):
         """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]")
+            await stream_agent_to_log(
+                log,
+                self.app.agent,
+                message,
+                on_thinking_update=self._show_thinking_area,
+                on_thinking_done=self._on_thinking_done,
+            )
         except Exception as e:
             log.write(f"[bold red]Agent error: {e}[/bold red]\n")
+
+    def _on_thinking_done(self, text: str) -> None:
+        """Called when a thinking block finishes. Store and collapse."""
+        if not text or len(text.strip()) <= 1:
+            self._hide_thinking_area()
+            return
+        self._store_thinking(text)
+        self._hide_thinking_area()
+        log = self.query_one("#chat-log", RichLog)
+        log.write(f"[dim]Thought for {len(text)} chars (Ctrl+O to view)[/dim]")

{aipa_cli-0.1.3 → aipa_cli-0.1.4}/src/aipriceaction_terminal/cli.py

@@ -9,8 +9,8 @@ def run():
 
     # 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")
+    #   [--lang en] [--ma-type ema] [--question TEXT] [--questions] [--context-only]
+    p_analyze = sub.add_parser("analyze", help="AI analysis for ticker(s)")
     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)
@@ -18,8 +18,11 @@ def run():
     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("--lang", default=None, choices=["en", "vn"])
     p_analyze.add_argument("--ma-type", default="ema", choices=["ema", "sma"])
+    p_analyze.add_argument("--question", default=None, help="Custom analysis question")
+    p_analyze.add_argument("--questions", action="store_true", help="List available question templates and exit")
+    p_analyze.add_argument("--context-only", action="store_true", help="Dump raw context without LLM (no API key needed)")
 
     # aipa get-ohlcv-data TICKER [--interval 1D] [--limit N]
     #   [--start-date] [--end-date] [--source] [--ma] [--ema]
@@ -35,8 +38,11 @@ def run():
     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 = sub.add_parser("deep-research", help="Multi-agent deep research")
     p_deep.add_argument("question", nargs="*", help="Research question")
+    p_deep.add_argument("--resume", default=None, help="Resume from checkpoint session ID")
+    p_deep.add_argument("--output", default=None, help="Save final report to file")
+    p_deep.add_argument("--lang", default=None, choices=["en", "vn"], help="Override language")
 
     args = parser.parse_args()
 
@@ -48,7 +54,12 @@ def run():
         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 "")
+        cmd_deep_research(
+            question=" ".join(args.question) if args.question else "",
+            resume=args.resume,
+            output=args.output,
+            lang=args.lang,
+        )
     else:
         from .app import main
         main()

aipa_cli-0.1.4/src/aipriceaction_terminal/cli_commands.py

@@ -0,0 +1,154 @@
+"""CLI subcommand implementations — thin wrappers around SDK methods."""
+
+from __future__ import annotations
+
+import sys
+import time
+
+
+def _resolve_lang(arg_lang: str | None) -> str:
+    """Resolve effective language: CLI arg > saved settings > default."""
+    if arg_lang:
+        return arg_lang
+    from .user_settings import load_settings
+    return load_settings().get("language", "en")
+
+
+def cmd_analyze(args) -> None:
+    from aipriceaction import AIContextBuilder
+
+    lang = _resolve_lang(args.lang)
+    builder = AIContextBuilder(lang=lang, ma_type=args.ma_type)
+
+    # --questions: list question bank and exit
+    if args.questions:
+        mode = "single" if len(args.tickers) == 1 else "multi"
+        templates = builder.questions(mode)
+        print(f"Available question templates ({mode}, lang={lang}):\n")
+        for i, t in enumerate(templates):
+            print(f"  [{i}] {t['title']}")
+            print(f"      {t['snippet']}\n")
+        return
+
+    # Build context
+    build_kwargs = dict(
+        interval=args.interval,
+        limit=args.limit if args.limit is not None else 20,
+        source=args.source,
+        start_date=args.start_date,
+        end_date=args.end_date,
+        reference_ticker=args.reference_ticker,
+    )
+
+    t0 = time.time()
+
+    if len(args.tickers) == 1:
+        context = builder.build(
+            ticker=args.tickers[0],
+            **build_kwargs,
+            include_system_prompt=not args.context_only,
+        )
+    else:
+        context = builder.build(
+            tickers=args.tickers,
+            **build_kwargs,
+            include_system_prompt=not args.context_only,
+        )
+
+    build_elapsed = time.time() - t0
+    ticker_label = args.tickers[0] if len(args.tickers) == 1 else ",".join(args.tickers)
+
+    # --context-only: dump raw context and exit
+    if args.context_only:
+        print(context)
+        return
+
+    # LLM analysis
+    question = _resolve_question(builder, args)
+    if not question:
+        print("No question resolved. Use --question TEXT or pick from --questions.", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"[build] Context ready ({len(context):,} chars, {build_elapsed:.1f}s)", file=sys.stderr)
+    print(f"[analyze] Asking:\n{question}", file=sys.stderr)
+
+    # LLM analysis with retry on empty/transient failures
+    max_attempts = 3
+    response = ""
+    last_error: Exception | None = None
+    for attempt in range(max_attempts):
+        try:
+            response = builder.answer(question)
+        except Exception as e:
+            last_error = e
+            print(f"[error] Attempt {attempt + 1}/{max_attempts}: {type(e).__name__}: {e}", file=sys.stderr)
+            if attempt < max_attempts - 1:
+                import time as _time
+                _time.sleep(2)
+            continue
+        if response.strip():
+            break
+        print(f"[warn] Attempt {attempt + 1}/{max_attempts}: LLM returned empty response", file=sys.stderr)
+        last_error = RuntimeError("LLM returned empty response")
+    else:
+        elapsed = time.time() - t0
+        print(f"[done] Total: {elapsed:.1f}s", file=sys.stderr)
+        if last_error:
+            print(f"[error] Failed after {max_attempts} attempts: {last_error}", file=sys.stderr)
+        sys.exit(1)
+
+    elapsed = time.time() - t0
+    print(f"[done] Total: {elapsed:.1f}s", file=sys.stderr)
+    print()
+    print(response)
+
+
+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 = "",
+    resume: str | None = None,
+    output: str | None = None,
+    lang: str | None = None,
+) -> None:
+    from .deep_research import run_deep_research
+
+    effective_lang = _resolve_lang(lang)
+    run_deep_research(question=question, resume_id=resume, output_file=output, lang=effective_lang)
+
+
+def _resolve_question(builder, args) -> str:
+    """Resolve the analysis question from args or question bank default."""
+    if args.question:
+        return args.question
+
+    # For single ticker, use question bank template 0 with {ticker} interpolated
+    if len(args.tickers) == 1:
+        templates = builder.questions("single")
+        if templates:
+            try:
+                return templates[0]["question"].format(ticker=args.tickers[0])
+            except KeyError:
+                return templates[0]["question"]
+
+    # For multi-ticker, use question bank template 0
+    templates = builder.questions("multi")
+    if templates:
+        return templates[0]["question"]
+
+    return ""