emdash-cli 0.1.4__py3-none-any.whl

emdash_cli/sse_renderer.py

@@ -0,0 +1,442 @@
+"""SSE event renderer for Rich terminal output."""
+
+import json
+import sys
+import time
+from typing import Iterator, Optional
+
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.text import Text
+
+
+# Spinner frames for loading animation
+SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+
+
+class SSERenderer:
+    """Renders SSE events to Rich terminal output with live updates.
+
+    Features:
+    - Animated spinner while tools execute
+    - Special UI for spawning sub-agents
+    - Clean, minimal output
+    """
+
+    def __init__(
+        self,
+        console: Optional[Console] = None,
+        verbose: bool = True,
+    ):
+        """Initialize the renderer.
+
+        Args:
+            console: Rich console to render to (creates one if not provided)
+            verbose: Whether to show tool calls and progress
+        """
+        self.console = console or Console()
+        self.verbose = verbose
+        self._partial_response = ""
+        self._session_id = None
+        self._spec = None
+        self._spec_submitted = False
+        self._pending_clarification = None
+
+        # Live display state
+        self._current_tool = None
+        self._tool_count = 0
+        self._completed_tools: list[dict] = []
+        self._spinner_idx = 0
+        self._waiting_for_next = False
+
+        # Sub-agent state (for inline updates)
+        self._subagent_tool_count = 0
+        self._subagent_current_tool = None
+
+    def render_stream(self, lines: Iterator[str]) -> dict:
+        """Render SSE stream to terminal.
+
+        Args:
+            lines: Iterator of SSE lines from HTTP response
+
+        Returns:
+            Dict with session_id, content, spec, 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()
+
+        return {
+            "content": final_response,
+            "session_id": self._session_id,
+            "spec": self._spec,
+            "spec_submitted": self._spec_submitted,
+            "clarification": self._pending_clarification,
+        }
+
+    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()
+
+    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
+
+    def _handle_event(self, event_type: str, data: dict) -> Optional[str]:
+        """Handle individual SSE event."""
+        # Ensure data is a dict
+        if not isinstance(data, dict):
+            data = {}
+
+        # Clear waiting indicator when new event arrives
+        self._clear_waiting()
+
+        if event_type == "session_start":
+            self._render_session_start(data)
+        elif event_type == "tool_start":
+            self._render_tool_start(data)
+        elif event_type == "tool_result":
+            self._render_tool_result(data)
+            # Set waiting for next tool/response
+            self._waiting_for_next = True
+        elif event_type == "thinking":
+            self._render_thinking(data)
+        elif event_type == "progress":
+            self._render_progress(data)
+        elif event_type == "partial_response":
+            self._render_partial(data)
+        elif event_type == "response":
+            return self._render_response(data)
+        elif event_type == "clarification":
+            self._render_clarification(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)
+
+        return None
+
+    def _render_session_start(self, data: dict) -> None:
+        """Render session start event."""
+        if data.get("session_id"):
+            self._session_id = data["session_id"]
+
+        if not self.verbose:
+            return
+
+        agent = data.get("agent_name", "Agent")
+        model = data.get("model", "unknown")
+
+        # Extract model name from full path
+        if "/" in model:
+            model = model.split("/")[-1]
+
+        self.console.print()
+        self.console.print(f"[bold cyan]{agent}[/bold cyan] [dim]({model})[/dim]")
+        self._tool_count = 0
+        self._completed_tools = []
+
+    def _render_tool_start(self, data: dict) -> None:
+        """Render tool start event."""
+        if not self.verbose:
+            return
+
+        name = data.get("name", "unknown")
+        args = data.get("args", {})
+        subagent_id = data.get("subagent_id")
+        subagent_type = data.get("subagent_type")
+
+        self._tool_count += 1
+        self._current_tool = {"name": name, "args": args, "start_time": time.time()}
+
+        # Special handling for task tool (spawning sub-agents)
+        if name == "task":
+            self._render_agent_spawn_start(args)
+            return
+
+        # Sub-agent events: update in place on single line
+        if subagent_id:
+            self._subagent_tool_count += 1
+            self._subagent_current_tool = name
+            self._render_subagent_progress(subagent_type or "Agent", name, args)
+            return
+
+        # Format args summary (compact)
+        args_summary = self._format_args_summary(args)
+
+        # Show spinner with tool name
+        spinner = SPINNER_FRAMES[0]
+        self.console.print(
+            f"  [dim]┃[/dim] [yellow]{spinner}[/yellow] [bold]{name}[/bold] {args_summary}",
+            end="\r"
+        )
+
+    def _render_subagent_progress(self, agent_type: str, tool_name: str, args: dict) -> None:
+        """Render sub-agent progress on a single updating line."""
+        self._spinner_idx = (self._spinner_idx + 1) % len(SPINNER_FRAMES)
+        spinner = SPINNER_FRAMES[self._spinner_idx]
+
+        # Get a short summary of what's being done
+        summary = ""
+        if "path" in args:
+            path = str(args["path"])
+            # Shorten long paths
+            if len(path) > 40:
+                summary = "..." + path[-37:]
+            else:
+                summary = path
+        elif "pattern" in args:
+            summary = str(args["pattern"])[:30]
+
+        # Clear line and show progress
+        line = f"      [dim]│[/dim] [yellow]{spinner}[/yellow] [dim cyan]({agent_type})[/dim cyan] {self._subagent_tool_count} tools... [bold]{tool_name}[/bold] [dim]{summary}[/dim]"
+        # Pad to clear previous content
+        sys.stdout.write(f"\r{' ' * 120}\r")
+        self.console.print(line, end="")
+
+    def _render_agent_spawn_start(self, args: dict) -> None:
+        """Render sub-agent spawn start with special UI."""
+        agent_type = args.get("subagent_type", "Explore")
+        description = args.get("description", "")
+        prompt = args.get("prompt", "")
+
+        # Truncate prompt for display
+        prompt_display = prompt[:60] + "..." if len(prompt) > 60 else prompt
+
+        self.console.print()
+        self.console.print(
+            f"  [bold magenta]◆ Spawning {agent_type} Agent[/bold magenta]"
+        )
+        if description:
+            self.console.print(f"    [dim]{description}[/dim]")
+        self.console.print(f"    [cyan]→[/cyan] {prompt_display}")
+
+    def _render_tool_result(self, data: dict) -> None:
+        """Render tool result event."""
+        name = data.get("name", "unknown")
+        success = data.get("success", True)
+        summary = data.get("summary")
+        subagent_id = data.get("subagent_id")
+
+        # Detect spec submission
+        if name == "submit_spec" and success:
+            self._spec_submitted = True
+            spec_data = data.get("data", {})
+            if spec_data:
+                self._spec = spec_data.get("content")
+
+        if not self.verbose:
+            return
+
+        # Special handling for task tool result
+        if name == "task":
+            self._render_agent_spawn_result(data)
+            return
+
+        # Sub-agent events: don't print result lines, just keep updating progress
+        if subagent_id:
+            # Progress is already shown by _render_tool_start, nothing to do here
+            return
+
+        # Calculate duration
+        duration = ""
+        if self._current_tool and self._current_tool.get("start_time"):
+            elapsed = time.time() - self._current_tool["start_time"]
+            if elapsed >= 0.1:
+                duration = f" [dim]{elapsed:.1f}s[/dim]"
+
+        args_summary = ""
+        if self._current_tool:
+            args_summary = self._format_args_summary(self._current_tool.get("args", {}))
+
+        if success:
+            status_icon = "[green]✓[/green]"
+            result_text = f"[dim]{summary}[/dim]" if summary else ""
+        else:
+            status_icon = "[red]✗[/red]"
+            result_text = f"[red]{summary}[/red]" if summary else "[red]failed[/red]"
+
+        # Overwrite the spinner line
+        self.console.print(
+            f"  [dim]┃[/dim] {status_icon} [bold]{name}[/bold] {args_summary}{duration} {result_text}"
+        )
+
+        self._completed_tools.append({
+            "name": name,
+            "success": success,
+            "summary": summary,
+        })
+        self._current_tool = None
+
+    def _render_agent_spawn_result(self, data: dict) -> None:
+        """Render sub-agent spawn result with special UI."""
+        success = data.get("success", True)
+        result_data = data.get("data") or {}
+
+        # Calculate duration
+        duration = ""
+        if self._current_tool and self._current_tool.get("start_time"):
+            elapsed = time.time() - self._current_tool["start_time"]
+            duration = f" [dim]({elapsed:.1f}s)[/dim]"
+
+        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")
+                self.console.print(f"    [dim]{' · '.join(stats)}[/dim]")
+        else:
+            error = result_data.get("error", data.get("summary", "failed"))
+            self.console.print(f"    [red]✗[/red] Agent failed: {error}")
+
+        self.console.print()
+        self._current_tool = None
+
+    def _format_args_summary(self, args: dict) -> str:
+        """Format args into a compact summary string."""
+        if not args:
+            return ""
+
+        parts = []
+        for k, v in list(args.items())[:2]:
+            v_str = str(v)
+            if len(v_str) > 40:
+                v_str = v_str[:37] + "..."
+            parts.append(f"[dim]{v_str}[/dim]")
+
+        return " ".join(parts)
+
+    def _render_thinking(self, data: dict) -> None:
+        """Render thinking event."""
+        if not self.verbose:
+            return
+
+        message = data.get("message", "")
+        self.console.print(f"  [dim]┃[/dim] [dim italic]💭 {message}[/dim italic]")
+
+    def _render_progress(self, data: dict) -> None:
+        """Render progress event."""
+        if not self.verbose:
+            return
+
+        message = data.get("message", "")
+        percent = data.get("percent")
+
+        if percent is not None:
+            bar_width = 20
+            filled = int(bar_width * percent / 100)
+            bar = "█" * filled + "░" * (bar_width - filled)
+            self.console.print(f"  [dim]┃[/dim] [dim]{bar} {percent:.0f}% {message}[/dim]")
+        else:
+            self.console.print(f"  [dim]┃[/dim] [dim]{message}[/dim]")
+
+    def _render_partial(self, data: dict) -> None:
+        """Render partial response (streaming text)."""
+        content = data.get("content", "")
+        self._partial_response += content
+
+    def _render_response(self, data: dict) -> str:
+        """Render final response."""
+        content = data.get("content", "")
+
+        self.console.print()
+        self.console.print(Markdown(content))
+
+        return content
+
+    def _render_clarification(self, data: dict) -> None:
+        """Render clarification request."""
+        question = data.get("question", "")
+        context = data.get("context", "")
+        options = data.get("options", [])
+
+        self.console.print()
+        self.console.print(Panel(
+            question,
+            title="[yellow]❓ Question[/yellow]",
+            border_style="yellow",
+            padding=(0, 1),
+        ))
+
+        if options:
+            for i, opt in enumerate(options, 1):
+                self.console.print(f"  [yellow][{i}][/yellow] {opt}")
+            self.console.print()
+
+            self._pending_clarification = {
+                "question": question,
+                "context": context,
+                "options": options,
+            }
+        else:
+            self._pending_clarification = None
+
+    def _render_error(self, data: dict) -> None:
+        """Render error event."""
+        message = data.get("message", "Unknown error")
+        details = data.get("details")
+
+        self.console.print(f"\n[red bold]✗ Error:[/red bold] {message}")
+
+        if details:
+            self.console.print(f"[dim]{details}[/dim]")
+
+    def _render_warning(self, data: dict) -> None:
+        """Render warning event."""
+        message = data.get("message", "")
+        self.console.print(f"[yellow]⚠ {message}[/yellow]")
+
+    def _render_session_end(self, data: dict) -> None:
+        """Render session end event."""
+        if not self.verbose:
+            return
+
+        success = data.get("success", True)
+        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]")

emdash_cli-0.1.4.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: emdash-cli
+Version: 0.1.4
+Summary: EmDash CLI - Command-line interface for code intelligence
+Author: Em Dash Team
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+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: 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/RECORD

@@ -0,0 +1,26 @@
+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/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/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/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/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-0.1.4.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.1
+Root-Is-Purelib: true
+Tag: py3-none-any

emdash_cli-0.1.4.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+--=emdash_cli.main:start_coding_agent
+em=emdash_cli.main:start_coding_agent
+emdash=emdash_cli.main:cli
+