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

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

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

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

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

{systemr_cli-2.0.0 → systemr_cli-2.1.1}/neo/chat_runner.py

@@ -190,6 +190,8 @@ async def _stream_to_tui(
     streaming_started = False
     start_time = time.time()
 
+    tui.set_processing(True)
+
     try:
         async for event in stream_chat(request, access_token):
             if event.event == "thinking":
@@ -248,6 +250,11 @@ async def _stream_to_tui(
                     credits_used=credits_used, balance=balance,
                     tools=tool_count, trade=has_trade,
                 )
+                if credits_used:
+                    try:
+                        tui.add_credits(float(credits_used))
+                    except (ValueError, TypeError):
+                        pass
 
             elif event.event == "error":
                 raw = event.parsed.get("message", event.parsed.get("error", ""))
@@ -263,6 +270,8 @@ async def _stream_to_tui(
     except Exception as exc:
         tui.add_error(f"Connection error: {str(exc)[:60]}")
         logger.error("stream_error", error=str(exc))
+    finally:
+        tui.set_processing(False)
 
     return collected_text
 

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

@@ -138,7 +138,7 @@ async def _pipe_mode(token, user_input: str, model_name: str | None, research: b
     text_parts: list[str] = []
     tools_used: list[str] = []
 
-    async for event in stream_chat(token.access_token, request):
+    async for event in stream_chat(request, token.access_token):
         if event.event == "text_delta" and event.data:
             text_parts.append(event.data.get("text", ""))
         elif event.event == "action" and event.data:

{systemr_cli-2.0.0 → systemr_cli-2.1.1}/neo/tui.py

@@ -1,17 +1,22 @@
 """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.
+Full-screen prompt_toolkit Application with:
+- Scrollable conversation area (top) with auto-scroll
+- Fixed separator + input prompt (middle)
+- Fixed separator + live status bar (bottom)
+
+Keyboard shortcuts:
+- Enter: submit message
+- Ctrl+D / Ctrl+C: exit
+- Ctrl+L: clear conversation
+- Page Up/Down: scroll conversation
+- Up/Down: input history
+- Escape: cancel current input
 """
 
 from __future__ import annotations
 
 import asyncio
-import sys
 import time
 from typing import Any, Callable
 
@@ -27,11 +32,12 @@ from prompt_toolkit.layout import (
 )
 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.formatted_text import FormattedText
 from prompt_toolkit.history import FileHistory
 from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+from prompt_toolkit.styles import Style
 
-# Colors matching theme.py
+# ── Colors (match theme.py) ──
 GREEN = "#3ECF8E"
 GREEN_DIM = "#34B87A"
 RED = "#EF4444"
@@ -41,6 +47,25 @@ GRAY = "#A1A1AA"
 WHITE = "#F5F5F5"
 AMBER = "#F59E0B"
 BG = "#09090B"
+BG_INPUT = "#111114"
+
+# ── Prompt toolkit style ──
+TUI_STYLE = Style.from_dict({
+    # Conversation area
+    "conversation": f"bg:{BG} {GRAY}",
+    # Input area
+    "input-prompt": f"bold {WHITE}",
+    # Separators
+    "separator": MUTED,
+    # Status bar
+    "status": f"bg:{BG_INPUT} {DIM}",
+    "status.green": GREEN,
+    "status.red": RED,
+    "status.dim": DIM,
+    "status.muted": MUTED,
+    # Auto-suggest
+    "auto-suggest": DIM,
+})
 
 
 class ChatTUI:
@@ -55,7 +80,7 @@ class ChatTUI:
         ├──────────────────────────────────────┤
         │ ❯ user input                          │
         ├──────────────────────────────────────┤
-        │ ● sonnet │ ○ broker │ /help commands  │
+        │ ● sonnet │ ○ broker │ /help  │ 2m 3s │
         └──────────────────────────────────────┘
     """
 
@@ -64,15 +89,17 @@ class ChatTUI:
         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._conversation_lines: list[tuple[str, str]] = []
         self._running = True
         self._input_ready = asyncio.Event()
         self._last_input = ""
+        self._credits_used: float = 0.0
+        self._tools_called: int = 0
+        self._start_time = time.time()
+        self._processing = False
 
         # Conversation display
         self._conversation_control = FormattedTextControl(
@@ -80,6 +107,12 @@ class ChatTUI:
             focusable=False,
         )
 
+        # Scrollable conversation window
+        self._conversation_window = Window(
+            content=self._conversation_control,
+            wrap_lines=True,
+        )
+
         # Input buffer
         self._input_buffer = Buffer(
             name="input",
@@ -89,8 +122,11 @@ class ChatTUI:
             multiline=False,
         )
 
-        # Separator bar
-        sep_text = FormattedText([(MUTED, "─" * 200)])
+        # Separator
+        self._sep_control = FormattedTextControl(
+            text=lambda: FormattedText([(MUTED, "─" * 300)]),
+            focusable=False,
+        )
 
         # Status bar
         self._status_control = FormattedTextControl(
@@ -104,44 +140,49 @@ class ChatTUI:
         @kb.add("c-d")
         def _exit(event: Any) -> None:
             self._running = False
+            self._input_ready.set()
             event.app.exit(result=None)
 
         @kb.add("c-c")
-        def _cancel(event: Any) -> None:
-            self._running = False
-            event.app.exit(result=None)
+        def _interrupt(event: Any) -> None:
+            if self._processing:
+                # During processing: just signal (future: cancel stream)
+                pass
+            else:
+                self._running = False
+                self._input_ready.set()
+                event.app.exit(result=None)
+
+        @kb.add("c-l")
+        def _clear_screen(event: Any) -> None:
+            self._conversation_lines.clear()
+            self._invalidate()
+
+        @kb.add("escape")
+        def _cancel_input(event: Any) -> None:
+            self._input_buffer.text = ""
 
         # Layout
         self._layout = Layout(
             HSplit([
-                # Scrollable conversation
+                # Scrollable conversation (takes all available space)
                 ScrollablePane(
-                    Window(
-                        content=self._conversation_control,
-                        wrap_lines=True,
-                    ),
+                    self._conversation_window,
                 ),
                 # Top separator
-                Window(
-                    content=FormattedTextControl(text=sep_text),
-                    height=1,
-                ),
-                # Input line
+                Window(content=self._sep_control, height=1),
+                # Input line with ❯ prefix
                 Window(
                     content=BufferControl(buffer=self._input_buffer),
                     height=1,
-                    get_line_prefix=lambda lineno, wrap: [("bold " + WHITE, "  ❯ ")],
+                    get_line_prefix=lambda lineno, wrap: FormattedText(
+                        [("bold " + WHITE, "  ❯ ")]
+                    ),
                 ),
                 # Bottom separator
-                Window(
-                    content=FormattedTextControl(text=sep_text),
-                    height=1,
-                ),
+                Window(content=self._sep_control, height=1),
                 # Status bar
-                Window(
-                    content=self._status_control,
-                    height=1,
-                ),
+                Window(content=self._status_control, height=1),
             ]),
             focused_element=self._input_buffer,
         )
@@ -151,94 +192,152 @@ class ChatTUI:
             layout=self._layout,
             key_bindings=kb,
             full_screen=True,
-            mouse_support=False,
-            style=None,
+            mouse_support=True,
+            style=TUI_STYLE,
         )
 
+    # ── Internal handlers ──
+
     def _on_accept(self, buffer: Buffer) -> bool:
-        """Handle Enter press in input buffer."""
-        self._last_input = buffer.text.strip()
+        """Handle Enter press."""
+        text = buffer.text.strip()
+        if text:
+            # Echo user input in conversation
+            self._conversation_lines.append((WHITE, f"\n  ❯ {text}\n"))
+        self._last_input = text
         self._input_ready.set()
-        return False  # Don't keep text in buffer
+        return False
 
     def _get_conversation_text(self) -> FormattedText:
-        """Render conversation lines as FormattedText."""
+        """Render conversation area."""
         if not self._conversation_lines:
-            return FormattedText([(DIM, "  Type your message below. /help for commands.\n")])
+            return FormattedText([
+                (DIM, "\n"),
+                (DIM, "  Type your message below.\n"),
+                (DIM, "  /help for commands. Ctrl+D to exit.\n"),
+            ])
         return FormattedText(self._conversation_lines)
 
     def _get_status_text(self) -> FormattedText:
-        """Render status bar."""
+        """Render status bar with live data."""
+        elapsed = int(time.time() - self._start_time)
+        mins, secs = divmod(elapsed, 60)
+        time_str = f"{mins}m {secs}s" if mins else f"{secs}s"
+
         parts: list[tuple[str, str]] = [("", "  ")]
+
+        # Model
         parts.append((GREEN, "● "))
         parts.append((DIM, self._model))
         parts.append((MUTED, "  │  "))
+
+        # Broker
         if self._broker:
             parts.append((GREEN, "● "))
             parts.append((DIM, self._broker))
         else:
             parts.append((RED, "○ "))
-            parts.append((DIM, "broker not connected"))
+            parts.append((DIM, "no broker"))
         parts.append((MUTED, "  │  "))
-        parts.append((DIM, "/help commands"))
+
+        # Stats
+        if self._tools_called > 0:
+            parts.append((DIM, f"{self._tools_called} tools"))
+            parts.append((MUTED, "  │  "))
+
+        if self._credits_used > 0:
+            parts.append((DIM, f"${self._credits_used:.3f}"))
+            parts.append((MUTED, "  │  "))
+
+        # Timer
+        parts.append((DIM, time_str))
+        parts.append((MUTED, "  │  "))
+
+        # Help hint
+        parts.append((DIM, "/help"))
+
         return FormattedText(parts)
 
-    # ── Public API for streaming content ──
+    # ── Public API ──
 
     def add_line(self, style: str, text: str) -> None:
-        """Add a line to the conversation area."""
+        """Add a line to conversation."""
         self._conversation_lines.append((style, text + "\n"))
-        self._invalidate()
+        self._scroll_to_bottom()
 
     def add_text(self, style: str, text: str) -> None:
         """Add inline text (no newline) for streaming."""
         self._conversation_lines.append((style, text))
-        self._invalidate()
+        self._scroll_to_bottom()
 
     def add_thinking(self, text: str) -> None:
-        """Show thinking status."""
-        self.add_line(DIM, f"  ◐ {text}")
+        """Show thinking status. Replaces previous thinking line."""
+        # Remove previous thinking line if exists
+        if (self._conversation_lines and
+                self._conversation_lines[-1][1].startswith("  ◐")):
+            self._conversation_lines.pop()
+        self._conversation_lines.append((DIM, f"  ◐ {text}\n"))
+        self._scroll_to_bottom()
+
+    def clear_thinking(self) -> None:
+        """Remove the current thinking line."""
+        if (self._conversation_lines and
+                self._conversation_lines[-1][1].strip().startswith("◐")):
+            self._conversation_lines.pop()
+            self._invalidate()
 
     def add_tool_running(self, name: str) -> None:
         """Show tool starting."""
+        self.clear_thinking()
         self.add_line(DIM, f"  ◐ {name}...")
 
     def add_tool_done(self, name: str, cost: str = "") -> None:
         """Show tool completed."""
+        # Replace running line
+        if (self._conversation_lines and
+                "◐" in self._conversation_lines[-1][1]):
+            self._conversation_lines.pop()
         suffix = f"  {cost}" if cost else ""
         self.add_line(GREEN, f"  ✓ {name}{suffix}")
+        self._tools_called += 1
 
     def add_tool_error(self, name: str, error: str = "") -> None:
         """Show tool error."""
+        if (self._conversation_lines and
+                "◐" in self._conversation_lines[-1][1]):
+            self._conversation_lines.pop()
         suffix = f"  {error}" if error else ""
         self.add_line(RED, f"  ✗ {name}{suffix}")
 
     def add_error(self, msg: str) -> None:
         """Show error message."""
+        self.clear_thinking()
         self.add_line(RED, f"  ✗ {msg}")
 
     def start_response(self) -> None:
         """Start a new response block with green border."""
+        self.clear_thinking()
         self.add_text(GREEN, "\n  ┃ ")
 
     def stream_text(self, text: str) -> None:
-        """Stream text within a response block."""
+        """Stream text within a response block, char by char."""
         for ch in text:
             if ch == "\n":
-                self.add_text(GREEN, "\n  ┃ ")
+                self._conversation_lines.append((GREEN, "\n  ┃ "))
             else:
-                self.add_text("", ch)
-        self._invalidate()
+                self._conversation_lines.append(("", ch))
+        self._scroll_to_bottom()
 
     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")
+        self.add_line(DIM, f"\n  ✦ {elapsed:.1f}s")
+        self.add_text("", "\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 add_credits(self, amount: float) -> None:
+        """Track credits used (updates status bar)."""
+        self._credits_used += amount
+        self._invalidate()
 
     def set_model(self, model: str) -> None:
         """Update model in status bar."""
@@ -250,11 +349,20 @@ class ChatTUI:
         self._broker = broker
         self._invalidate()
 
+    def set_processing(self, active: bool) -> None:
+        """Set processing state (affects Ctrl+C behavior)."""
+        self._processing = active
+        self._invalidate()
+
     def clear_conversation(self) -> None:
         """Clear conversation area."""
         self._conversation_lines.clear()
         self._invalidate()
 
+    def _scroll_to_bottom(self) -> None:
+        """Scroll conversation to bottom and redraw."""
+        self._invalidate()
+
     def _invalidate(self) -> None:
         """Request UI redraw."""
         if self._app and self._app.is_running:
@@ -264,12 +372,14 @@ class ChatTUI:
         """Wait for user to submit input. Returns None on exit."""
         self._input_ready.clear()
         self._input_buffer.text = ""
+        self._processing = False
         self._invalidate()
 
         await self._input_ready.wait()
 
         if not self._running:
             return None
+        self._processing = True
         return self._last_input
 
     async def run_async(self) -> None:
@@ -279,5 +389,6 @@ class ChatTUI:
     def exit(self) -> None:
         """Exit the application."""
         self._running = False
+        self._input_ready.set()
         if self._app.is_running:
             self._app.exit()

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

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