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

emdash_cli/__init__.py

@@ -1,6 +1,21 @@
 """EmDash CLI - Command-line interface for code intelligence."""
 
 from importlib.metadata import version, PackageNotFoundError
+from pathlib import Path
+
+# Load .env files early so env vars are available for server subprocess
+try:
+    from dotenv import load_dotenv
+    # Try to find .env in current dir or parent dirs
+    current = Path.cwd()
+    for _ in range(5):
+        env_path = current / ".env"
+        if env_path.exists():
+            load_dotenv(env_path, override=True)
+            break
+        current = current.parent
+except ImportError:
+    pass  # dotenv not installed
 
 try:
     __version__ = version("emdash-cli")

emdash_cli/client.py

@@ -53,6 +53,7 @@ class EmdashClient:
         max_iterations: int = _get_max_iterations(),
         options: Optional[dict] = None,
         images: Optional[list[dict]] = None,
+        history: Optional[list[dict]] = None,
     ) -> Iterator[str]:
         """Stream agent chat response via SSE.
 
@@ -63,6 +64,7 @@ class EmdashClient:
             max_iterations: Max agent iterations
             options: Additional options (mode, save, no_graph_tools, etc.)
             images: List of images [{"data": base64_str, "format": "png"}]
+            history: Pre-loaded conversation history from saved session
 
         Yields:
             SSE lines from the response
@@ -91,6 +93,8 @@ class EmdashClient:
             payload["session_id"] = session_id
         if images:
             payload["images"] = images
+        if history:
+            payload["history"] = history
 
         try:
             with self._client.stream(
@@ -138,6 +142,123 @@ class EmdashClient:
             # Stream was closed early (interrupted)
             pass
 
+    def plan_approve_stream(self, session_id: str) -> Iterator[str]:
+        """Approve a pending plan and start implementation.
+
+        Args:
+            session_id: Session ID with pending plan
+
+        Yields:
+            SSE lines from the response
+        """
+        try:
+            with self._client.stream(
+                "POST",
+                f"{self.base_url}/api/agent/chat/{session_id}/plan/approve",
+            ) as response:
+                response.raise_for_status()
+                for line in response.iter_lines():
+                    yield line
+        except GeneratorExit:
+            pass
+
+    def plan_reject_stream(self, session_id: str, feedback: str = "") -> Iterator[str]:
+        """Reject a pending plan with feedback.
+
+        Args:
+            session_id: Session ID with pending plan
+            feedback: Feedback explaining rejection
+
+        Yields:
+            SSE lines from the response
+        """
+        try:
+            with self._client.stream(
+                "POST",
+                f"{self.base_url}/api/agent/chat/{session_id}/plan/reject",
+                params={"feedback": feedback},
+            ) as response:
+                response.raise_for_status()
+                for line in response.iter_lines():
+                    yield line
+        except GeneratorExit:
+            pass
+
+    def planmode_approve_stream(self, session_id: str) -> Iterator[str]:
+        """Approve entering plan mode.
+
+        Args:
+            session_id: Session ID requesting plan mode
+
+        Yields:
+            SSE lines from the response
+        """
+        try:
+            with self._client.stream(
+                "POST",
+                f"{self.base_url}/api/agent/chat/{session_id}/planmode/approve",
+            ) as response:
+                response.raise_for_status()
+                for line in response.iter_lines():
+                    yield line
+        except GeneratorExit:
+            pass
+
+    def planmode_reject_stream(self, session_id: str, feedback: str = "") -> Iterator[str]:
+        """Reject entering plan mode.
+
+        Args:
+            session_id: Session ID requesting plan mode
+            feedback: Feedback explaining rejection
+
+        Yields:
+            SSE lines from the response
+        """
+        try:
+            with self._client.stream(
+                "POST",
+                f"{self.base_url}/api/agent/chat/{session_id}/planmode/reject",
+                params={"feedback": feedback},
+            ) as response:
+                response.raise_for_status()
+                for line in response.iter_lines():
+                    yield line
+        except GeneratorExit:
+            pass
+
+    def clarification_answer_stream(self, session_id: str, answer: str) -> Iterator[str]:
+        """Answer a pending clarification question.
+
+        Args:
+            session_id: Session ID with pending clarification
+            answer: User's answer to the clarification question
+
+        Yields:
+            SSE lines from the response
+        """
+        try:
+            with self._client.stream(
+                "POST",
+                f"{self.base_url}/api/agent/chat/{session_id}/clarification/answer",
+                params={"answer": answer},
+            ) as response:
+                response.raise_for_status()
+                for line in response.iter_lines():
+                    yield line
+        except GeneratorExit:
+            pass
+
+    def get(self, path: str) -> "httpx.Response":
+        """Make a GET request to the API.
+
+        Args:
+            path: API path (e.g., "/api/agent/sessions")
+
+        Returns:
+            HTTP response
+        """
+        return self._client.get(f"{self.base_url}{path}")
+
     def list_sessions(self) -> list[dict]:
         """List active agent sessions.
 
@@ -567,6 +688,41 @@ class EmdashClient:
         response.raise_for_status()
         return response.json()
 
+    # ==================== Todos ====================
+
+    def get_todos(self, session_id: str) -> dict:
+        """Get the current todo list for a session.
+
+        Args:
+            session_id: Session ID
+
+        Returns:
+            Dict with todos list and summary
+        """
+        response = self._client.get(
+            f"{self.base_url}/api/agent/chat/{session_id}/todos"
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def add_todo(self, session_id: str, title: str, description: str = "") -> dict:
+        """Add a new todo item to the agent's task list.
+
+        Args:
+            session_id: Session ID
+            title: Todo title
+            description: Optional description
+
+        Returns:
+            Dict with created task info
+        """
+        response = self._client.post(
+            f"{self.base_url}/api/agent/chat/{session_id}/todos",
+            params={"title": title, "description": description},
+        )
+        response.raise_for_status()
+        return response.json()
+
     def close(self) -> None:
         """Close the HTTP client."""
         self._client.close()

emdash_cli/clipboard.py

@@ -1,9 +1,18 @@
-"""Clipboard utilities for image handling."""
+"""Clipboard utilities for image handling.
+
+Uses platform-native clipboard access (no Pillow dependency).
+"""
 
 import base64
-import io
 from typing import Optional, Tuple
 
+from emdash_core.utils.image import (
+    read_clipboard_image,
+    is_clipboard_image_available,
+    get_image_info,
+    ClipboardImageError,
+)
+
 
 def get_clipboard_image() -> Optional[Tuple[str, str]]:
     """Get image from clipboard if available.
@@ -12,57 +21,28 @@ def get_clipboard_image() -> Optional[Tuple[str, str]]:
         Tuple of (base64_data, format) if image found, None otherwise.
     """
     try:
-        from PIL import ImageGrab, Image
-
-        # Try to grab image from clipboard
-        image = ImageGrab.grabclipboard()
+        if not is_clipboard_image_available():
+            return None
 
-        if image is None:
+        image_data = read_clipboard_image()
+        if image_data is None:
             return None
 
-        # Handle list of file paths (Windows)
-        if isinstance(image, list):
-            # It's a list of file paths
-            if image and isinstance(image[0], str):
-                try:
-                    image = Image.open(image[0])
-                except Exception:
-                    return None
-            else:
-                return None
-
-        # Convert to PNG bytes
-        if isinstance(image, Image.Image):
-            buffer = io.BytesIO()
-            # Convert to RGB if necessary (for RGBA images)
-            if image.mode in ('RGBA', 'LA') or (image.mode == 'P' and 'transparency' in image.info):
-                # Keep as PNG to preserve transparency
-                image.save(buffer, format='PNG')
-                img_format = 'png'
-            else:
-                # Convert to JPEG for smaller size
-                if image.mode != 'RGB':
-                    image = image.convert('RGB')
-                image.save(buffer, format='JPEG', quality=85)
-                img_format = 'jpeg'
-
-            buffer.seek(0)
-            base64_data = base64.b64encode(buffer.read()).decode('utf-8')
-            return base64_data, img_format
-
-    except ImportError:
-        # PIL not available
+        # Encode to base64
+        base64_data = base64.b64encode(image_data).decode('utf-8')
+        return base64_data, 'png'
+
+    except ClipboardImageError:
         return None
     except Exception:
-        # Any other error (no clipboard access, etc.)
         return None
 
-    return None
-
 
 def get_image_from_path(path: str) -> Optional[Tuple[str, str]]:
     """Load image from file path.
 
+    Only PNG files are fully supported. Other formats will be read as raw bytes.
+
     Args:
         path: Path to image file
 
@@ -70,34 +50,23 @@ def get_image_from_path(path: str) -> Optional[Tuple[str, str]]:
         Tuple of (base64_data, format) if successful, None otherwise.
     """
     try:
-        from PIL import Image
-
-        image = Image.open(path)
-        buffer = io.BytesIO()
+        with open(path, 'rb') as f:
+            image_data = f.read()
 
         # Determine format from file extension
         ext = path.lower().split('.')[-1]
         if ext in ('jpg', 'jpeg'):
-            if image.mode != 'RGB':
-                image = image.convert('RGB')
-            image.save(buffer, format='JPEG', quality=85)
             img_format = 'jpeg'
         elif ext == 'png':
-            image.save(buffer, format='PNG')
             img_format = 'png'
         elif ext == 'gif':
-            image.save(buffer, format='GIF')
             img_format = 'gif'
         elif ext == 'webp':
-            image.save(buffer, format='WEBP')
             img_format = 'webp'
         else:
-            # Default to PNG
-            image.save(buffer, format='PNG')
             img_format = 'png'
 
-        buffer.seek(0)
-        base64_data = base64.b64encode(buffer.read()).decode('utf-8')
+        base64_data = base64.b64encode(image_data).decode('utf-8')
         return base64_data, img_format
 
     except Exception:
@@ -105,7 +74,7 @@ def get_image_from_path(path: str) -> Optional[Tuple[str, str]]:
 
 
 def get_image_dimensions(base64_data: str) -> Optional[Tuple[int, int]]:
-    """Get dimensions of base64-encoded image.
+    """Get dimensions of base64-encoded PNG image.
 
     Args:
         base64_data: Base64-encoded image data
@@ -114,10 +83,10 @@ def get_image_dimensions(base64_data: str) -> Optional[Tuple[int, int]]:
         Tuple of (width, height) if successful, None otherwise.
     """
     try:
-        from PIL import Image
-
         image_bytes = base64.b64decode(base64_data)
-        image = Image.open(io.BytesIO(image_bytes))
-        return image.size
+        info = get_image_info(image_bytes)
+        if info.get("width") and info.get("height"):
+            return info["width"], info["height"]
+        return None
     except Exception:
         return None

emdash_cli/commands/agent/__init__.py

@@ -0,0 +1,14 @@
+"""Agent CLI commands package.
+
+This package contains the refactored agent CLI code, split into:
+- cli.py: Click command definitions
+- constants.py: Enums and constants
+- file_utils.py: File reference expansion utilities
+- menus.py: Interactive prompt_toolkit menus
+- interactive.py: Main REPL loop
+- handlers/: Slash command handlers
+"""
+
+from .cli import agent, agent_code
+
+__all__ = ["agent", "agent_code"]

emdash_cli/commands/agent/cli.py

@@ -0,0 +1,100 @@
+"""Click CLI commands for the agent."""
+
+import os
+
+import click
+from rich.console import Console
+
+from ...client import EmdashClient
+from ...server_manager import get_server_manager
+from ...sse_renderer import SSERenderer
+from .interactive import run_interactive, run_single_task
+
+console = Console()
+
+
+@click.group()
+def agent():
+    """AI agent commands."""
+    pass
+
+
+@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", "code"]), default="code",
+              help="Starting mode")
+@click.option("--quiet", "-q", is_flag=True, help="Less verbose output")
+@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(
+    task: str | None,
+    model: str | None,
+    mode: str,
+    quiet: bool,
+    max_iterations: int,
+    no_graph_tools: bool,
+    save: bool,
+):
+    """Start the coding agent.
+
+    With TASK: Run single task and exit
+    Without TASK: Start interactive REPL mode
+
+    MODES:
+      plan   - Explore codebase and create plans (read-only)
+      code   - Execute code changes (default)
+
+    SLASH COMMANDS (in interactive mode):
+      /plan   - Switch to plan mode
+      /code   - Switch to code mode
+      /help   - Show available commands
+      /reset  - Reset session
+
+    Examples:
+        emdash                                         # Interactive code mode
+        emdash agent code                              # Same as above
+        emdash agent code --mode plan                  # Start in plan mode
+        emdash agent code "Fix the login bug"          # Single task
+    """
+    # Get server URL (starts server if needed)
+    server = get_server_manager()
+    base_url = server.get_server_url()
+
+    client = EmdashClient(base_url)
+    renderer = SSERenderer(console=console, verbose=not quiet)
+
+    options = {
+        "mode": mode,
+        "no_graph_tools": no_graph_tools,
+        "save": save,
+    }
+
+    if task:
+        # Single task mode
+        run_single_task(client, renderer, task, model, max_iterations, options)
+    else:
+        # Interactive REPL mode
+        run_interactive(client, renderer, model, max_iterations, options)
+
+
+@agent.command("sessions")
+def list_sessions():
+    """List active agent sessions."""
+    server = get_server_manager()
+    base_url = server.get_server_url()
+
+    client = EmdashClient(base_url)
+    sessions = client.list_sessions()
+
+    if not sessions:
+        console.print("[dim]No active sessions[/dim]")
+        return
+
+    for s in sessions:
+        console.print(
+            f"  {s['session_id'][:8]}... "
+            f"[dim]({s.get('model', 'unknown')}, "
+            f"{s.get('message_count', 0)} messages)[/dim]"
+        )

emdash_cli/commands/agent/constants.py

@@ -0,0 +1,53 @@
+"""Constants and enums for the agent CLI."""
+
+from enum import Enum
+
+
+class AgentMode(Enum):
+    """Agent operation modes."""
+    PLAN = "plan"
+    CODE = "code"
+
+
+# Slash commands available in interactive mode
+SLASH_COMMANDS = {
+    # Mode switching
+    "/plan": "Switch to plan mode (explore codebase, create plans)",
+    "/code": "Switch to code mode (execute file changes)",
+    "/mode": "Show current mode",
+    # Generation commands
+    "/pr [url]": "Review a pull request",
+    "/projectmd": "Generate PROJECT.md for the codebase",
+    "/research [goal]": "Deep research on a topic",
+    # Status commands
+    "/status": "Show index and PROJECT.md status",
+    "/agents": "Manage agents (interactive menu, or /agents [create|show|edit|delete] <name>)",
+    # Todo management
+    "/todos": "Show current agent todo list",
+    "/todo-add [title]": "Add a todo item for the agent (e.g., /todo-add Fix tests)",
+    # Session management
+    "/session": "Save, load, or list sessions (e.g., /session save my-task)",
+    "/spec": "Show current specification",
+    "/reset": "Reset session state",
+    # Hooks
+    "/hooks": "Manage hooks (list, add, remove, toggle)",
+    # Rules
+    "/rules": "Manage rules (list, add, delete)",
+    # Skills
+    "/skills": "Manage skills (list, show, add, delete)",
+    # MCP
+    "/mcp": "Manage global MCP servers (list, edit)",
+    # Auth
+    "/auth": "GitHub authentication (login, logout, status)",
+    # Context
+    "/context": "Show current context frame (tokens, reranked items)",
+    # Diagnostics
+    "/doctor": "Check Python environment and diagnose issues",
+    # Verification
+    "/verify": "Run verification checks on current work",
+    "/verify-loop [task]": "Run task in loop until verifications pass",
+    # Setup wizard
+    "/setup": "Setup wizard for rules, agents, skills, and verifiers",
+    "/help": "Show available commands",
+    "/quit": "Exit the agent",
+}