systemr-cli 1.2.0__tar.gz → 2.0.0__tar.gz

{systemr_cli-1.2.0 → systemr_cli-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: systemr-cli
-Version: 1.2.0
+Version: 2.0.0
 Summary: System R AI — trading operating system for agents
 Author-email: System R AI <ashim@systemr.ai>
 License-Expression: MIT

{systemr_cli-1.2.0 → systemr_cli-2.0.0}/neo/__init__.py

@@ -1,3 +1,3 @@
 """System R CLI — trading operating system in your terminal."""
 
-__version__ = "1.2.0"
+__version__ = "2.0.0"

systemr_cli-2.0.0/neo/chat_runner.py

@@ -0,0 +1,293 @@
+"""Chat runner — TUI-based chat loop with fixed layout.
+
+Manages the full-screen TUI application while processing
+chat events (streaming, tools, confirmations) in the background.
+The TUI stays responsive during all operations.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Any
+
+import structlog
+
+from neo.credits import SessionCredits
+from neo.hooks import HookEvent, fire_hook
+from neo.profile import (
+    append_daily_log,
+    auto_save_rule_violation,
+    load_daily_context,
+    load_profile,
+    load_rules,
+    load_standing_orders,
+    profile_exists,
+    search_memory,
+)
+from neo.streaming import (
+    ChatRequest,
+    call_tool,
+    chat_blocking,
+    send_confirmation,
+    stream_chat,
+)
+from neo.tool_router import match_tool
+from neo.tui import ChatTUI
+
+logger = structlog.get_logger(module="chat_runner")
+
+
+async def run_chat_tui(
+    tui: ChatTUI,
+    access_token: str,
+    credits: SessionCredits,
+    store: Any,
+    db_session_id: int,
+    messages: list[dict[str, str]],
+    model: str | None = None,
+    research: bool = False,
+) -> None:
+    """Run the chat loop inside the TUI.
+
+    Alternates between waiting for user input and processing
+    the response (streaming, tool calls, etc.). The TUI handles
+    all display.
+    """
+    from neo.commands.chat_commands import (
+        COMPACTION_THRESHOLD,
+        _compact_history,
+        _handle_slash_command,
+    )
+
+    current_model = model
+
+    while True:
+        user_input = await tui.wait_for_input()
+        if user_input is None:
+            break
+        if not user_input:
+            continue
+
+        # Slash commands
+        if user_input.startswith("/"):
+            if user_input.strip() in ("/q", "/exit", "/quit"):
+                break
+            if user_input.strip() == "/clear":
+                messages.clear()
+                tui.clear_conversation()
+                tui.add_line("#3ECF8E", "  ✓ Conversation cleared.")
+                continue
+            if user_input.strip() == "/help":
+                _show_help(tui)
+                continue
+            if user_input.strip() == "/credits":
+                s = credits.summary()
+                tui.add_line("#A1A1AA", f"\n  Credits: ${s['credits_used']:.3f} used  │  {s['tools_called']} tools  │  {s['duration_min']}m")
+                continue
+            if user_input.startswith("/remember "):
+                text = user_input[10:].strip()
+                if text:
+                    from neo.profile import auto_save_explicit
+                    auto_save_explicit(text)
+                    tui.add_line("#3ECF8E", f"  ✓ Saved to memory.")
+                continue
+            if user_input.startswith("/memory "):
+                query = user_input[8:].strip()
+                if query:
+                    results = search_memory(query)
+                    if results:
+                        for r in results[:5]:
+                            tui.add_line("#A1A1AA", f"  {r}")
+                    else:
+                        tui.add_line("#52525B", "  No memories found.")
+                continue
+            # Other slash commands: pass to backend as regular chat
+            tui.add_line("#52525B", f"  Unknown command. /help for available commands.")
+            continue
+
+        store.add_chat_message(db_session_id, "user", user_input)
+        messages.append({"role": "user", "content": user_input})
+
+        # Tool pre-routing
+        tool_match_result = match_tool(user_input)
+        if tool_match_result:
+            tui.add_tool_running(tool_match_result.tool_name)
+            try:
+                tool_result = await call_tool(
+                    tool_match_result.tool_name, tool_match_result.arguments
+                )
+                result_data = tool_result.get("result", {})
+                cost = tool_result.get("cost_usdc") or (
+                    result_data.get("cost_usdc", "") if isinstance(result_data, dict) else ""
+                )
+                tui.add_tool_done(
+                    tool_match_result.tool_name,
+                    f"${cost}" if cost else "",
+                )
+                if isinstance(result_data, dict):
+                    tui.add_text("", "\n")
+                    for k, v in result_data.items():
+                        if k == "cost_usdc":
+                            continue
+                        if v is not None and str(v).strip():
+                            tui.add_line("#A1A1AA", f"  {k}: ")
+                            tui.add_text("#F5F5F5", str(v))
+                    tui.add_text("", "\n")
+                credits.add_response(credits_used=cost, tools=1)
+                reply = f"Tool {tool_match_result.tool_name}: {str(result_data)[:200]}"
+                store.add_chat_message(db_session_id, "assistant", reply)
+                messages.append({"role": "assistant", "content": reply})
+            except Exception as e:
+                err = str(e)
+                if "402" in err:
+                    tui.add_tool_error(tool_match_result.tool_name, "insufficient credits")
+                elif "401" in err or "403" in err:
+                    tui.add_tool_error(tool_match_result.tool_name, "auth required")
+                else:
+                    tui.add_tool_error(tool_match_result.tool_name, err[:60])
+            continue
+
+        # Compact history
+        if len(messages) > COMPACTION_THRESHOLD:
+            messages = _compact_history(messages)
+
+        # Build chat request
+        rules_text = load_rules() or ""
+        standing = load_standing_orders()
+        if standing and standing not in rules_text:
+            rules_text = rules_text + "\n\n" + standing if rules_text else standing
+
+        request = ChatRequest(
+            user_input=user_input,
+            session_id=str(db_session_id),
+            model=current_model,
+            history=messages,
+            profile=load_profile() or None,
+            rules=rules_text or None,
+            daily_context=load_daily_context() or None,
+            research_mode=research,
+        )
+
+        # Stream response
+        reply = await _stream_to_tui(tui, request, access_token, credits)
+
+        if reply:
+            store.add_chat_message(db_session_id, "assistant", reply)
+            messages.append({"role": "assistant", "content": reply})
+
+
+async def _stream_to_tui(
+    tui: ChatTUI,
+    request: ChatRequest,
+    access_token: str,
+    credits: SessionCredits,
+) -> str:
+    """Stream chat response into the TUI."""
+    collected_text = ""
+    tool_count = 0
+    has_trade = False
+    streaming_started = False
+    start_time = time.time()
+
+    try:
+        async for event in stream_chat(request, access_token):
+            if event.event == "thinking":
+                text = event.parsed.get("text", event.parsed.get("status", ""))
+                if text:
+                    tui.add_thinking(text[:70])
+
+            elif event.event == "action":
+                tool = event.parsed.get("action", event.parsed.get("tool", ""))
+                params = event.parsed.get("parameters", {})
+                tool_count += 1
+                if tool:
+                    fire_hook(HookEvent.BEFORE_TOOL_CALL, context={"tool": tool, "args": params})
+                    tui.add_tool_running(tool)
+                    if params:
+                        try:
+                            result = await call_tool(tool, params)
+                            data = result.get("result", {})
+                            cost = result.get("cost_usdc") or (data.get("cost_usdc", "") if isinstance(data, dict) else "")
+                            tui.add_tool_done(tool, f"${cost}" if cost else "")
+                            if isinstance(data, dict):
+                                tui.add_text("", "\n")
+                                for k, v in data.items():
+                                    if k == "cost_usdc":
+                                        continue
+                                    if v is not None and str(v).strip():
+                                        tui.add_text("#A1A1AA", f"  {k}: ")
+                                        tui.add_text("#F5F5F5", f"{v}\n")
+                        except Exception as e:
+                            tui.add_tool_error(tool, str(e)[:60])
+
+            elif event.event == "text_delta":
+                text = event.parsed.get("text", event.parsed.get("delta", ""))
+                if text and text != "null":
+                    if not streaming_started:
+                        tui.start_response()
+                        streaming_started = True
+                    tui.stream_text(text)
+                    collected_text += text
+
+            elif event.event == "done":
+                if streaming_started:
+                    elapsed = time.time() - start_time
+                    tui.end_response(elapsed)
+                elif not collected_text:
+                    full = event.parsed.get("response", event.parsed.get("content", ""))
+                    if full:
+                        collected_text = full
+                        tui.start_response()
+                        tui.stream_text(full)
+                        tui.end_response(time.time() - start_time)
+
+                credits_used = event.parsed.get("credits_used")
+                balance = event.parsed.get("balance")
+                credits.add_response(
+                    credits_used=credits_used, balance=balance,
+                    tools=tool_count, trade=has_trade,
+                )
+
+            elif event.event == "error":
+                raw = event.parsed.get("message", event.parsed.get("error", ""))
+                msg = str(raw)
+                if "Classification backend unavailable" in msg:
+                    msg = "AI model temporarily unavailable. Try again."
+                elif "AccessDeniedException" in msg:
+                    msg = "AI model access error."
+                elif len(msg) > 120:
+                    msg = msg[:120] + "..."
+                tui.add_error(msg)
+
+    except Exception as exc:
+        tui.add_error(f"Connection error: {str(exc)[:60]}")
+        logger.error("stream_error", error=str(exc))
+
+    return collected_text
+
+
+def _show_help(tui: ChatTUI) -> None:
+    """Show help in the TUI."""
+    tui.add_text("", "\n")
+    tui.add_line("#3ECF8E", "  Chat")
+    tui.add_line("#52525B", "    /morning      Morning briefing")
+    tui.add_line("#52525B", "    /eod          End of day review")
+    tui.add_line("#52525B", "    /plan         Plan today's trades")
+    tui.add_line("#52525B", "    /portfolio    Open positions")
+    tui.add_line("#52525B", "    /risk         Risk dashboard")
+    tui.add_text("", "\n")
+    tui.add_line("#3ECF8E", "  Memory")
+    tui.add_line("#52525B", "    /remember     Save a memory")
+    tui.add_line("#52525B", "    /memory       Search memories")
+    tui.add_line("#52525B", "    /sessions     Recent sessions")
+    tui.add_text("", "\n")
+    tui.add_line("#3ECF8E", "  Settings")
+    tui.add_line("#52525B", "    /model        Show or switch model")
+    tui.add_line("#52525B", "    /permissions   Safety profile")
+    tui.add_line("#52525B", "    /credits      Credit usage")
+    tui.add_text("", "\n")
+    tui.add_line("#3ECF8E", "  Session")
+    tui.add_line("#52525B", "    /clear        Clear conversation")
+    tui.add_line("#52525B", "    /q            Exit")
+    tui.add_text("", "\n")

{systemr_cli-1.2.0 → systemr_cli-2.0.0}/neo/commands/chat_commands.py

@@ -204,7 +204,8 @@ def chat(ctx: click.Context, model_name: str | None, research: bool, resume: boo
         db_session_id = store.create_chat_session()
 
     from neo.config import get_api_key
-    from neo.display.theme import print_prompt_bar
+    from neo.tui import ChatTUI
+    from neo.chat_runner import run_chat_tui
 
     # Only print banner if not already shown by _show_home_and_chat
     banner_shown = (ctx.obj or {}).get("banner_shown", False)
@@ -212,180 +213,58 @@ def chat(ctx: click.Context, model_name: str | None, research: bool, resume: boo
         print_banner()
         console.print(f"  [{GREEN}]● connected[/]")
 
-    # Session state
-    failover = load_failover_chain()
-    if model_name:
-        failover.pinned_model = model_name
-    current_model = model_name
     credits = SessionCredits()
-    history_file = SYSTEMR_HOME / "chat_history"
-    loop = asyncio.new_event_loop()
-
-    prompt_session: PromptSession[str] = PromptSession(
-        history=FileHistory(str(history_file)),
-        auto_suggest=AutoSuggestFromHistory(),
-    )
-
-    # Broker state (will be dynamic when broker connection is implemented)
-    connected_broker: str | None = None
-    display_model = current_model or "sonnet"
+    history_file = str(SYSTEMR_HOME / "chat_history")
+    display_model = model_name or "sonnet"
 
     # Fire session start hook
     fire_hook(HookEvent.PRE_SESSION, context={"model": model_name})
     logger.info("session_started", model=model_name, resume=resume)
 
-    try:
-        while True:
-            print_separator()
-            try:
-                user_input = prompt_session.prompt("  ❯ ").strip()
-            except (EOFError, KeyboardInterrupt):
-                console.print()
-                console.print(f"  [{DIM}]Session closed.[/]")
-                break
-
-            # Bottom separator + status bar
-            print_separator()
-            print_prompt_bar(model=display_model, broker=connected_broker)
-
-            if not user_input:
-                continue
-
-            # Handle slash commands
-            if user_input.startswith("/"):
-                result = _handle_slash_command(
-                    user_input, messages, current_model,
-                    access_token=token.access_token, credits=credits,
-                )
-                if result == "exit":
-                    console.print(f"\n  [{GREEN_DIM}]Session closed.[/]")
-                    break
-                if result == "clear":
-                    messages.clear()
-                    print_success("Conversation cleared.")
-                    continue
-                if result is not None:
-                    if result.startswith("model:"):
-                        current_model = result.split(":", 1)[1]
-                        failover.pinned_model = current_model
-                        print_success(f"Model: {current_model}")
-                    continue
-
-            store.add_chat_message(db_session_id, "user", user_input)
-            messages.append({"role": "user", "content": user_input})
-
-            # Tool pre-routing: detect tool-invocable requests and execute directly
-            tool_match = match_tool(user_input)
-            if tool_match:
-                render_action(tool_match.tool_name, status="running", result="")
-                try:
-                    tool_result = loop.run_until_complete(
-                        call_tool(tool_match.tool_name, tool_match.arguments)
-                    )
-                    result_data = tool_result.get("result", {})
-                    cost = tool_result.get("cost_usdc") or (
-                        result_data.get("cost_usdc", "") if isinstance(result_data, dict) else ""
-                    )
-                    render_action(
-                        tool_match.tool_name, status="done",
-                        result=f"${cost}" if cost else "done",
-                    )
+    # Create TUI and run
+    tui = ChatTUI(
+        model=display_model,
+        broker=None,
+        history_file=history_file,
+    )
 
-                    # Display results
-                    if isinstance(result_data, dict):
-                        display_items: list[str] = []
-                        for k, v in result_data.items():
-                            if k in ("cost_usdc",):
-                                continue
-                            if v is not None and str(v).strip():
-                                display_items.append(f"  [{GRAY}]{k}:[/] [{WHITE}]{v}[/]")
-                        if display_items:
-                            console.print()
-                            for item in display_items[:15]:
-                                console.print(item)
-                            console.print()
-
-                    credits.add_response(credits_used=cost, tools=1)
-                    reply = f"Tool {tool_match.tool_name} executed. Result: {json.dumps(result_data)[:200]}"
-                    store.add_chat_message(db_session_id, "assistant", reply)
-                    messages.append({"role": "assistant", "content": reply})
-
-                except Exception as tool_err:
-                    err_msg = str(tool_err)
-                    if "402" in err_msg:
-                        render_error("Insufficient credits. Run `systemr pay` to add credits.")
-                    elif "401" in err_msg or "403" in err_msg:
-                        render_error("Auth required. Run `systemr configure --api-key`.")
-                    else:
-                        render_error(f"Tool failed: {err_msg[:80]}")
-                    reply = ""
-
-                continue  # Skip chat stream — tool handled it
-
-            # Compact if over threshold
-            if len(messages) > COMPACTION_THRESHOLD:
-                messages = _compact_history(messages)
-                logger.info("context_compacted", messages=len(messages))
-
-            # Build request with profile + rules + standing orders + daily context
-            # Only send model if user explicitly chose one (via --model or /model)
-            # Backend handles default model selection via REASONING_MODEL env var
-            effective_model = current_model  # None = let backend decide
-            rules_text = load_rules() or ""
-            standing = load_standing_orders()
-            if standing and standing not in rules_text:
-                rules_text = rules_text + "\n\n" + standing if rules_text else standing
-            request = ChatRequest(
-                user_input=user_input,
-                session_id=str(db_session_id),
-                model=effective_model,
-                history=messages,
-                profile=load_profile() or None,
-                rules=rules_text or None,
-                daily_context=load_daily_context() or None,
-                research_mode=research,
+    async def _run() -> None:
+        # Start TUI in background
+        tui_task = asyncio.create_task(tui.run_async())
+        # Run chat loop
+        try:
+            await run_chat_tui(
+                tui=tui,
+                access_token=token.access_token,
+                credits=credits,
+                store=store,
+                db_session_id=db_session_id,
+                messages=messages,
+                model=model_name,
+                research=research,
             )
-
+        finally:
+            tui.exit()
             try:
-                reply = loop.run_until_complete(
-                    _do_chat(request, token.access_token, credits)
-                )
-            except Exception as exc:
-                # On failure, retry once with no model override (let backend decide)
-                if effective_model:
-                    logger.info("model_failover_retry", from_model=effective_model)
-                    request.model = None
-                    try:
-                        reply = loop.run_until_complete(
-                            _do_chat(request, token.access_token, credits)
-                        )
-                    except Exception as exc2:
-                        render_error("Something went wrong. Try again or run `systemr doctor`.")
-                        logger.error("chat_failover_error", error=str(exc2))
-                        fire_hook(HookEvent.ERROR, context={"message": str(exc2)})
-                        reply = ""
-                else:
-                    render_error("Something went wrong. Try again or run `systemr doctor`.")
-                    logger.error("chat_error", error=str(exc))
-                    fire_hook(HookEvent.ERROR, context={"message": str(exc)})
-                    reply = ""
-
-            if reply:
-                store.add_chat_message(db_session_id, "assistant", reply)
-                messages.append({"role": "assistant", "content": reply})
+                await tui_task
+            except Exception:
+                pass
 
+    try:
+        asyncio.run(_run())
+    except (KeyboardInterrupt, EOFError):
+        pass
     finally:
-        loop.close()
         _save_session(db_session_id, messages)
         fire_hook(HookEvent.POST_SESSION, context=credits.summary())
         logger.info("session_ended", **credits.summary())
 
-        # Show session summary if there was activity
+        # Show session summary
         if credits.messages_sent > 0:
             console.print()
             console.print(f"  [{GRAY}]Session summary[/]")
             s = credits.summary()
-            console.print(f"    [{WHITE}]{s['credits_used']:.1f}[/] [{DIM}]credits[/]   "  # type: ignore[str-format]
+            console.print(f"    [{WHITE}]{s['credits_used']:.1f}[/] [{DIM}]credits[/]   "
                           f"[{WHITE}]{s['tools_called']}[/] [{DIM}]tools[/]   "
                           f"[{WHITE}]{s['duration_min']}m[/] [{DIM}]duration[/]")
             console.print()

systemr_cli-2.0.0/neo/tui.py

@@ -0,0 +1,283 @@
+"""Terminal UI Application — fixed-layout chat interface.
+
+Uses prompt_toolkit's Application to create a layout with:
+- Scrollable conversation area (top)
+- Fixed separator + input + separator + status bar (bottom)
+
+This replaces the Rich console.print() approach with a proper
+TUI that supports streaming text, fixed bars, and live updates.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+import time
+from typing import Any, Callable
+
+from prompt_toolkit import Application
+from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.layout import (
+    HSplit,
+    Window,
+    FormattedTextControl,
+    BufferControl,
+    ScrollablePane,
+)
+from prompt_toolkit.layout.layout import Layout
+from prompt_toolkit.layout.dimension import Dimension
+from prompt_toolkit.formatted_text import FormattedText, HTML
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+
+# Colors matching theme.py
+GREEN = "#3ECF8E"
+GREEN_DIM = "#34B87A"
+RED = "#EF4444"
+DIM = "#52525B"
+MUTED = "#3F3F46"
+GRAY = "#A1A1AA"
+WHITE = "#F5F5F5"
+AMBER = "#F59E0B"
+BG = "#09090B"
+
+
+class ChatTUI:
+    """Fixed-layout terminal chat interface.
+
+    Layout:
+        ┌──────────────────────────────────────┐
+        │ [Scrollable conversation]             │
+        │   ◐ Thinking...                       │
+        │   ┃ Streaming response...             │
+        │   ✓ tool_name  $0.003                 │
+        ├──────────────────────────────────────┤
+        │ ❯ user input                          │
+        ├──────────────────────────────────────┤
+        │ ● sonnet │ ○ broker │ /help commands  │
+        └──────────────────────────────────────┘
+    """
+
+    def __init__(
+        self,
+        model: str = "sonnet",
+        broker: str | None = None,
+        history_file: str = "",
+        on_submit: Callable[[str], None] | None = None,
+    ) -> None:
+        self._model = model
+        self._broker = broker
+        self._on_submit = on_submit
+        self._conversation_lines: list[tuple[str, str]] = []  # (style, text) pairs
+        self._running = True
+        self._input_ready = asyncio.Event()
+        self._last_input = ""
+
+        # Conversation display
+        self._conversation_control = FormattedTextControl(
+            text=self._get_conversation_text,
+            focusable=False,
+        )
+
+        # Input buffer
+        self._input_buffer = Buffer(
+            name="input",
+            history=FileHistory(history_file) if history_file else None,
+            auto_suggest=AutoSuggestFromHistory(),
+            accept_handler=self._on_accept,
+            multiline=False,
+        )
+
+        # Separator bar
+        sep_text = FormattedText([(MUTED, "─" * 200)])
+
+        # Status bar
+        self._status_control = FormattedTextControl(
+            text=self._get_status_text,
+            focusable=False,
+        )
+
+        # Key bindings
+        kb = KeyBindings()
+
+        @kb.add("c-d")
+        def _exit(event: Any) -> None:
+            self._running = False
+            event.app.exit(result=None)
+
+        @kb.add("c-c")
+        def _cancel(event: Any) -> None:
+            self._running = False
+            event.app.exit(result=None)
+
+        # Layout
+        self._layout = Layout(
+            HSplit([
+                # Scrollable conversation
+                ScrollablePane(
+                    Window(
+                        content=self._conversation_control,
+                        wrap_lines=True,
+                    ),
+                ),
+                # Top separator
+                Window(
+                    content=FormattedTextControl(text=sep_text),
+                    height=1,
+                ),
+                # Input line
+                Window(
+                    content=BufferControl(buffer=self._input_buffer),
+                    height=1,
+                    get_line_prefix=lambda lineno, wrap: [("bold " + WHITE, "  ❯ ")],
+                ),
+                # Bottom separator
+                Window(
+                    content=FormattedTextControl(text=sep_text),
+                    height=1,
+                ),
+                # Status bar
+                Window(
+                    content=self._status_control,
+                    height=1,
+                ),
+            ]),
+            focused_element=self._input_buffer,
+        )
+
+        # Application
+        self._app: Application[str | None] = Application(
+            layout=self._layout,
+            key_bindings=kb,
+            full_screen=True,
+            mouse_support=False,
+            style=None,
+        )
+
+    def _on_accept(self, buffer: Buffer) -> bool:
+        """Handle Enter press in input buffer."""
+        self._last_input = buffer.text.strip()
+        self._input_ready.set()
+        return False  # Don't keep text in buffer
+
+    def _get_conversation_text(self) -> FormattedText:
+        """Render conversation lines as FormattedText."""
+        if not self._conversation_lines:
+            return FormattedText([(DIM, "  Type your message below. /help for commands.\n")])
+        return FormattedText(self._conversation_lines)
+
+    def _get_status_text(self) -> FormattedText:
+        """Render status bar."""
+        parts: list[tuple[str, str]] = [("", "  ")]
+        parts.append((GREEN, "● "))
+        parts.append((DIM, self._model))
+        parts.append((MUTED, "  │  "))
+        if self._broker:
+            parts.append((GREEN, "● "))
+            parts.append((DIM, self._broker))
+        else:
+            parts.append((RED, "○ "))
+            parts.append((DIM, "broker not connected"))
+        parts.append((MUTED, "  │  "))
+        parts.append((DIM, "/help commands"))
+        return FormattedText(parts)
+
+    # ── Public API for streaming content ──
+
+    def add_line(self, style: str, text: str) -> None:
+        """Add a line to the conversation area."""
+        self._conversation_lines.append((style, text + "\n"))
+        self._invalidate()
+
+    def add_text(self, style: str, text: str) -> None:
+        """Add inline text (no newline) for streaming."""
+        self._conversation_lines.append((style, text))
+        self._invalidate()
+
+    def add_thinking(self, text: str) -> None:
+        """Show thinking status."""
+        self.add_line(DIM, f"  ◐ {text}")
+
+    def add_tool_running(self, name: str) -> None:
+        """Show tool starting."""
+        self.add_line(DIM, f"  ◐ {name}...")
+
+    def add_tool_done(self, name: str, cost: str = "") -> None:
+        """Show tool completed."""
+        suffix = f"  {cost}" if cost else ""
+        self.add_line(GREEN, f"  ✓ {name}{suffix}")
+
+    def add_tool_error(self, name: str, error: str = "") -> None:
+        """Show tool error."""
+        suffix = f"  {error}" if error else ""
+        self.add_line(RED, f"  ✗ {name}{suffix}")
+
+    def add_error(self, msg: str) -> None:
+        """Show error message."""
+        self.add_line(RED, f"  ✗ {msg}")
+
+    def start_response(self) -> None:
+        """Start a new response block with green border."""
+        self.add_text(GREEN, "\n  ┃ ")
+
+    def stream_text(self, text: str) -> None:
+        """Stream text within a response block."""
+        for ch in text:
+            if ch == "\n":
+                self.add_text(GREEN, "\n  ┃ ")
+            else:
+                self.add_text("", ch)
+        self._invalidate()
+
+    def end_response(self, elapsed: float) -> None:
+        """End response block with timing."""
+        self.add_text(GREEN, "\n  ┃")
+        self.add_line(DIM, f"\n  ✦ {elapsed:.1f}s\n")
+
+    def add_result_row(self, key: str, value: str) -> None:
+        """Add a key-value result row."""
+        self.add_line("", f"  {key}: ")
+        self.add_text(WHITE, value)
+
+    def set_model(self, model: str) -> None:
+        """Update model in status bar."""
+        self._model = model
+        self._invalidate()
+
+    def set_broker(self, broker: str | None) -> None:
+        """Update broker in status bar."""
+        self._broker = broker
+        self._invalidate()
+
+    def clear_conversation(self) -> None:
+        """Clear conversation area."""
+        self._conversation_lines.clear()
+        self._invalidate()
+
+    def _invalidate(self) -> None:
+        """Request UI redraw."""
+        if self._app and self._app.is_running:
+            self._app.invalidate()
+
+    async def wait_for_input(self) -> str | None:
+        """Wait for user to submit input. Returns None on exit."""
+        self._input_ready.clear()
+        self._input_buffer.text = ""
+        self._invalidate()
+
+        await self._input_ready.wait()
+
+        if not self._running:
+            return None
+        return self._last_input
+
+    async def run_async(self) -> None:
+        """Start the TUI application."""
+        await self._app.run_async()
+
+    def exit(self) -> None:
+        """Exit the application."""
+        self._running = False
+        if self._app.is_running:
+            self._app.exit()

{systemr_cli-1.2.0 → systemr_cli-2.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "systemr-cli"
-version = "1.2.0"
+version = "2.0.0"
 description = "System R AI — trading operating system for agents"
 readme = "README.md"
 license = "MIT"