aipa-cli 0.1.0__tar.gz

aipa_cli-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+.venv/
+.pytest_cache/

aipa_cli-0.1.0/CHANGELOG.md

@@ -0,0 +1,38 @@
+# Changelog
+
+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.0] - 2026-05-09
+
+### Added
+- Add `aipriceaction-terminal` Textual TUI with chat, workflows, and ticker tabs
+- Add TickerSelect autocomplete widget using textual-autocomplete
+- Add `/exit` command, `/analyze` optional interval arg, and auto-focus chat input
+- Add arrow up/down history navigation in chat input
+- Add ChatInput widget with slash command autocomplete and history
+- Add `/export` command to save AIContextBuilder output to markdown
+- Add agents module for AI-powered chat with streaming and tab-switch fix
+- Add thinking token detection with collapsible summary in chat
+- Add OpenRouterChatOpenAI for reasoning token passthrough and stream thinking visibly
+- Add collapsible thinking display with modal viewer in Chat tab
+- Add CLI subcommands (`analyze`, `get-ohlcv-data`, `deep-research`) to `aipa` binary
+- Add 42 pytest tests for `aipriceaction-terminal`
+- Add integration tests with real LangChain message types
+- Persist user settings to `~/.aipriceaction/settings.json`
+- Show all thinking history with timestamps in ThinkingModal
+
+### Changed
+- Reduce default ohlcv limit from 30 to 5 bars
+- Replace mock-based tests with real LangChain message types and add integration tests
+- Update data policy to fetch via tools
+- Extract key bindings and action handlers from `app.py` into separate modules
+
+### Fixed
+- Improve TickerSelect autocomplete dropdown size and ticker symbol ranking
+- Select autocomplete on Enter instead of submitting when dropdown is open
+- Compact ticker list output and buffer streaming tool calls
+- Escape key closes thinking modal
+- Fix ohlcv docstring default

aipa_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Quan Hua
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aipa_cli-0.1.0/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: aipa-cli
+Version: 0.1.0
+Summary: Terminal TUI for AI-powered ticker analysis
+Project-URL: Homepage, https://github.com/quanhua92/aipriceaction
+Project-URL: Repository, https://github.com/quanhua92/aipriceaction
+Author-email: Quan Hua <quanhua92@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console :: Curses
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.13
+Requires-Dist: aipriceaction
+Requires-Dist: langchain-core
+Requires-Dist: langchain-openai
+Requires-Dist: langgraph
+Requires-Dist: textual-autocomplete>=4.0.6
+Requires-Dist: textual>=3.0.0
+Description-Content-Type: text/markdown
+
+# AIPA Terminal
+
+**Live site:** [aipriceaction.com](https://aipriceaction.com) | **GitHub:** [aipriceaction](https://github.com/quanhua92/aipriceaction) | **Frontend:** [aipriceaction-web](https://github.com/quanhua92/aipriceaction-web) | **Docker image:** [`quanhua92/aipriceaction:latest`](https://hub.docker.com/r/quanhua92/aipriceaction) | **Python SDK:** [`aipriceaction` on PyPI](https://pypi.org/project/aipriceaction/) | **AIPA Terminal:** [`aipa-cli` on PyPI](https://pypi.org/project/aipa-cli/)
+
+Textual-based terminal interface for AI-powered ticker analysis. Features streaming chat with thinking/reasoning display, autocomplete, slash commands, and workflow tabs.
+
+## Install
+
+```bash
+# Run directly (no install)
+uvx aipa-cli
+
+# Or install as a standalone tool
+uv tool install aipa-cli
+```
+
+## Requirements
+
+- Python 3.13+
+- An OpenAI-compatible API key (`OPENAI_API_KEY`)
+- Optional: set `OPENAI_BASE_URL` for custom providers like OpenRouter
+
+## Usage
+
+```
+aipa              # Launch the TUI
+aipa analyze      # Run ticker analysis from CLI
+aipa get-ohlcv-data  # Fetch OHLCV data from CLI
+aipa deep-research   # Run deep research from CLI
+```
+
+### TUI
+
+The interface has three tabs:
+
+- **Chat** — AI-powered chat with streaming responses, thinking/reasoning display, slash commands (`/analyze`, `/export`, `/clear`, `/exit`), and arrow-key history navigation
+- **Workflows** — Structured analysis forms for ticker analysis and deep research
+- **Tickers** — Browse and search available tickers
+
+Press `Ctrl+O` in the Chat tab to view thinking/reasoning history.
+
+## License
+
+MIT

aipa_cli-0.1.0/README.md

@@ -0,0 +1,44 @@
+# AIPA Terminal
+
+**Live site:** [aipriceaction.com](https://aipriceaction.com) | **GitHub:** [aipriceaction](https://github.com/quanhua92/aipriceaction) | **Frontend:** [aipriceaction-web](https://github.com/quanhua92/aipriceaction-web) | **Docker image:** [`quanhua92/aipriceaction:latest`](https://hub.docker.com/r/quanhua92/aipriceaction) | **Python SDK:** [`aipriceaction` on PyPI](https://pypi.org/project/aipriceaction/) | **AIPA Terminal:** [`aipa-cli` on PyPI](https://pypi.org/project/aipa-cli/)
+
+Textual-based terminal interface for AI-powered ticker analysis. Features streaming chat with thinking/reasoning display, autocomplete, slash commands, and workflow tabs.
+
+## Install
+
+```bash
+# Run directly (no install)
+uvx aipa-cli
+
+# Or install as a standalone tool
+uv tool install aipa-cli
+```
+
+## Requirements
+
+- Python 3.13+
+- An OpenAI-compatible API key (`OPENAI_API_KEY`)
+- Optional: set `OPENAI_BASE_URL` for custom providers like OpenRouter
+
+## Usage
+
+```
+aipa              # Launch the TUI
+aipa analyze      # Run ticker analysis from CLI
+aipa get-ohlcv-data  # Fetch OHLCV data from CLI
+aipa deep-research   # Run deep research from CLI
+```
+
+### TUI
+
+The interface has three tabs:
+
+- **Chat** — AI-powered chat with streaming responses, thinking/reasoning display, slash commands (`/analyze`, `/export`, `/clear`, `/exit`), and arrow-key history navigation
+- **Workflows** — Structured analysis forms for ticker analysis and deep research
+- **Tickers** — Browse and search available tickers
+
+Press `Ctrl+O` in the Chat tab to view thinking/reasoning history.
+
+## License
+
+MIT

aipa_cli-0.1.0/pyproject.toml

@@ -0,0 +1,60 @@
+[project]
+name = "aipa-cli"
+dynamic = ["version"]
+description = "Terminal TUI for AI-powered ticker analysis"
+authors = [
+    {name = "Quan Hua", email = "quanhua92@gmail.com"},
+]
+license = "MIT"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "aipriceaction",
+    "textual>=3.0.0",
+    "textual-autocomplete>=4.0.6",
+    "langchain-core",
+    "langchain-openai",
+    "langgraph",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console :: Curses",
+    "Intended Audience :: Financial and Insurance Industry",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Office/Business :: Financial",
+]
+
+[project.urls]
+Homepage = "https://github.com/quanhua92/aipriceaction"
+Repository = "https://github.com/quanhua92/aipriceaction"
+
+[project.scripts]
+aipa = "aipriceaction_terminal.app:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+path = "src/aipriceaction_terminal/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/aipriceaction_terminal"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/aipriceaction_terminal", "tests", "pyproject.toml", "README.md", "LICENSE", "CHANGELOG.md"]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.24",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+
+[tool.uv.sources]
+aipriceaction = { workspace = true }

aipa_cli-0.1.0/src/aipriceaction_terminal/__init__.py

@@ -0,0 +1,3 @@
+"""AIPriceAction Terminal - TUI chat interface for ticker analysis."""
+
+__version__ = "0.1.0"

aipa_cli-0.1.0/src/aipriceaction_terminal/__main__.py

@@ -0,0 +1,3 @@
+from .cli import run
+
+run()

aipa_cli-0.1.0/src/aipriceaction_terminal/actions.py

@@ -0,0 +1,73 @@
+"""Action handlers for AIPriceActionApp."""
+
+import time
+
+from textual.widgets import TabbedContent, Input, Select, Button, TextArea
+
+
+class AppActions:
+    """Mixin providing all action_* methods for AIPriceActionApp."""
+
+    _quit_requested_at: float = 0.0
+
+    def action_switch_tab(self, tab_id: str) -> None:
+        tabs = self.query_one(TabbedContent)
+        tabs.active = tab_id
+
+    def action_focus_none(self) -> None:
+        """Blur any focused widget, or dismiss a modal if one is showing."""
+        from .chat import ThinkingModal
+        if isinstance(self.screen_stack[-1], ThinkingModal):
+            self.pop_screen()
+            return
+        self.set_focus(None)
+
+    def action_focus_first_input(self) -> None:
+        """Focus the first Input or Select in the active tab (respects nested tabs)."""
+        # Let Enter pass through to widgets that handle it themselves
+        if isinstance(self.focused, (Input, Select, Button, TextArea)):
+            return
+
+        tabs = self.query_one(TabbedContent)
+        active_pane = tabs.query(f"TabPane#{tabs.active}").first()
+        if active_pane is None:
+            return
+
+        # Find the innermost active TabbedContent within this pane
+        container = active_pane
+        try:
+            nested = active_pane.query_one("TabbedContent")
+            inner_pane = nested.query(f"TabPane#{nested.active}").first()
+            if inner_pane:
+                container = inner_pane
+        except Exception:
+            pass
+
+        try:
+            first_input = container.query(Input).first()
+            first_input.focus()
+            return
+        except Exception:
+            pass
+        try:
+            first_select = container.query(Select).first()
+            first_select.focus()
+        except Exception:
+            pass
+
+    def action_confirm_quit(self) -> None:
+        """Quit on second press within 2 seconds, otherwise show warning."""
+        now = time.monotonic()
+        if now - self._quit_requested_at < 2.0:
+            self.exit()
+        else:
+            self._quit_requested_at = now
+            self.notify("Press ctrl+q again to quit", severity="warning")
+
+    def action_show_help(self) -> None:
+        self.app.notify(
+            "1-6: Switch tabs | ctrl+q: Quit | "
+            "esc: Back | enter: Focus input | "
+            "Chat: /help for commands",
+            title="Keyboard Shortcuts",
+        )

aipa_cli-0.1.0/src/aipriceaction_terminal/agents/__init__.py

@@ -0,0 +1,20 @@
+"""Agents module for AI-powered chat in the terminal TUI."""
+
+from .agent import AgentSession
+from .callbacks import StreamCallbackHandler, StreamEvent, StreamEventType
+from .config import AgentConfig
+from .personas import Persona, PersonaRegistry, get_default_persona
+from .tools import ToolRegistry, get_default_tools
+
+__all__ = [
+    "AgentSession",
+    "AgentConfig",
+    "Persona",
+    "PersonaRegistry",
+    "get_default_persona",
+    "ToolRegistry",
+    "get_default_tools",
+    "StreamCallbackHandler",
+    "StreamEvent",
+    "StreamEventType",
+]

aipa_cli-0.1.0/src/aipriceaction_terminal/agents/agent.py

@@ -0,0 +1,175 @@
+"""Agent session: wraps LangChain create_agent with streaming and retry."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import AsyncIterator
+from typing import TYPE_CHECKING, Any
+
+from langchain.agents import create_agent
+from langchain_core.messages import AIMessageChunk
+from langchain_openai import ChatOpenAI
+from langgraph.checkpoint.memory import MemorySaver
+
+from .callbacks import StreamCallbackHandler, StreamEvent, StreamEventType
+from .config import AgentConfig, TRANSIENT_ERROR_KEYWORDS
+
+if TYPE_CHECKING:
+    from .personas import Persona
+    from .tools import ToolRegistry
+
+
+class OpenRouterChatOpenAI(ChatOpenAI):
+    """ChatOpenAI subclass that preserves reasoning tokens from OpenRouter.
+
+    OpenRouter reasoning models (e.g. nvidia/nemotron-3-nano-omni-reasoning) return
+    a ``reasoning`` string field in the streaming delta.  LangChain's default
+    ``_convert_delta_to_message_chunk`` ignores this field, so we override
+    ``_convert_chunk_to_generation_chunk`` to inject it into
+    ``AIMessageChunk.additional_kwargs["reasoning_content"]`` after the chunk is built.
+    """
+
+    def _convert_chunk_to_generation_chunk(
+        self,
+        chunk: dict[str, Any],
+        default_chunk_class: type,
+        base_generation_info: dict[str, Any] | None,
+    ) -> Any:
+        """Build the generation chunk, then inject reasoning into additional_kwargs."""
+        result = super()._convert_chunk_to_generation_chunk(
+            chunk, default_chunk_class, base_generation_info
+        )
+        if result is None:
+            return result
+
+        # Extract reasoning from the raw delta before LangChain discards it.
+        choices = chunk.get("choices", [])
+        if choices:
+            delta = choices[0].get("delta")
+            if isinstance(delta, dict):
+                reasoning = delta.get("reasoning")
+                if reasoning and isinstance(result.message, AIMessageChunk):
+                    result.message.additional_kwargs["reasoning_content"] = reasoning
+
+        return result
+
+
+class AgentSession:
+    """Manages a single agent session with memory, streaming, and retry."""
+
+    def __init__(
+        self,
+        config: AgentConfig,
+        persona: Persona | None = None,
+        tools: ToolRegistry | None = None,
+    ) -> None:
+        from .personas import get_default_persona
+        from .tools import get_default_tools
+
+        self.config = config
+        self.persona = persona or get_default_persona(config.lang)
+        self.tools = tools or get_default_tools(config.lang)
+        self._checkpointer = MemorySaver()
+        self._thread_id = "terminal-default"
+        self._agent = self._build_agent()
+
+    def _build_agent(self) -> object:
+        """Build the LangChain agent from current config/persona/tools."""
+        llm = OpenRouterChatOpenAI(
+            api_key=self.config.api_key,
+            base_url=self.config.base_url,
+            model=self.config.model,
+            extra_body={"reasoning": {"enabled": True}},
+        )
+        system_prompt = self.persona.build_system_prompt(self.config.lang)
+        lc_tools = self.tools.get_tools()
+
+        return create_agent(
+            llm,
+            lc_tools,
+            checkpointer=self._checkpointer,
+            system_prompt=system_prompt,
+        )
+
+    async def stream(
+        self,
+        message: str,
+        *,
+        callback: object | None = None,
+    ) -> AsyncIterator[StreamEvent]:
+        """Stream an agent response as StreamEvents.
+
+        Built-in retry with exponential backoff on transient errors.
+        """
+        handler = StreamCallbackHandler(
+            show_tool_calls=True,
+            show_tool_results=False,
+        )
+
+        last_error: Exception | None = None
+        for attempt in range(self.config.max_retries):
+            try:
+                input_dict = {"messages": [{"role": "user", "content": message}]}
+                config = {"configurable": {"thread_id": self._thread_id}}
+
+                async for lc_event in self._agent.astream(
+                    input_dict,
+                    config=config,
+                    stream_mode="messages",
+                ):
+                    for stream_event in handler.process_agent_event(lc_event):
+                        if callback:
+                            await callback(stream_event)
+                        yield stream_event
+
+                yield StreamEvent(type=StreamEventType.DONE)
+                return
+
+            except Exception as e:
+                last_error = e
+                err_str = str(e).lower()
+                is_transient = any(kw in err_str for kw in TRANSIENT_ERROR_KEYWORDS)
+
+                if is_transient and attempt < self.config.max_retries - 1:
+                    delay = self.config.base_retry_delay * (2 ** attempt)
+                    delay = min(delay, self.config.max_retry_delay)
+                    yield StreamEvent(
+                        type=StreamEventType.ERROR,
+                        content=f"Retry {attempt + 1}/{self.config.max_retries}: {type(e).__name__}",
+                    )
+                    await asyncio.sleep(delay)
+                else:
+                    break
+
+        # All retries exhausted
+        yield StreamEvent(
+            type=StreamEventType.ERROR,
+            content=f"Error: {last_error}",
+        )
+        yield StreamEvent(type=StreamEventType.DONE)
+
+    async def run(self, message: str) -> str:
+        """Convenience wrapper: collect tokens and return the final answer."""
+        parts: list[str] = []
+        async for event in self.stream(message):
+            if event.type == StreamEventType.TOKEN:
+                parts.append(event.content)
+
+        # Return the longest part (final answer after potential re-generation)
+        return max(parts, key=len) if parts else ""
+
+    def switch_persona(self, persona: Persona) -> None:
+        """Switch to a different persona, clearing conversation history."""
+        self.persona = persona
+        self._checkpointer = MemorySaver()
+        self._agent = self._build_agent()
+
+    def clear_history(self) -> None:
+        """Clear conversation history (start fresh session)."""
+        self._checkpointer = MemorySaver()
+        self._agent = self._build_agent()
+
+    def rebuild(self) -> None:
+        """Rebuild agent after config change (language/model)."""
+        self._checkpointer = MemorySaver()
+        self._agent = self._build_agent()