emdash-cli 0.1.4__py3-none-any.whl → 0.1.25__py3-none-any.whl

emdash_cli/sse_renderer.py

@@ -3,6 +3,7 @@
 import json
 import sys
 import time
+import threading
 from typing import Iterator, Optional
 
 from rich.console import Console
@@ -41,6 +42,7 @@ class SSERenderer:
         self._session_id = None
         self._spec = None
         self._spec_submitted = False
+        self._plan_submitted = None  # Plan data when submit_plan tool is called
         self._pending_clarification = None
 
         # Live display state
@@ -54,62 +56,126 @@ class SSERenderer:
         self._subagent_tool_count = 0
         self._subagent_current_tool = None
 
-    def render_stream(self, lines: Iterator[str]) -> dict:
+        # Spinner animation thread
+        self._spinner_thread: Optional[threading.Thread] = None
+        self._spinner_running = False
+        self._spinner_message = "thinking"
+        self._spinner_lock = threading.Lock()
+
+        # Extended thinking storage
+        self._last_thinking: Optional[str] = None
+
+    def render_stream(
+        self,
+        lines: Iterator[str],
+        interrupt_event: Optional[threading.Event] = None,
+    ) -> dict:
         """Render SSE stream to terminal.
 
         Args:
             lines: Iterator of SSE lines from HTTP response
+            interrupt_event: Optional event to signal interruption (e.g., ESC pressed)
 
         Returns:
-            Dict with session_id, content, spec, and other metadata
+            Dict with session_id, content, spec, interrupted flag, and other metadata
         """
         current_event = None
         final_response = ""
-
-        for line in lines:
-            line = line.strip()
-
-            if line.startswith("event: "):
-                current_event = line[7:]
-            elif line.startswith("data: "):
-                try:
-                    data = json.loads(line[6:])
-                    # Ensure data is a dict (could be null/None from JSON)
-                    if data is None:
-                        data = {}
-                    if current_event:
-                        result = self._handle_event(current_event, data)
-                        if result:
-                            final_response = result
-                except json.JSONDecodeError:
-                    pass
-            elif line == ": ping":
-                # SSE keep-alive - show loading if waiting
-                if self._waiting_for_next and self.verbose:
-                    self._show_waiting()
+        interrupted = False
+        self._last_thinking = None  # Reset thinking storage
+
+        # Start spinner while waiting for first event
+        if self.verbose:
+            self._start_spinner("thinking")
+
+        try:
+            for line in lines:
+                # Check for interrupt signal
+                if interrupt_event and interrupt_event.is_set():
+                    self._stop_spinner()
+                    self.console.print("\n[yellow]Interrupted[/yellow]")
+                    interrupted = True
+                    break
+
+                line = line.strip()
+
+                if line.startswith("event: "):
+                    current_event = line[7:]
+                elif line.startswith("data: "):
+                    try:
+                        data = json.loads(line[6:])
+                        # Ensure data is a dict (could be null/None from JSON)
+                        if data is None:
+                            data = {}
+                        if current_event:
+                            result = self._handle_event(current_event, data)
+                            if result:
+                                final_response = result
+                    except json.JSONDecodeError:
+                        pass
+                elif line == ": ping":
+                    # SSE keep-alive - ensure spinner is running
+                    if self.verbose and not self._spinner_running:
+                        self._start_spinner("waiting")
+        finally:
+            # Always stop spinner when stream ends
+            self._stop_spinner()
 
         return {
             "content": final_response,
             "session_id": self._session_id,
             "spec": self._spec,
             "spec_submitted": self._spec_submitted,
+            "plan_submitted": self._plan_submitted,
             "clarification": self._pending_clarification,
+            "interrupted": interrupted,
+            "thinking": self._last_thinking,
         }
 
+    def _start_spinner(self, message: str = "thinking") -> None:
+        """Start the animated spinner in a background thread."""
+        if self._spinner_running:
+            return
+
+        self._spinner_message = message
+        self._spinner_running = True
+        self._spinner_thread = threading.Thread(target=self._spinner_loop, daemon=True)
+        self._spinner_thread.start()
+
+    def _stop_spinner(self) -> None:
+        """Stop the spinner and clear the line."""
+        if not self._spinner_running:
+            return
+
+        self._spinner_running = False
+        if self._spinner_thread:
+            self._spinner_thread.join(timeout=0.2)
+            self._spinner_thread = None
+
+        # Clear the spinner line
+        with self._spinner_lock:
+            sys.stdout.write("\r" + " " * 60 + "\r")
+            sys.stdout.flush()
+
+    def _spinner_loop(self) -> None:
+        """Background thread that animates the spinner."""
+        while self._spinner_running:
+            with self._spinner_lock:
+                self._spinner_idx = (self._spinner_idx + 1) % len(SPINNER_FRAMES)
+                spinner = SPINNER_FRAMES[self._spinner_idx]
+                sys.stdout.write(f"\r  \033[33m{spinner}\033[0m \033[2m{self._spinner_message}...\033[0m")
+                sys.stdout.flush()
+            time.sleep(0.1)
+
     def _show_waiting(self) -> None:
-        """Show waiting animation."""
-        self._spinner_idx = (self._spinner_idx + 1) % len(SPINNER_FRAMES)
-        spinner = SPINNER_FRAMES[self._spinner_idx]
-        # Use carriage return to update in place
-        sys.stdout.write(f"\r  [dim]{spinner}[/dim] waiting...")
-        sys.stdout.flush()
+        """Show waiting animation (starts spinner if not running)."""
+        if not self._spinner_running:
+            self._start_spinner("waiting")
 
     def _clear_waiting(self) -> None:
-        """Clear waiting line."""
-        if self._waiting_for_next:
-            sys.stdout.write("\r" + " " * 40 + "\r")
-            sys.stdout.flush()
-            self._waiting_for_next = False
+        """Clear waiting line (stops spinner)."""
+        self._stop_spinner()
+        self._waiting_for_next = False
 
     def _handle_event(self, event_type: str, data: dict) -> Optional[str]:
         """Handle individual SSE event."""
@@ -126,8 +192,10 @@ class SSERenderer:
             self._render_tool_start(data)
         elif event_type == "tool_result":
             self._render_tool_result(data)
-            # Set waiting for next tool/response
+            # Start spinner while waiting for next tool/response
             self._waiting_for_next = True
+            if self.verbose:
+                self._start_spinner("thinking")
         elif event_type == "thinking":
             self._render_thinking(data)
         elif event_type == "progress":
@@ -138,12 +206,16 @@ class SSERenderer:
             return self._render_response(data)
         elif event_type == "clarification":
             self._render_clarification(data)
+        elif event_type == "plan_submitted":
+            self._render_plan_submitted(data)
         elif event_type == "error":
             self._render_error(data)
         elif event_type == "warning":
             self._render_warning(data)
         elif event_type == "session_end":
             self._render_session_end(data)
+        elif event_type == "context_frame":
+            self._render_context_frame(data)
 
         return None
 
@@ -231,6 +303,10 @@ class SSERenderer:
         description = args.get("description", "")
         prompt = args.get("prompt", "")
 
+        # Reset sub-agent tracking
+        self._subagent_tool_count = 0
+        self._subagent_current_tool = None
+
         # Truncate prompt for display
         prompt_display = prompt[:60] + "..." if len(prompt) > 60 else prompt
 
@@ -304,6 +380,10 @@ class SSERenderer:
         success = data.get("success", True)
         result_data = data.get("data") or {}
 
+        # Clear the progress line
+        sys.stdout.write(f"\r{' ' * 120}\r")
+        sys.stdout.flush()
+
         # Calculate duration
         duration = ""
         if self._current_tool and self._current_tool.get("start_time"):
@@ -313,20 +393,20 @@ class SSERenderer:
         if success:
             agent_type = result_data.get("agent_type", "Agent")
             iterations = result_data.get("iterations", 0)
-            tools_used = result_data.get("tools_used", [])
             files_count = len(result_data.get("files_explored", []))
 
             self.console.print(
                 f"    [green]✓[/green] {agent_type} completed{duration}"
             )
-            if iterations > 0 or files_count > 0:
-                stats = []
-                if iterations > 0:
-                    stats.append(f"{iterations} turns")
-                if files_count > 0:
-                    stats.append(f"{files_count} files")
-                if tools_used:
-                    stats.append(f"{len(tools_used)} tools")
+            # Show stats using our tracked tool count
+            stats = []
+            if iterations > 0:
+                stats.append(f"{iterations} turns")
+            if files_count > 0:
+                stats.append(f"{files_count} files")
+            if self._subagent_tool_count > 0:
+                stats.append(f"{self._subagent_tool_count} tools")
+            if stats:
                 self.console.print(f"    [dim]{' · '.join(stats)}[/dim]")
         else:
             error = result_data.get("error", data.get("summary", "failed"))
@@ -334,6 +414,7 @@ class SSERenderer:
 
         self.console.print()
         self._current_tool = None
+        self._subagent_tool_count = 0
 
     def _format_args_summary(self, args: dict) -> str:
         """Format args into a compact summary string."""
@@ -350,12 +431,32 @@ class SSERenderer:
         return " ".join(parts)
 
     def _render_thinking(self, data: dict) -> None:
-        """Render thinking event."""
+        """Render thinking event.
+
+        Handles both short progress messages and extended thinking content.
+        """
         if not self.verbose:
             return
 
         message = data.get("message", "")
-        self.console.print(f"  [dim]┃[/dim] [dim italic]💭 {message}[/dim italic]")
+
+        # Check if this is extended thinking (long content) vs short progress message
+        if len(message) > 200:
+            # Extended thinking - show summary with collapsible indicator
+            self._stop_spinner()
+            lines = message.strip().split("\n")
+            preview = lines[0][:80] + "..." if len(lines[0]) > 80 else lines[0]
+            line_count = len(lines)
+            char_count = len(message)
+
+            self.console.print(f"  [dim]┃[/dim] [dim italic]💭 Thinking ({char_count:,} chars, {line_count} lines)[/dim italic]")
+            self.console.print(f"  [dim]┃[/dim] [dim]   {preview}[/dim]")
+
+            # Store thinking for potential later display
+            self._last_thinking = message
+        else:
+            # Short progress message
+            self.console.print(f"  [dim]┃[/dim] [dim italic]💭 {message}[/dim italic]")
 
     def _render_progress(self, data: dict) -> None:
         """Render progress event."""
@@ -414,6 +515,67 @@ class SSERenderer:
         else:
             self._pending_clarification = None
 
+    def _render_plan_submitted(self, data: dict) -> None:
+        """Render plan submission event and store for menu display."""
+        from rich.panel import Panel
+        from rich.table import Table
+        from rich.text import Text
+
+        title = data.get("title", "Plan")
+        summary = data.get("summary", "")
+        files_to_modify = data.get("files_to_modify", [])
+        implementation_steps = data.get("implementation_steps", [])
+        risks = data.get("risks", [])
+        testing_strategy = data.get("testing_strategy", "")
+
+        # Store the plan data for the CLI to show the menu
+        self._plan_submitted = data
+
+        # Build plan display
+        self.console.print()
+        self.console.print(Panel(
+            f"[bold]{title}[/bold]\n\n{summary}",
+            title="[cyan]📋 Plan[/cyan]",
+            border_style="cyan",
+        ))
+
+        # Critical Files table (always shown)
+        if files_to_modify:
+            files_table = Table(title="Critical Files", show_header=True, header_style="bold cyan")
+            files_table.add_column("File", style="yellow")
+            files_table.add_column("Lines", style="dim")
+            files_table.add_column("Changes", style="white")
+
+            for f in files_to_modify:
+                if isinstance(f, dict):
+                    files_table.add_row(
+                        f.get("path", ""),
+                        f.get("lines", ""),
+                        f.get("changes", "")
+                    )
+                else:
+                    files_table.add_row(str(f), "", "")
+
+            self.console.print(files_table)
+
+        # Implementation Steps (only if provided)
+        if implementation_steps:
+            self.console.print("\n[bold cyan]Implementation Steps[/bold cyan]")
+            for i, step in enumerate(implementation_steps, 1):
+                self.console.print(f"  [dim]{i}.[/dim] {step}")
+
+        # Risks (only if provided)
+        if risks:
+            self.console.print("\n[bold yellow]⚠ Risks[/bold yellow]")
+            for risk in risks:
+                self.console.print(f"  [yellow]•[/yellow] {risk}")
+
+        # Testing (only if provided)
+        if testing_strategy:
+            self.console.print(f"\n[bold green]Testing:[/bold green] {testing_strategy}")
+
+        self.console.print()
+
     def _render_error(self, data: dict) -> None:
         """Render error event."""
         message = data.get("message", "Unknown error")
@@ -438,5 +600,59 @@ class SSERenderer:
         if not success:
             error = data.get("error", "Unknown error")
             self.console.print(f"\n[red]Session ended with error: {error}[/red]")
-        elif self._tool_count > 0:
-            self.console.print(f"\n[dim]───── {self._tool_count} tools ─────[/dim]")
+
+    def _render_context_frame(self, data: dict) -> None:
+        """Render context frame update (post-agentic loop summary)."""
+        adding = data.get("adding") or {}
+        reading = data.get("reading") or {}
+
+        # Get stats from the adding data
+        step_count = adding.get("step_count", 0)
+        entities_found = adding.get("entities_found", 0)
+        context_tokens = adding.get("context_tokens", 0)
+        context_breakdown = adding.get("context_breakdown", {})
+        largest_messages = adding.get("largest_messages", [])
+
+        # Get reading stats
+        item_count = reading.get("item_count", 0)
+
+        # Only show if there's something to report
+        if step_count == 0 and item_count == 0 and context_tokens == 0:
+            return
+
+        self.console.print()
+        self.console.print("[dim]───── Context Frame ─────[/dim]")
+
+        # Show total context
+        if context_tokens > 0:
+            self.console.print(f"  [bold]Total: {context_tokens:,} tokens[/bold]")
+
+        # Show breakdown
+        if context_breakdown:
+            breakdown_parts = []
+            for key, tokens in context_breakdown.items():
+                if tokens > 0:
+                    breakdown_parts.append(f"{key}: {tokens:,}")
+            if breakdown_parts:
+                self.console.print(f"  [dim]Breakdown: {' | '.join(breakdown_parts)}[/dim]")
+
+        # Show largest messages (context hogs)
+        if largest_messages:
+            self.console.print(f"  [yellow]Largest messages:[/yellow]")
+            for msg in largest_messages[:5]:
+                label = msg.get("label", "unknown")
+                tokens = msg.get("tokens", 0)
+                preview = msg.get("preview", "")[:50].replace("\n", " ")
+                self.console.print(f"    [dim]{tokens:,} tokens[/dim] - {label}: {preview}...")
+
+        # Show other stats
+        stats = []
+        if step_count > 0:
+            stats.append(f"{step_count} steps")
+        if entities_found > 0:
+            stats.append(f"{entities_found} entities")
+        if item_count > 0:
+            stats.append(f"{item_count} context items")
+
+        if stats:
+            self.console.print(f"  [dim]{' · '.join(stats)}[/dim]")

{emdash_cli-0.1.4.dist-info → emdash_cli-0.1.25.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emdash-cli
-Version: 0.1.4
+Version: 0.1.25
 Summary: EmDash CLI - Command-line interface for code intelligence
 Author: Em Dash Team
 Requires-Python: >=3.10,<4.0
@@ -11,7 +11,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: click (>=8.1.7,<9.0.0)
-Requires-Dist: emdash-core (>=0.1.4)
+Requires-Dist: emdash-core (>=0.1.25)
 Requires-Dist: httpx (>=0.25.0)
 Requires-Dist: prompt_toolkit (>=3.0.43,<4.0.0)
 Requires-Dist: rich (>=13.7.0)

{emdash_cli-0.1.4.dist-info → emdash_cli-0.1.25.dist-info}/RECORD

@@ -1,26 +1,28 @@
-emdash_cli/__init__.py,sha256=q-eC58WAvKd48CbdQVJ5kSGA86_V18JmkE1qXkjEyjw,88
-emdash_cli/client.py,sha256=7eWchJugC4xtKs8Ob63_kJMdnjyoN3be_1qP8qMujZE,16275
-emdash_cli/commands/__init__.py,sha256=zf0lQ6S1UgoIg6NS7Oehxnb3iGD0Wxai0QU1nobgi9U,671
-emdash_cli/commands/agent.py,sha256=HAz9exNc2iXiNu5OBJJRJrTKS1z31lkdDzVcIpfItAg,29618
+emdash_cli/__init__.py,sha256=Rnn2O7B8OCEKlVtNRbWOU2-GN75_KLmhEJgOZzY-KwE,232
+emdash_cli/client.py,sha256=sPgX2CEfiHc4TXN9TYqFhc8DVKgPyk20Efm66KQAOhE,16761
+emdash_cli/commands/__init__.py,sha256=D9edXBHm69tueUtE4DggTA1_Yjsl9YZaKjBVDY2D_gQ,712
+emdash_cli/commands/agent.py,sha256=RCgSYW6OBx3UFGVAM_byhyrtBKlsXN2xfJaT3w51uDY,27735
 emdash_cli/commands/analyze.py,sha256=c9ztbv0Ra7g2AlDmMOy-9L51fDVuoqbuzxnRfomoFIQ,4403
 emdash_cli/commands/auth.py,sha256=SpWdqO1bJCgt4x1B4Pr7hNOucwTuBFJ1oGPOzXtvwZM,3816
 emdash_cli/commands/db.py,sha256=nZK7gLDVE2lAQVYrMx6Swscml5OAtkbg-EcSNSvRIlA,2922
 emdash_cli/commands/embed.py,sha256=kqP5jtYCsZ2_s_I1DjzIUgaod1VUvPiRO0jIIY0HtCs,3244
-emdash_cli/commands/index.py,sha256=njVUEirFPTSsqAR0QRaS_rMKWBe4REBT4hBRWrNnYxI,4607
+emdash_cli/commands/index.py,sha256=uFNC5whhU9JdF_59FeM99OPdzKLBTJLkLO6vp9pt944,6959
 emdash_cli/commands/plan.py,sha256=BRiyIhfy_zz2PYy4Qo3a0t77GwHhdssZk6NImOkPi-w,2189
 emdash_cli/commands/projectmd.py,sha256=4y4cn_yFw85jMUm52nGjpqnd-YWvs6ZNEMWJGeJC17Q,1605
 emdash_cli/commands/research.py,sha256=xtI9_9emY7-rGQD5xJALTxtgTFmI4dplYW148dtTaTs,1553
 emdash_cli/commands/rules.py,sha256=n85CCG0WNIBEsUK9STJetPmZxoypQtest5BGPsXl0ac,2712
 emdash_cli/commands/search.py,sha256=DrSv_oN2xF1NaKCBICdyII7eupVRsDQ2ysW-TPSU0X0,1661
 emdash_cli/commands/server.py,sha256=UTmLAVolT0krN9xCtMcCSvmQZ9k1QwpFFmXGg9BulRY,3459
+emdash_cli/commands/skills.py,sha256=8N4279Hr8u2L8AgVjSTRVBLJBcXhN5DN7dn5fME62bs,9989
 emdash_cli/commands/spec.py,sha256=qafDmzKyRH035p3xTm_VTUsQLDZblIzIg-dxjEPv6tM,1494
 emdash_cli/commands/swarm.py,sha256=s_cntuorNdtNNTD2Qs1p2IcHghMrBMOQuturPS3y9mM,2661
 emdash_cli/commands/tasks.py,sha256=TdyunjSV5w7jpNFwv0fTL-_No5Fyvdm7Z2nXqxWSJec,1635
 emdash_cli/commands/team.py,sha256=K1-IJg6iG-9HMF_3JmpNDlNs1PYbb-ThFHU9KU_jKRo,1430
-emdash_cli/main.py,sha256=pxUzyh01R-FDETMRf8nrBvP9QW3DVgeTJZ1Vsradw-E,2502
+emdash_cli/keyboard.py,sha256=haYYAuhYGtdjomzhIFy_3Z3eN3BXfMdb4uRQjwB0tbk,4593
+emdash_cli/main.py,sha256=c-faWp-jzf9a0BbXhVoPvPQfGWSryXpYfswehqZCYPM,2593
 emdash_cli/server_manager.py,sha256=RrLteSHUmcFV4cyHJAEmgM9qHru2mJS08QNLWno6Y3Y,7051
-emdash_cli/sse_renderer.py,sha256=lm09h7a4zjahNvwEKkgxWWQjcB7i-k0v6OS4AWVpUSQ,15384
-emdash_cli-0.1.4.dist-info/METADATA,sha256=_9lj3mUt5L3rZqbN4HA7Ctol5k1I0h7rZrCY5sUUmBQ,660
-emdash_cli-0.1.4.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-emdash_cli-0.1.4.dist-info/entry_points.txt,sha256=31CuYD0k-tM8csFWDunc-JoZTxXaifj3oIXz4V0p6F0,122
-emdash_cli-0.1.4.dist-info/RECORD,,
+emdash_cli/sse_renderer.py,sha256=PEbD53ZohMp9yvii_1ELGwVKb8nnA_n17jICeaURkuY,23738
+emdash_cli-0.1.25.dist-info/METADATA,sha256=RFuFUhHJlRcpfzwztnQXTWheB853OVlyWd1tAIzRKsE,662
+emdash_cli-0.1.25.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+emdash_cli-0.1.25.dist-info/entry_points.txt,sha256=31CuYD0k-tM8csFWDunc-JoZTxXaifj3oIXz4V0p6F0,122
+emdash_cli-0.1.25.dist-info/RECORD,,