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

emdash_cli/commands/agent.py

@@ -1,5 +1,8 @@
 """Agent CLI commands."""
 
+import os
+import threading
+
 import click
 from enum import Enum
 from rich.console import Console
@@ -7,6 +10,7 @@ from rich.panel import Panel
 from rich.markdown import Markdown
 
 from ..client import EmdashClient
+from ..keyboard import KeyListener
 from ..server_manager import get_server_manager
 from ..sse_renderer import SSERenderer
 
@@ -16,15 +20,13 @@ console = Console()
 class AgentMode(Enum):
     """Agent operation modes."""
     PLAN = "plan"
-    TASKS = "tasks"
     CODE = "code"
 
 
 # Slash commands available in interactive mode
 SLASH_COMMANDS = {
     # Mode switching
-    "/plan": "Switch to plan mode (explore codebase, create specs)",
-    "/tasks": "Switch to tasks mode (generate task lists)",
+    "/plan": "Switch to plan mode (explore codebase, create plans)",
     "/code": "Switch to code mode (execute file changes)",
     "/mode": "Show current mode",
     # Generation commands
@@ -51,10 +53,10 @@ def agent():
 @agent.command("code")
 @click.argument("task", required=False)
 @click.option("--model", "-m", default=None, help="Model to use")
-@click.option("--mode", type=click.Choice(["plan", "tasks", "code"]), default="code",
+@click.option("--mode", type=click.Choice(["plan", "code"]), default="code",
               help="Starting mode")
 @click.option("--quiet", "-q", is_flag=True, help="Less verbose output")
-@click.option("--max-iterations", default=20, help="Max agent iterations")
+@click.option("--max-iterations", default=int(os.getenv("EMDASH_MAX_ITERATIONS", "100")), help="Max agent iterations")
 @click.option("--no-graph-tools", is_flag=True, help="Skip graph exploration tools")
 @click.option("--save", is_flag=True, help="Save specs to specs/<feature>/")
 def agent_code(
@@ -72,13 +74,11 @@ def agent_code(
     Without TASK: Start interactive REPL mode
 
     MODES:
-      plan   - Explore codebase and create specifications
-      tasks  - Generate implementation task lists
+      plan   - Explore codebase and create plans (read-only)
       code   - Execute code changes (default)
 
     SLASH COMMANDS (in interactive mode):
       /plan   - Switch to plan mode
-      /tasks  - Switch to tasks mode
       /code   - Switch to code mode
       /help   - Show available commands
       /reset  - Reset session
@@ -111,7 +111,7 @@ def agent_code(
 
 
 def _get_clarification_response(clarification: dict) -> str | None:
-    """Get user response for clarification with options.
+    """Get user response for clarification with interactive selection.
 
     Args:
         clarification: Dict with question, context, and options
@@ -119,49 +119,22 @@ def _get_clarification_response(clarification: dict) -> str | None:
     Returns:
         User's selected option or typed response, or None if cancelled
     """
-    from prompt_toolkit import PromptSession
-
-    options = clarification.get("options", [])
-
-    session = PromptSession()
-    console.print("[dim]Enter number or type response:[/dim]")
-
-    try:
-        response = session.prompt("choice > ").strip()
-
-        if not response:
-            return None
-
-        # Map number to option
-        if response.isdigit():
-            idx = int(response) - 1
-            if 0 <= idx < len(options):
-                return options[idx]
-
-        return response
-    except (KeyboardInterrupt, EOFError):
-        return None
-
-
-def _show_spec_approval_menu() -> tuple[str, str]:
-    """Show spec approval menu with arrow-key selection.
-
-    Returns:
-        Tuple of (choice, feedback) where feedback is only set for 'refine'
-    """
-    from prompt_toolkit import Application
+    from prompt_toolkit import Application, PromptSession
     from prompt_toolkit.key_binding import KeyBindings
     from prompt_toolkit.layout import Layout, HSplit, Window, FormattedTextControl
     from prompt_toolkit.styles import Style
 
-    options = [
-        ("tasks", "Generate implementation tasks"),
-        ("code", "Start coding directly"),
-        ("refine", "Provide feedback to improve"),
-        ("abort", "Cancel and discard"),
-    ]
+    options = clarification.get("options", [])
 
-    selected_index = [0]  # Use list to allow mutation in closure
+    if not options:
+        # No options, just get free-form input
+        session = PromptSession()
+        try:
+            return session.prompt("response > ").strip() or None
+        except (KeyboardInterrupt, EOFError):
+            return None
+
+    selected_index = [0]
     result = [None]
 
     # Key bindings
@@ -179,64 +152,53 @@ def _show_spec_approval_menu() -> tuple[str, str]:
 
     @kb.add("enter")
     def select(event):
-        result[0] = options[selected_index[0]][0]
+        result[0] = options[selected_index[0]]
         event.app.exit()
 
-    @kb.add("1")
-    def select_1(event):
-        result[0] = "tasks"
-        event.app.exit()
-
-    @kb.add("2")
-    def select_2(event):
-        result[0] = "code"
-        event.app.exit()
-
-    @kb.add("3")
-    def select_3(event):
-        result[0] = "refine"
-        event.app.exit()
-
-    @kb.add("4")
-    def select_4(event):
-        result[0] = "abort"
-        event.app.exit()
+    # Number key shortcuts (1-9)
+    for i in range(min(9, len(options))):
+        @kb.add(str(i + 1))
+        def select_by_number(event, idx=i):
+            result[0] = options[idx]
+            event.app.exit()
 
     @kb.add("c-c")
-    @kb.add("q")
     @kb.add("escape")
     def cancel(event):
-        result[0] = "abort"
+        result[0] = None
+        event.app.exit()
+
+    @kb.add("o")  # 'o' for Other - custom input
+    def other_input(event):
+        result[0] = "OTHER_INPUT"
         event.app.exit()
 
     def get_formatted_options():
-        lines = [("class:title", "What would you like to do with this spec?\n\n")]
-        for i, (key, desc) in enumerate(options):
+        lines = []
+        for i, opt in enumerate(options):
             if i == selected_index[0]:
-                lines.append(("class:selected", f"  ❯ {key:8} "))
-                lines.append(("class:selected-desc", f"- {desc}\n"))
+                lines.append(("class:selected", f"  ❯ [{i+1}] {opt}\n"))
             else:
-                lines.append(("class:option", f"    {key:8} "))
-                lines.append(("class:desc", f"- {desc}\n"))
-        lines.append(("class:hint", "\n↑/↓ to move, Enter to select, q to cancel"))
+                lines.append(("class:option", f"    [{i+1}] {opt}\n"))
+        lines.append(("class:hint", "\n↑/↓ to move, Enter to select, 1-9 for quick select, o for other"))
         return lines
 
     # Style
     style = Style.from_dict({
-        "title": "#00ccff bold",
         "selected": "#00cc66 bold",
-        "selected-desc": "#00cc66",
         "option": "#888888",
-        "desc": "#666666",
         "hint": "#444444 italic",
     })
 
+    # Calculate height based on options
+    height = len(options) + 2  # options + hint line + padding
+
     # Layout
     layout = Layout(
         HSplit([
             Window(
                 FormattedTextControl(get_formatted_options),
-                height=8,
+                height=height,
             ),
         ])
     )
@@ -254,30 +216,48 @@ def _show_spec_approval_menu() -> tuple[str, str]:
     try:
         app.run()
     except (KeyboardInterrupt, EOFError):
-        result[0] = "abort"
-
-    choice = result[0] or "abort"
+        return None
 
-    # Get feedback if refine was chosen
-    feedback = ""
-    if choice == "refine":
-        from prompt_toolkit import PromptSession
+    # Handle "other" option - get custom input
+    if result[0] == "OTHER_INPUT":
+        session = PromptSession()
         console.print()
-        console.print("[dim]What changes would you like?[/dim]")
         try:
-            session = PromptSession()
-            feedback = session.prompt("feedback > ").strip()
+            return session.prompt("response > ").strip() or None
         except (KeyboardInterrupt, EOFError):
-            return "abort", ""
+            return None
 
-    return choice, feedback
+    # Check if selected option is an "other/explain" type that needs text input
+    if result[0]:
+        lower_result = result[0].lower()
+        needs_input = any(phrase in lower_result for phrase in [
+            "something else",
+            "other",
+            "i'll explain",
+            "i will explain",
+            "let me explain",
+            "custom",
+            "none of the above",
+        ])
+        if needs_input:
+            session = PromptSession()
+            console.print()
+            console.print("[dim]Please explain:[/dim]")
+            try:
+                custom_input = session.prompt("response > ").strip()
+                if custom_input:
+                    return custom_input
+            except (KeyboardInterrupt, EOFError):
+                return None
+
+    return result[0]
 
 
-def _show_tasks_approval_menu() -> tuple[str, str]:
-    """Show tasks approval menu with arrow-key selection.
+def _show_plan_approval_menu() -> tuple[str, str]:
+    """Show plan approval menu with simple approve/reject options.
 
     Returns:
-        Tuple of (choice, feedback) where feedback is only set for 'refine'
+        Tuple of (choice, feedback) where feedback is only set for 'reject'
     """
     from prompt_toolkit import Application
     from prompt_toolkit.key_binding import KeyBindings
@@ -285,10 +265,8 @@ def _show_tasks_approval_menu() -> tuple[str, str]:
     from prompt_toolkit.styles import Style
 
     options = [
-        ("code", "Start implementing these tasks"),
-        ("refine", "Refine tasks with more details"),
-        ("export", "Export tasks to file"),
-        ("abort", "Cancel and discard"),
+        ("approve", "Approve and start implementation"),
+        ("reject", "Reject and provide feedback"),
     ]
 
     selected_index = [0]  # Use list to allow mutation in closure
@@ -313,34 +291,26 @@ def _show_tasks_approval_menu() -> tuple[str, str]:
         event.app.exit()
 
     @kb.add("1")
-    def select_1(event):
-        result[0] = "code"
+    @kb.add("y")
+    def select_approve(event):
+        result[0] = "approve"
         event.app.exit()
 
     @kb.add("2")
-    def select_2(event):
-        result[0] = "refine"
-        event.app.exit()
-
-    @kb.add("3")
-    def select_3(event):
-        result[0] = "export"
-        event.app.exit()
-
-    @kb.add("4")
-    def select_4(event):
-        result[0] = "abort"
+    @kb.add("n")
+    def select_reject(event):
+        result[0] = "reject"
         event.app.exit()
 
     @kb.add("c-c")
     @kb.add("q")
     @kb.add("escape")
     def cancel(event):
-        result[0] = "abort"
+        result[0] = "reject"
         event.app.exit()
 
     def get_formatted_options():
-        lines = [("class:title", "What would you like to do with these tasks?\n\n")]
+        lines = [("class:title", "Approve this plan?\n\n")]
         for i, (key, desc) in enumerate(options):
             if i == selected_index[0]:
                 lines.append(("class:selected", f"  ❯ {key:8} "))
@@ -348,14 +318,14 @@ def _show_tasks_approval_menu() -> tuple[str, str]:
             else:
                 lines.append(("class:option", f"    {key:8} "))
                 lines.append(("class:desc", f"- {desc}\n"))
-        lines.append(("class:hint", "\n↑/↓ to move, Enter to select, q to cancel"))
+        lines.append(("class:hint", "\n↑/↓ to move, Enter to select, y/n for quick select"))
         return lines
 
     # Style
     style = Style.from_dict({
-        "title": "#cc66ff bold",  # Purple for tasks
-        "selected": "#cc66ff bold",
-        "selected-desc": "#cc66ff",
+        "title": "#00ccff bold",
+        "selected": "#00cc66 bold",
+        "selected-desc": "#00cc66",
         "option": "#888888",
         "desc": "#666666",
         "hint": "#444444 italic",
@@ -366,7 +336,7 @@ def _show_tasks_approval_menu() -> tuple[str, str]:
         HSplit([
             Window(
                 FormattedTextControl(get_formatted_options),
-                height=8,
+                height=6,
             ),
         ])
     )
@@ -384,25 +354,50 @@ def _show_tasks_approval_menu() -> tuple[str, str]:
     try:
         app.run()
     except (KeyboardInterrupt, EOFError):
-        result[0] = "abort"
+        result[0] = "reject"
 
-    choice = result[0] or "abort"
+    choice = result[0] or "reject"
 
-    # Get feedback if refine was chosen
+    # Get feedback if reject was chosen
     feedback = ""
-    if choice == "refine":
+    if choice == "reject":
         from prompt_toolkit import PromptSession
         console.print()
-        console.print("[dim]What changes would you like to the tasks?[/dim]")
+        console.print("[dim]What changes would you like?[/dim]")
         try:
             session = PromptSession()
             feedback = session.prompt("feedback > ").strip()
         except (KeyboardInterrupt, EOFError):
-            return "abort", ""
+            return "reject", ""
 
     return choice, feedback
 
 
+def _render_with_interrupt(renderer: SSERenderer, stream) -> dict:
+    """Render stream with ESC key interrupt support.
+
+    Args:
+        renderer: SSE renderer instance
+        stream: SSE stream iterator
+
+    Returns:
+        Result dict from renderer, with 'interrupted' flag
+    """
+    interrupt_event = threading.Event()
+
+    def on_escape():
+        interrupt_event.set()
+
+    listener = KeyListener(on_escape)
+
+    try:
+        listener.start()
+        result = renderer.render_stream(stream, interrupt_event=interrupt_event)
+        return result
+    finally:
+        listener.stop()
+
+
 def _run_single_task(
     client: EmdashClient,
     renderer: SSERenderer,
@@ -419,7 +414,9 @@ def _run_single_task(
             max_iterations=max_iterations,
             options=options,
         )
-        renderer.render_stream(stream)
+        result = _render_with_interrupt(renderer, stream)
+        if result.get("interrupted"):
+            console.print("[dim]Task interrupted. You can continue or start a new task.[/dim]")
     except Exception as e:
         console.print(f"[red]Error: {e}[/red]")
         raise click.Abort()
@@ -441,7 +438,9 @@ def _run_slash_command_task(
             max_iterations=max_iterations,
             options=options,
         )
-        renderer.render_stream(stream)
+        result = _render_with_interrupt(renderer, stream)
+        if result.get("interrupted"):
+            console.print("[dim]Task interrupted.[/dim]")
         console.print()
     except Exception as e:
         console.print(f"[red]Error: {e}[/red]")
@@ -459,6 +458,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
@@ -469,7 +469,6 @@ def _run_interactive(
     # Style for prompt
     PROMPT_STYLE = Style.from_dict({
         "prompt.mode.plan": "#ffcc00 bold",
-        "prompt.mode.tasks": "#cc66ff bold",
         "prompt.mode.code": "#00cc66 bold",
         "prompt.prefix": "#888888",
         "completion-menu": "bg:#1a1a2e #ffffff",
@@ -503,18 +502,35 @@ 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():
         """Get formatted prompt based on current mode."""
         mode_colors = {
             AgentMode.PLAN: "class:prompt.mode.plan",
-            AgentMode.TASKS: "class:prompt.mode.tasks",
             AgentMode.CODE: "class:prompt.mode.code",
         }
         mode_name = current_mode.value
@@ -550,10 +566,6 @@ def _run_interactive(
             current_mode = AgentMode.PLAN
             console.print("[yellow]Switched to plan mode[/yellow]")
 
-        elif command == "/tasks":
-            current_mode = AgentMode.TASKS
-            console.print("[magenta]Switched to tasks mode[/magenta]")
-
         elif command == "/code":
             current_mode = AgentMode.CODE
             console.print("[green]Switched to code mode[/green]")
@@ -730,7 +742,7 @@ def _run_interactive(
                     )
 
                 # Render the stream and capture any spec output
-                result = renderer.render_stream(stream)
+                result = _render_with_interrupt(renderer, stream)
 
                 # Check if we got a session ID back
                 if result and result.get("session_id"):
@@ -747,108 +759,45 @@ def _run_interactive(
                     if response:
                         # Continue session with user's choice
                         stream = client.agent_continue_stream(session_id, response)
-                        result = renderer.render_stream(stream)
+                        result = _render_with_interrupt(renderer, stream)
 
-                        # Update mode if user chose tasks or code
-                        if "tasks" in response.lower():
-                            current_mode = AgentMode.TASKS
-                        elif "code" in response.lower():
+                        # Update mode if user chose code
+                        if "code" in response.lower():
                             current_mode = AgentMode.CODE
 
                 # Handle plan mode completion (show approval menu)
-                # In plan mode, show menu after any substantial response
+                # Only show menu when agent explicitly submits a plan via exit_plan tool
                 content = result.get("content", "")
+                plan_submitted = result.get("plan_submitted")
                 should_show_plan_menu = (
                     current_mode == AgentMode.PLAN and
                     session_id and
-                    len(content) > 100  # Has substantial content
+                    plan_submitted is not None  # Agent called exit_plan tool
                 )
                 if should_show_plan_menu:
-                    choice, feedback = _show_spec_approval_menu()
-
-                    if choice == "tasks":
-                        current_mode = AgentMode.TASKS
-                        # Include the spec content explicitly in the message
-                        tasks_prompt = f"""Generate implementation tasks from this approved specification.
-
-## Approved Specification
-
-{content}
-
-## Your Task
-
-Use your tools to explore the codebase and create implementation tasks:
-
-1. **Explore**: Use semantic_search and code graph tools to find:
-   - Existing related code to modify
-   - Patterns and conventions used in the codebase
-   - Files that will need changes
-
-2. **Generate Tasks**: Create detailed tasks that include:
-   - Task ID (T1, T2, T3...)
-   - Description of what to implement
-   - Specific files to modify (based on your exploration)
-   - Dependencies on other tasks
-   - Complexity estimate (S/M/L)
-   - Acceptance criteria
-
-3. **Order**: Arrange tasks in implementation order, starting with foundational changes.
-
-Output a comprehensive task list that a developer can follow step-by-step."""
-                        stream = client.agent_continue_stream(
-                            session_id,
-                            tasks_prompt
-                        )
-                        result = renderer.render_stream(stream)
-                        # After generating tasks, show tasks menu
-                        content = result.get("content", "")
-                    elif choice == "code":
-                        current_mode = AgentMode.CODE
-                        stream = client.agent_continue_stream(
-                            session_id,
-                            "Start implementing the approved spec."
-                        )
-                        renderer.render_stream(stream)
-                    elif choice == "refine":
-                        stream = client.agent_continue_stream(
-                            session_id,
-                            f"Please update the spec based on this feedback: {feedback}"
-                        )
-                        renderer.render_stream(stream)
-                    elif choice == "abort":
-                        console.print("[dim]Spec discarded[/dim]")
-                        session_id = None
-                        current_spec = None
-
-                # Handle tasks mode completion (show tasks approval menu)
-                should_show_tasks_menu = (
-                    current_mode == AgentMode.TASKS and
-                    session_id and
-                    len(content) > 100  # Has substantial content
-                )
-                if should_show_tasks_menu:
-                    choice, feedback = _show_tasks_approval_menu()
+                    choice, feedback = _show_plan_approval_menu()
 
-                    if choice == "code":
+                    if choice == "approve":
                         current_mode = AgentMode.CODE
+                        # Reset mode state to CODE
+                        from emdash_core.agent.tools.modes import ModeState, AgentMode as CoreMode
+                        ModeState.get_instance().current_mode = CoreMode.CODE
                         stream = client.agent_continue_stream(
                             session_id,
-                            "Start implementing the first task from the task list."
-                        )
-                        renderer.render_stream(stream)
-                    elif choice == "refine":
-                        stream = client.agent_continue_stream(
-                            session_id,
-                            f"Please update the tasks based on this feedback: {feedback}"
+                            "The plan has been approved. Start implementing it now."
                         )
-                        renderer.render_stream(stream)
-                    elif choice == "export":
-                        console.print("[dim]Exporting tasks...[/dim]")
-                        # TODO: Implement export functionality
-                        console.print("[yellow]Export not implemented yet[/yellow]")
-                    elif choice == "abort":
-                        console.print("[dim]Tasks discarded[/dim]")
-                        session_id = None
+                        _render_with_interrupt(renderer, stream)
+                    elif choice == "reject":
+                        if feedback:
+                            stream = client.agent_continue_stream(
+                                session_id,
+                                f"The plan was rejected. Please revise based on this feedback: {feedback}"
+                            )
+                            _render_with_interrupt(renderer, stream)
+                        else:
+                            console.print("[dim]Plan rejected[/dim]")
+                            session_id = None
+                            current_spec = None
 
                 console.print()