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

emdash_cli/__init__.py

@@ -1,3 +1,8 @@
 """EmDash CLI - Command-line interface for code intelligence."""
 
-__version__ = "0.1.3"
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("emdash-cli")
+except PackageNotFoundError:
+    __version__ = "0.0.0-dev"

emdash_cli/client.py

@@ -476,7 +476,7 @@ class EmdashClient:
     def research_stream(
         self,
         goal: str,
-        max_iterations: int = 10,
+        max_iterations: int = 50,
         budget: int = 50,
         model: Optional[str] = None,
     ) -> Iterator[str]:

emdash_cli/commands/agent.py

@@ -459,6 +459,7 @@ def _run_interactive(
     from prompt_toolkit.history import FileHistory
     from prompt_toolkit.completion import Completer, Completion
     from prompt_toolkit.styles import Style
+    from prompt_toolkit.key_binding import KeyBindings
     from pathlib import Path
 
     # Current mode
@@ -503,11 +504,29 @@ def _run_interactive(
     history_file.parent.mkdir(parents=True, exist_ok=True)
     history = FileHistory(str(history_file))
 
+    # Key bindings: Enter submits, Alt+Enter inserts newline
+    # Note: Shift+Enter is indistinguishable from Enter in most terminals
+    kb = KeyBindings()
+
+    @kb.add("enter")
+    def submit_on_enter(event):
+        """Submit on Enter."""
+        event.current_buffer.validate_and_handle()
+
+    @kb.add("escape", "enter")  # Alt+Enter (Escape then Enter)
+    @kb.add("c-j")  # Ctrl+J as alternative for newline
+    def insert_newline_alt(event):
+        """Insert a newline character with Alt+Enter or Ctrl+J."""
+        event.current_buffer.insert_text("\n")
+
     session = PromptSession(
         history=history,
         completer=SlashCommandCompleter(),
         style=PROMPT_STYLE,
         complete_while_typing=True,
+        multiline=True,
+        prompt_continuation="... ",
+        key_bindings=kb,
     )
 
     def get_prompt():

emdash_cli/commands/index.py

@@ -5,7 +5,9 @@ import os
 
 import click
 from rich.console import Console
-from rich.status import Status
+from rich.panel import Panel
+from rich.progress import BarColumn, Progress, TaskProgressColumn, TextColumn
+from rich.table import Table
 
 from ..client import EmdashClient
 from ..server_manager import get_server_manager
@@ -68,30 +70,96 @@ def index_start(
         options["model"] = model
 
     try:
-        # Stream indexing progress with spinner
-        with Status("[bold cyan]Indexing in progress...[/bold cyan]", console=console) as status:
+        # Stream indexing progress with progress bar
+        final_stats = {}
+
+        with Progress(
+            TextColumn("[bold cyan]{task.description}[/bold cyan]"),
+            BarColumn(bar_width=40, complete_style="cyan", finished_style="green"),
+            TaskProgressColumn(),
+            console=console,
+            transient=True,
+        ) as progress:
+            task = progress.add_task("Starting...", total=100)
+
             for line in client.index_start_stream(repo_path, changed_only):
                 line = line.strip()
+                if line.startswith("event: "):
+                    continue
                 if line.startswith("data: "):
                     try:
                         data = json.loads(line[6:])
                         step = data.get("step") or data.get("message", "")
                         percent = data.get("percent")
+
+                        # Capture final stats from response event
+                        if data.get("success") and data.get("stats"):
+                            final_stats = data.get("stats", {})
+
                         if step:
-                            if percent is not None:
-                                status.update(f"[bold cyan]{step}[/bold cyan] ({percent:.0f}%)")
-                            else:
-                                status.update(f"[bold cyan]{step}[/bold cyan]")
+                            progress.update(task, description=step)
+                        if percent is not None:
+                            progress.update(task, completed=percent)
                     except json.JSONDecodeError:
                         pass
 
-        console.print("\n[green]Indexing complete![/green]")
+            # Complete the progress bar
+            progress.update(task, completed=100, description="Complete")
+
+        # Show completion with sense of accomplishment
+        _show_completion(repo_path, final_stats, client)
 
     except Exception as e:
         console.print(f"\n[red]Error:[/red] {e}")
         raise click.Abort()
 
 
+def _show_completion(repo_path: str, stats: dict, client: EmdashClient) -> None:
+    """Show a nice completion message with stats."""
+    # If we don't have stats from the stream, fetch from status endpoint
+    if not stats:
+        try:
+            status_data = client.index_status(repo_path)
+            stats = {
+                "files": status_data.get("file_count", 0),
+                "functions": status_data.get("function_count", 0),
+                "classes": status_data.get("class_count", 0),
+                "communities": status_data.get("community_count", 0),
+            }
+        except Exception:
+            stats = {}
+
+    # Build completion message
+    console.print()
+
+    if stats:
+        # Create a summary table
+        table = Table(show_header=False, box=None, padding=(0, 2))
+        table.add_column("Label", style="dim")
+        table.add_column("Value", style="bold")
+
+        if stats.get("files"):
+            table.add_row("Files", str(stats["files"]))
+        if stats.get("functions"):
+            table.add_row("Functions", str(stats["functions"]))
+        if stats.get("classes"):
+            table.add_row("Classes", str(stats["classes"]))
+        if stats.get("communities"):
+            table.add_row("Communities", str(stats["communities"]))
+
+        panel = Panel(
+            table,
+            title="[bold green]Indexing Complete[/bold green]",
+            border_style="green",
+            padding=(1, 2),
+        )
+        console.print(panel)
+    else:
+        console.print("[bold green]Indexing complete![/bold green]")
+
+    console.print()
+
+
 @index.command("status")
 @click.argument("repo_path", required=False)
 def index_status(repo_path: str | None):

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
@@ -54,6 +55,12 @@ class SSERenderer:
         self._subagent_tool_count = 0
         self._subagent_current_tool = None
 
+        # Spinner animation thread
+        self._spinner_thread: Optional[threading.Thread] = None
+        self._spinner_running = False
+        self._spinner_message = "thinking"
+        self._spinner_lock = threading.Lock()
+
     def render_stream(self, lines: Iterator[str]) -> dict:
         """Render SSE stream to terminal.
 
@@ -66,27 +73,35 @@ class SSERenderer:
         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()
+        # Start spinner while waiting for first event
+        if self.verbose:
+            self._start_spinner("thinking")
+
+        try:
+            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 - 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,
@@ -96,20 +111,50 @@ class SSERenderer:
             "clarification": self._pending_clarification,
         }
 
+    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 +171,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":
@@ -144,6 +191,8 @@ class SSERenderer:
             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 +280,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 +357,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 +370,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 +391,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."""
@@ -438,5 +496,40 @@ 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)."""
+        if not self.verbose:
+            return
+
+        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)
+
+        # 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:
+            return
+
+        self.console.print()
+        self.console.print("[dim]───── Context Frame ─────[/dim]")
+
+        # Show stats line
+        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 context_tokens > 0:
+            stats.append(f"{context_tokens:,} context tokens")
+
+        if stats:
+            self.console.print(f"  [dim]{' · '.join(stats)}[/dim]")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emdash-cli
-Version: 0.1.4
+Version: 0.1.17
 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.17)
 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.17.dist-info}/RECORD

@@ -1,12 +1,12 @@
-emdash_cli/__init__.py,sha256=q-eC58WAvKd48CbdQVJ5kSGA86_V18JmkE1qXkjEyjw,88
-emdash_cli/client.py,sha256=7eWchJugC4xtKs8Ob63_kJMdnjyoN3be_1qP8qMujZE,16275
+emdash_cli/__init__.py,sha256=Rnn2O7B8OCEKlVtNRbWOU2-GN75_KLmhEJgOZzY-KwE,232
+emdash_cli/client.py,sha256=1Ri-BpZPfnZuXRhN8sCLna2SRhhr_AVDC_0CeTQPOhM,16275
 emdash_cli/commands/__init__.py,sha256=zf0lQ6S1UgoIg6NS7Oehxnb3iGD0Wxai0QU1nobgi9U,671
-emdash_cli/commands/agent.py,sha256=HAz9exNc2iXiNu5OBJJRJrTKS1z31lkdDzVcIpfItAg,29618
+emdash_cli/commands/agent.py,sha256=aYN9nLL30ETJKewo42d8U7QY9DGqCMTHCpIPiqJGlLA,30323
 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
@@ -19,8 +19,8 @@ emdash_cli/commands/tasks.py,sha256=TdyunjSV5w7jpNFwv0fTL-_No5Fyvdm7Z2nXqxWSJec,
 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/sse_renderer.py,sha256=55lDLzYngrWmXstb7PNpQcWi2G4u47qWaYqRJjqMUYo,18587
+emdash_cli-0.1.17.dist-info/METADATA,sha256=u7puOJ_vO_Nc_RU7RSCsQOoXV2rSTCd3zEfwpueg3o0,662
+emdash_cli-0.1.17.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+emdash_cli-0.1.17.dist-info/entry_points.txt,sha256=31CuYD0k-tM8csFWDunc-JoZTxXaifj3oIXz4V0p6F0,122
+emdash_cli-0.1.17.dist-info/RECORD,,