emdash-cli 0.1.30__py3-none-any.whl → 0.1.35__py3-none-any.whl

emdash_cli/sse_renderer.py

@@ -43,6 +43,7 @@ class SSERenderer:
         self._spec = None
         self._spec_submitted = False
         self._plan_submitted = None  # Plan data when submit_plan tool is called
+        self._plan_mode_requested = None  # Plan mode request data
         self._pending_clarification = None
 
         # Live display state
@@ -55,6 +56,8 @@ class SSERenderer:
         # Sub-agent state (for inline updates)
         self._subagent_tool_count = 0
         self._subagent_current_tool = None
+        self._subagent_type = None
+        self._in_subagent_mode = False  # Track when sub-agent is running
 
         # Spinner animation thread
         self._spinner_thread: Optional[threading.Thread] = None
@@ -83,6 +86,9 @@ class SSERenderer:
         final_response = ""
         interrupted = False
         self._last_thinking = None  # Reset thinking storage
+        self._pending_clarification = None  # Reset clarification state
+        self._plan_submitted = None  # Reset plan state
+        self._plan_mode_requested = None  # Reset plan mode request state
 
         # Start spinner while waiting for first event
         if self.verbose:
@@ -127,6 +133,7 @@ class SSERenderer:
             "spec": self._spec,
             "spec_submitted": self._spec_submitted,
             "plan_submitted": self._plan_submitted,
+            "plan_mode_requested": self._plan_mode_requested,
             "clarification": self._pending_clarification,
             "interrupted": interrupted,
             "thinking": self._last_thinking,
@@ -183,8 +190,10 @@ class SSERenderer:
         if not isinstance(data, dict):
             data = {}
 
-        # Clear waiting indicator when new event arrives
-        self._clear_waiting()
+        # Clear waiting indicator when new event arrives (but not for sub-agent events)
+        subagent_id = data.get("subagent_id") if isinstance(data, dict) else None
+        if not subagent_id and not self._in_subagent_mode:
+            self._clear_waiting()
 
         if event_type == "session_start":
             self._render_session_start(data)
@@ -196,8 +205,14 @@ class SSERenderer:
             self._waiting_for_next = True
             if self.verbose:
                 self._start_spinner("thinking")
+        elif event_type == "subagent_start":
+            self._render_subagent_start(data)
+        elif event_type == "subagent_end":
+            self._render_subagent_end(data)
         elif event_type == "thinking":
             self._render_thinking(data)
+        elif event_type == "assistant_text":
+            self._render_assistant_text(data)
         elif event_type == "progress":
             self._render_progress(data)
         elif event_type == "partial_response":
@@ -206,6 +221,8 @@ class SSERenderer:
             return self._render_response(data)
         elif event_type == "clarification":
             self._render_clarification(data)
+        elif event_type == "plan_mode_requested":
+            self._render_plan_mode_requested(data)
         elif event_type == "plan_submitted":
             self._render_plan_submitted(data)
         elif event_type == "error":
@@ -239,6 +256,9 @@ class SSERenderer:
         self._tool_count = 0
         self._completed_tools = []
 
+        # Start spinner while waiting for first tool
+        self._start_spinner("thinking")
+
     def _render_tool_start(self, data: dict) -> None:
         """Render tool start event."""
         if not self.verbose:
@@ -246,11 +266,22 @@ class SSERenderer:
 
         name = data.get("name", "unknown")
         args = data.get("args", {})
+        tool_id = data.get("tool_id")
         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()}
+
+        # Store tool info for result rendering (keyed by tool_id for parallel support)
+        if not hasattr(self, '_pending_tools'):
+            self._pending_tools = {}
+        # Use tool_id if available, otherwise fall back to name
+        key = tool_id or name
+        self._pending_tools[key] = {"name": name, "args": args, "start_time": time.time(), "tool_id": tool_id}
+        self._current_tool = self._pending_tools[key]
+
+        # Stop spinner when tool starts
+        self._stop_spinner()
 
         # Special handling for task tool (spawning sub-agents)
         if name == "task":
@@ -264,59 +295,49 @@ class SSERenderer:
             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"
-        )
+        # Don't print anything here - wait for tool_result to print complete line
+        # This handles parallel tool execution correctly
 
     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]
 
+        # Use stored type if not provided
+        agent_type = agent_type or self._subagent_type or "Agent"
+
         # 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:]
+            if len(path) > 30:
+                summary = "..." + path[-27:]
             else:
                 summary = path
         elif "pattern" in args:
-            summary = str(args["pattern"])[:30]
+            summary = str(args["pattern"])[:25]
 
-        # 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="")
+        # Build compact progress line
+        line = f"    │ {spinner} ({agent_type}) {self._subagent_tool_count} tools... {tool_name} {summary}"
+        # Use ANSI: move to column 0, clear line, print
+        sys.stdout.write(f"\r\033[K{line}")
+        sys.stdout.flush()
 
     def _render_agent_spawn_start(self, args: dict) -> None:
-        """Render sub-agent spawn start with special UI."""
+        """Track sub-agent spawn state (rendering done by subagent_start event)."""
         agent_type = args.get("subagent_type", "Explore")
-        description = args.get("description", "")
-        prompt = args.get("prompt", "")
+
+        # Enter sub-agent mode: stop spinner, track state
+        self._stop_spinner()
+        self._in_subagent_mode = True
 
         # Reset sub-agent tracking
         self._subagent_tool_count = 0
         self._subagent_current_tool = None
+        self._subagent_type = agent_type
 
-        # 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}")
+        # Don't render here - subagent_start event will render the UI
 
     def _render_tool_result(self, data: dict) -> None:
         """Render tool result event."""
@@ -342,31 +363,35 @@ class SSERenderer:
 
         # 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
 
+        # Get tool info from pending tools (use tool_id if available)
+        pending_tools = getattr(self, '_pending_tools', {})
+        tool_id = data.get("tool_id")
+        key = tool_id or name
+        tool_info = pending_tools.pop(key, None) or self._current_tool or {}
+        args = tool_info.get("args", {})
+
         # 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]"
+        start_time = tool_info.get("start_time")
+        if start_time:
+            elapsed = time.time() - start_time
+            if elapsed >= 0.5:  # Only show if >= 0.5s
+                duration = f" {elapsed:.1f}s"
 
-        args_summary = ""
-        if self._current_tool:
-            args_summary = self._format_args_summary(self._current_tool.get("args", {}))
+        # Format args for display
+        args_display = self._format_tool_args(name, args)
 
+        # Build complete line: • ToolName(args)
         if success:
-            status_icon = "[green]✓[/green]"
-            result_text = f"[dim]{summary}[/dim]" if summary else ""
+            # Format: • tool(args) result 1.2s
+            result_text = f" [dim]{summary}[/dim]" if summary else ""
+            duration_text = f" [dim]{duration}[/dim]" if duration else ""
+            self.console.print(f"  [green]✓[/green] [bold]{name}[/bold]({args_display}){result_text}{duration_text}")
         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}"
-        )
+            error_text = summary or "failed"
+            self.console.print(f"  [red]✗[/red] [bold]{name}[/bold]({args_display}) [red]{error_text}[/red]")
 
         self._completed_tools.append({
             "name": name,
@@ -380,8 +405,11 @@ class SSERenderer:
         success = data.get("success", True)
         result_data = data.get("data") or {}
 
-        # Clear the progress line
-        sys.stdout.write(f"\r{' ' * 120}\r")
+        # Exit sub-agent mode
+        self._in_subagent_mode = False
+
+        # Clear the progress line and move to new line
+        sys.stdout.write(f"\r\033[K")
         sys.stdout.flush()
 
         # Calculate duration
@@ -415,6 +443,66 @@ class SSERenderer:
         self.console.print()
         self._current_tool = None
         self._subagent_tool_count = 0
+        self._subagent_type = None
+
+    def _render_subagent_start(self, data: dict) -> None:
+        """Render subagent start event - shows when Explore/Plan agent is spawned."""
+        agent_type = data.get("agent_type", "Agent")
+        prompt = data.get("prompt", "")
+        description = data.get("description", "")
+
+        # Stop any existing spinner
+        self._stop_spinner()
+
+        # Truncate prompt for display
+        prompt_display = prompt[:80] + "..." if len(prompt) > 80 else prompt
+
+        self.console.print()
+        # Use different colors for different agent types
+        if agent_type == "Plan":
+            self.console.print(f"  [bold blue]◆ Spawning {agent_type} Agent[/bold blue]")
+        else:
+            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}")
+
+        # Enter subagent mode for tool tracking
+        self._in_subagent_mode = True
+        self._subagent_type = agent_type
+        self._subagent_tool_count = 0
+        self._subagent_start_time = time.time()
+
+    def _render_subagent_end(self, data: dict) -> None:
+        """Render subagent end event - shows completion summary."""
+        agent_type = data.get("agent_type", "Agent")
+        success = data.get("success", True)
+        iterations = data.get("iterations", 0)
+        files_explored = data.get("files_explored", 0)
+        execution_time = data.get("execution_time", 0)
+
+        # Exit subagent mode
+        self._in_subagent_mode = False
+
+        if success:
+            self.console.print(
+                f"    [green]✓[/green] {agent_type} completed [dim]({execution_time:.1f}s)[/dim]"
+            )
+            # Show stats
+            stats = []
+            if iterations > 0:
+                stats.append(f"{iterations} turns")
+            if files_explored > 0:
+                stats.append(f"{files_explored} files")
+            if stats:
+                self.console.print(f"    [dim]{' · '.join(stats)}[/dim]")
+        else:
+            self.console.print(f"    [red]✗[/red] {agent_type} failed")
+
+        self.console.print()
+        self._subagent_type = None
+        self._subagent_tool_count = 0
 
     def _format_args_summary(self, args: dict) -> str:
         """Format args into a compact summary string."""
@@ -422,7 +510,7 @@ class SSERenderer:
             return ""
 
         parts = []
-        for k, v in list(args.items())[:2]:
+        for _, v in list(args.items())[:2]:
             v_str = str(v)
             if len(v_str) > 40:
                 v_str = v_str[:37] + "..."
@@ -430,6 +518,41 @@ class SSERenderer:
 
         return " ".join(parts)
 
+    def _format_tool_args(self, tool_name: str, args: dict) -> str:
+        """Format tool args in Claude Code style: ToolName(key_arg_value).
+
+        Shows the most relevant arg for each tool type.
+        """
+        if not args:
+            return ""
+
+        # Tool-specific formatting for cleaner display
+        if tool_name in ("glob", "grep", "semantic_search"):
+            pattern = args.get("pattern", args.get("query", ""))
+            if pattern:
+                return f'[dim]pattern:[/dim] "{pattern}"' if len(pattern) < 50 else f'[dim]pattern:[/dim] "{pattern[:47]}..."'
+        elif tool_name in ("read_file", "write_to_file", "list_files"):
+            path = args.get("path", "")
+            if path:
+                return f"[dim]{path}[/dim]"
+        elif tool_name == "bash":
+            cmd = args.get("command", "")
+            if cmd:
+                return f"[dim]{cmd[:60]}{'...' if len(cmd) > 60 else ''}[/dim]"
+        elif tool_name == "edit_file":
+            path = args.get("path", "")
+            if path:
+                return f"[dim]{path}[/dim]"
+
+        # Default: show first arg value
+        if args:
+            first_val = str(list(args.values())[0])
+            if len(first_val) > 50:
+                first_val = first_val[:47] + "..."
+            return f"[dim]{first_val}[/dim]"
+
+        return ""
+
     def _render_thinking(self, data: dict) -> None:
         """Render thinking event.
 
@@ -442,15 +565,15 @@ class SSERenderer:
 
         # Check if this is extended thinking (long content) vs short progress message
         if len(message) > 200:
-            # Extended thinking - show summary with collapsible indicator
+            # Extended thinking - show full content
             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]")
+            for line in lines:
+                self.console.print(f"  [dim]┃[/dim] [dim]   {line}[/dim]")
 
             # Store thinking for potential later display
             self._last_thinking = message
@@ -458,6 +581,24 @@ class SSERenderer:
             # Short progress message
             self.console.print(f"  [dim]┃[/dim] [dim italic]💭 {message}[/dim italic]")
 
+    def _render_assistant_text(self, data: dict) -> None:
+        """Render intermediate assistant text (between tool calls)."""
+        if not self.verbose:
+            return
+
+        content = data.get("content", "").strip()
+        if not content:
+            return
+
+        # Stop spinner while showing text
+        self._stop_spinner()
+
+        # Show as bullet point like Claude Code (cyan for assistant reasoning)
+        # Truncate long content
+        if len(content) > 200:
+            content = content[:197] + "..."
+        self.console.print(f"  [cyan]•[/cyan] [italic]{content}[/italic]")
+
     def _render_progress(self, data: dict) -> None:
         """Render progress event."""
         if not self.verbose:
@@ -507,73 +648,47 @@ class SSERenderer:
                 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
+        # Always store clarification (with or without options)
+        self._pending_clarification = {
+            "question": question,
+            "context": context,
+            "options": options,
+        }
+
+    def _render_plan_mode_requested(self, data: dict) -> None:
+        """Render plan mode request event and store for menu display."""
+        from rich.panel import Panel
+
+        reason = data.get("reason", "")
+
+        # Store the request data for the CLI to show the menu
+        self._plan_mode_requested = data
+
+        # Display the request
+        self.console.print()
+        self.console.print(Panel(
+            f"[bold]Request to Enter Plan Mode[/bold]\n\n{reason}",
+            title="[yellow]⚡ Plan Mode Request[/yellow]",
+            border_style="yellow",
+        ))
 
     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
+        from rich.markdown import Markdown
 
-        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", "")
+        plan = data.get("plan", "")
 
         # Store the plan data for the CLI to show the menu
         self._plan_submitted = data
 
-        # Build plan display
+        # Render plan as markdown in a panel
         self.console.print()
         self.console.print(Panel(
-            f"[bold]{title}[/bold]\n\n{summary}",
+            Markdown(plan),
             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:

{emdash_cli-0.1.30.dist-info → emdash_cli-0.1.35.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emdash-cli
-Version: 0.1.30
+Version: 0.1.35
 Summary: EmDash CLI - Command-line interface for code intelligence
 Author: Em Dash Team
 Requires-Python: >=3.10,<4.0
@@ -12,7 +12,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Provides-Extra: images
 Requires-Dist: click (>=8.1.7,<9.0.0)
-Requires-Dist: emdash-core (>=0.1.30)
+Requires-Dist: emdash-core (>=0.1.35)
 Requires-Dist: httpx (>=0.25.0)
 Requires-Dist: pillow (>=10.0.0) ; extra == "images"
 Requires-Dist: prompt_toolkit (>=3.0.43,<4.0.0)

{emdash_cli-0.1.30.dist-info → emdash_cli-0.1.35.dist-info}/RECORD

@@ -1,8 +1,8 @@
-emdash_cli/__init__.py,sha256=Rnn2O7B8OCEKlVtNRbWOU2-GN75_KLmhEJgOZzY-KwE,232
-emdash_cli/client.py,sha256=aQO_wF4XQaqig6RWhTA3FIJslweo7LsZHCk_GBVGdvw,17117
+emdash_cli/__init__.py,sha256=21JmQcWge3QOM4hLjtBdu-7AoxJonJuIwMeobWIjr2w,690
+emdash_cli/client.py,sha256=MZCyajCM7UghFVv_lKoPAaX0lUUDTe4FI4qlIPCYvcc,21008
 emdash_cli/clipboard.py,sha256=hcg5sbIhbixqzpJdonoFLGBlSo2AKjplNrWy5PGnqaY,3564
 emdash_cli/commands/__init__.py,sha256=D9edXBHm69tueUtE4DggTA1_Yjsl9YZaKjBVDY2D_gQ,712
-emdash_cli/commands/agent.py,sha256=dLNNyJNL9uzZcBapzFghdjb-Xa27PglpbFNAMPGa3qc,28772
+emdash_cli/commands/agent.py,sha256=ZBCJWxX-Ze6UlmU3POO3EMjCdOc6D_akxlr6T4U-p74,48445
 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
@@ -22,8 +22,9 @@ emdash_cli/commands/team.py,sha256=K1-IJg6iG-9HMF_3JmpNDlNs1PYbb-ThFHU9KU_jKRo,1
 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=aDOoHKglOkaYEXuKg937mH6yFPDxjU7Rqa_-APyM9Dc,23215
-emdash_cli-0.1.30.dist-info/METADATA,sha256=czNXf-GzyfHKHe8g8Dfd7Bm7kI189H-VLRpFDVgtejc,738
-emdash_cli-0.1.30.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-emdash_cli-0.1.30.dist-info/entry_points.txt,sha256=31CuYD0k-tM8csFWDunc-JoZTxXaifj3oIXz4V0p6F0,122
-emdash_cli-0.1.30.dist-info/RECORD,,
+emdash_cli/session_store.py,sha256=GjS73GLSZ3oTNtrFHMcyiP6GnH0Dvfvs6r4s3-bfEaM,9424
+emdash_cli/sse_renderer.py,sha256=QRykGh1BirtRC_2_3X48zJ0gctDEF7OV5VgiM0QUwtQ,27750
+emdash_cli-0.1.35.dist-info/METADATA,sha256=Imi3rtfGyvWLC_ddLV8GiPPeSQlavqcB78XgowoJufg,738
+emdash_cli-0.1.35.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+emdash_cli-0.1.35.dist-info/entry_points.txt,sha256=31CuYD0k-tM8csFWDunc-JoZTxXaifj3oIXz4V0p6F0,122
+emdash_cli-0.1.35.dist-info/RECORD,,