emdash-cli 0.1.8__tar.gz → 0.1.60__tar.gz

{emdash_cli-0.1.8 → emdash_cli-0.1.60}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emdash-cli
-Version: 0.1.8
+Version: 0.1.60
 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.8)
+Requires-Dist: emdash-core (>=0.1.60)
 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.60/emdash_cli/__init__.py

@@ -0,0 +1,23 @@
+"""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")
+except PackageNotFoundError:
+    __version__ = "0.0.0-dev"

{emdash_cli-0.1.8 → emdash_cli-0.1.60}/emdash_cli/client.py

@@ -1,10 +1,16 @@
 """HTTP client for emdash-core API."""
 
+import os
 from typing import Any, Iterator, Optional
 
 import httpx
 
 
+def _get_max_iterations() -> int:
+    """Get max iterations from env var with default."""
+    return int(os.getenv("EMDASH_MAX_ITERATIONS", "100"))
+
+
 class EmdashClient:
     """HTTP client for interacting with emdash-core API.
 
@@ -44,8 +50,10 @@ class EmdashClient:
         message: str,
         model: Optional[str] = None,
         session_id: Optional[str] = None,
-        max_iterations: int = 20,
+        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.
 
@@ -55,6 +63,8 @@ class EmdashClient:
             session_id: Session ID for continuity (optional)
             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
@@ -81,40 +91,185 @@ class EmdashClient:
             payload["model"] = model
         if session_id:
             payload["session_id"] = session_id
-
-        with self._client.stream(
-            "POST",
-            f"{self.base_url}/api/agent/chat",
-            json=payload,
-        ) as response:
-            response.raise_for_status()
-            for line in response.iter_lines():
-                yield line
+        if images:
+            payload["images"] = images
+        if history:
+            payload["history"] = history
+
+        try:
+            with self._client.stream(
+                "POST",
+                f"{self.base_url}/api/agent/chat",
+                json=payload,
+            ) as response:
+                response.raise_for_status()
+                for line in response.iter_lines():
+                    yield line
+        except GeneratorExit:
+            # Stream was closed early (interrupted)
+            pass
 
     def agent_continue_stream(
         self,
         session_id: str,
         message: str,
+        images: Optional[list[dict]] = None,
     ) -> Iterator[str]:
         """Continue an existing agent session.
 
         Args:
             session_id: Existing session ID
             message: Continuation message
+            images: List of images [{"data": base64_str, "format": "png"}]
 
         Yields:
             SSE lines from the response
         """
         payload = {"message": message}
+        if images:
+            payload["images"] = images
+
+        try:
+            with self._client.stream(
+                "POST",
+                f"{self.base_url}/api/agent/chat/{session_id}/continue",
+                json=payload,
+            ) as response:
+                response.raise_for_status()
+                for line in response.iter_lines():
+                    yield line
+        except GeneratorExit:
+            # Stream was closed early (interrupted)
+            pass
+
+    def plan_approve_stream(self, session_id: str) -> Iterator[str]:
+        """Approve a pending plan and start implementation.
 
-        with self._client.stream(
-            "POST",
-            f"{self.base_url}/api/agent/chat/{session_id}/continue",
-            json=payload,
-        ) as response:
-            response.raise_for_status()
-            for line in response.iter_lines():
-                yield line
+        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 post(self, path: str, json: dict | None = None) -> "httpx.Response":
+        """Make a POST request to the API.
+
+        Args:
+            path: API path (e.g., "/api/agent/chat/123/compact")
+            json: Optional JSON body
+
+        Returns:
+            HTTP response
+        """
+        return self._client.post(f"{self.base_url}{path}", json=json)
 
     def list_sessions(self) -> list[dict]:
         """List active agent sessions.
@@ -476,7 +631,7 @@ class EmdashClient:
     def research_stream(
         self,
         goal: str,
-        max_iterations: int = 50,
+        max_iterations: int = _get_max_iterations(),
         budget: int = 50,
         model: Optional[str] = None,
     ) -> Iterator[str]:
@@ -517,31 +672,38 @@ class EmdashClient:
         response.raise_for_status()
         return response.json()
 
-    # ==================== Swarm ====================
+    # ==================== Todos ====================
 
-    def swarm_run_stream(
-        self,
-        tasks: list[str],
-        model: Optional[str] = None,
-        auto_merge: bool = False,
-    ) -> Iterator[str]:
-        """Run multi-agent swarm with SSE streaming."""
-        payload = {"tasks": tasks, "auto_merge": auto_merge}
-        if model:
-            payload["model"] = model
+    def get_todos(self, session_id: str) -> dict:
+        """Get the current todo list for a session.
 
-        with self._client.stream(
-            "POST",
-            f"{self.base_url}/api/swarm/run",
-            json=payload,
-        ) as response:
-            response.raise_for_status()
-            for line in response.iter_lines():
-                yield line
+        Args:
+            session_id: Session ID
 
-    def swarm_status(self) -> dict:
-        """Get swarm execution status."""
-        response = self._client.get(f"{self.base_url}/api/swarm/status")
+        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()
 

emdash_cli-0.1.60/emdash_cli/clipboard.py

@@ -0,0 +1,92 @@
+"""Clipboard utilities for image handling.
+
+Uses platform-native clipboard access (no Pillow dependency).
+"""
+
+import base64
+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.
+
+    Returns:
+        Tuple of (base64_data, format) if image found, None otherwise.
+    """
+    try:
+        if not is_clipboard_image_available():
+            return None
+
+        image_data = read_clipboard_image()
+        if image_data is None:
+            return None
+
+        # Encode to base64
+        base64_data = base64.b64encode(image_data).decode('utf-8')
+        return base64_data, 'png'
+
+    except ClipboardImageError:
+        return None
+    except Exception:
+        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
+
+    Returns:
+        Tuple of (base64_data, format) if successful, None otherwise.
+    """
+    try:
+        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'):
+            img_format = 'jpeg'
+        elif ext == 'png':
+            img_format = 'png'
+        elif ext == 'gif':
+            img_format = 'gif'
+        elif ext == 'webp':
+            img_format = 'webp'
+        else:
+            img_format = 'png'
+
+        base64_data = base64.b64encode(image_data).decode('utf-8')
+        return base64_data, img_format
+
+    except Exception:
+        return None
+
+
+def get_image_dimensions(base64_data: str) -> Optional[Tuple[int, int]]:
+    """Get dimensions of base64-encoded PNG image.
+
+    Args:
+        base64_data: Base64-encoded image data
+
+    Returns:
+        Tuple of (width, height) if successful, None otherwise.
+    """
+    try:
+        image_bytes = base64.b64decode(base64_data)
+        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-0.1.8 → emdash_cli-0.1.60}/emdash_cli/commands/__init__.py

@@ -7,11 +7,12 @@ from .analyze import analyze
 from .embed import embed
 from .index import index
 from .plan import plan
+from .registry import registry
 from .rules import rules
 from .search import search
 from .server import server
+from .skills import skills
 from .team import team
-from .swarm import swarm
 from .projectmd import projectmd
 from .research import research
 from .spec import spec
@@ -25,11 +26,12 @@ __all__ = [
     "embed",
     "index",
     "plan",
+    "registry",
     "rules",
     "search",
     "server",
+    "skills",
     "team",
-    "swarm",
     "projectmd",
     "research",
     "spec",

emdash_cli-0.1.60/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-0.1.60/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-0.1.60/emdash_cli/commands/agent/constants.py

@@ -0,0 +1,61 @@
+"""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",
+    "/diff": "Show uncommitted changes in GitHub-style diff view",
+    "/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)",
+    # Index
+    "/index": "Manage codebase index (status, start, hook install/uninstall)",
+    # MCP
+    "/mcp": "Manage global MCP servers (list, edit)",
+    # Registry
+    "/registry": "Browse and install community skills, rules, agents, verifiers",
+    # Auth
+    "/auth": "GitHub authentication (login, logout, status)",
+    # Context
+    "/context": "Show current context frame (tokens, reranked items)",
+    "/compact": "Compact message history using LLM summarization",
+    # Image
+    "/paste": "Attach image from clipboard (or use Ctrl+V)",
+    # 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",
+}