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

emdash_cli/client.py

@@ -259,6 +259,18 @@ class EmdashClient:
         """
         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.
 
@@ -660,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/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/__init__.py

@@ -7,12 +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
@@ -26,12 +26,12 @@ __all__ = [
     "embed",
     "index",
     "plan",
+    "registry",
     "rules",
     "search",
     "server",
     "skills",
     "team",
-    "swarm",
     "projectmd",
     "research",
     "spec",

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,63 @@
+"""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",
+    # Telegram integration
+    "/telegram": "Telegram integration (setup, connect, status, test)",
+    "/help": "Show available commands",
+    "/quit": "Exit the agent",
+}

emdash_cli/commands/agent/file_utils.py

@@ -0,0 +1,178 @@
+"""File utilities for the agent CLI.
+
+Handles @file reference expansion and fuzzy file finding.
+"""
+
+import fnmatch
+import os
+import re
+from pathlib import Path
+
+from rich.console import Console
+
+console = Console()
+
+
+def fuzzy_find_files(query: str, limit: int = 10) -> list[Path]:
+    """Find files matching a fuzzy query.
+
+    Args:
+        query: File name or partial path to search for
+        limit: Maximum number of results
+
+    Returns:
+        List of matching file paths
+    """
+    cwd = Path.cwd()
+    matches = []
+
+    # Common directories to skip
+    skip_dirs = {'.git', 'node_modules', '__pycache__', '.venv', 'venv', 'dist', 'build', '.emdash'}
+
+    # Walk the directory tree (more control than glob for skipping dirs)
+    for root, dirs, files in os.walk(cwd):
+        # Skip unwanted directories
+        dirs[:] = [d for d in dirs if d not in skip_dirs and not d.startswith('.')]
+
+        rel_root = Path(root).relative_to(cwd)
+
+        for file in files:
+            # Skip hidden files
+            if file.startswith('.'):
+                continue
+
+            rel_path = rel_root / file if str(rel_root) != '.' else Path(file)
+            full_path = cwd / rel_path
+
+            # Check if query matches (case-insensitive)
+            path_str = str(rel_path).lower()
+            query_lower = query.lower()
+
+            if query_lower in path_str or fnmatch.fnmatch(path_str, f"*{query_lower}*"):
+                matches.append(full_path)
+
+                if len(matches) >= limit:
+                    return matches
+
+    return matches
+
+
+def select_file_interactive(matches: list[Path], query: str) -> Path | None:
+    """Show interactive file selection menu.
+
+    Args:
+        matches: List of matching file paths
+        query: Original query string
+
+    Returns:
+        Selected file path or None if cancelled
+    """
+    if not matches:
+        return None
+
+    if len(matches) == 1:
+        return matches[0]
+
+    cwd = Path.cwd()
+
+    # Print numbered list
+    console.print(f"\n[bold cyan]Select file for @{query}:[/bold cyan]\n")
+
+    for i, path in enumerate(matches):
+        try:
+            rel_path = path.relative_to(cwd)
+        except ValueError:
+            rel_path = path
+        console.print(f"  [bold]{i + 1}[/bold]) {rel_path}")
+
+    console.print(f"\n[dim]Enter number (1-{len(matches)}) or press Enter to cancel:[/dim]")
+
+    try:
+        from prompt_toolkit import PromptSession
+        selection_session = PromptSession()
+        choice = selection_session.prompt("").strip()
+        if choice.isdigit():
+            idx = int(choice) - 1
+            if 0 <= idx < len(matches):
+                return matches[idx]
+    except (KeyboardInterrupt, EOFError):
+        pass
+
+    return None
+
+
+def expand_file_references(message: str) -> tuple[str, list[str]]:
+    """Expand @file references in a message to include file contents.
+
+    Supports:
+    - @file.txt - exact path (relative or absolute)
+    - @utils - fuzzy search for files containing "utils"
+    - @~/path/file.txt - home directory paths
+
+    Shows interactive selection if multiple files match.
+
+    Args:
+        message: User message potentially containing @file references
+
+    Returns:
+        Tuple of (expanded_message, list_of_included_files)
+    """
+    # Pattern to match @word (not followed by space immediately, at least 2 chars)
+    pattern = r'@([^\s@]{2,})'
+
+    files_included = []
+    file_contents = []
+    replacements = {}  # Store replacements to apply after iteration
+
+    # Find all @references
+    for match in re.finditer(pattern, message):
+        file_query = match.group(1)
+        original = match.group(0)
+
+        # Skip if already processed
+        if original in replacements:
+            continue
+
+        # Expand ~ to home directory
+        if file_query.startswith("~"):
+            file_query_expanded = os.path.expanduser(file_query)
+        else:
+            file_query_expanded = file_query
+
+        # Check if it's an exact path first
+        path = Path(file_query_expanded)
+        if not path.is_absolute():
+            path = Path.cwd() / path
+
+        resolved_path = None
+
+        if path.exists() and path.is_file():
+            # Exact match
+            resolved_path = path
+        else:
+            # Fuzzy search
+            matches = fuzzy_find_files(file_query)
+            if matches:
+                resolved_path = select_file_interactive(matches, file_query)
+
+        if resolved_path:
+            try:
+                content = resolved_path.read_text()
+                files_included.append(str(resolved_path))
+                file_contents.append(f"\n\n**File: {resolved_path.name}**\n```\n{content}\n```")
+                replacements[original] = ""  # Remove the @reference
+            except Exception:
+                pass  # Can't read file, leave as-is
+
+    # Apply replacements
+    expanded_message = message
+    for original, replacement in replacements.items():
+        expanded_message = expanded_message.replace(original, replacement)
+
+    expanded_message = expanded_message.strip()
+
+    # Append file contents to the message
+    if file_contents:
+        expanded_message = expanded_message + "\n" + "\n".join(file_contents)
+
+    return expanded_message, files_included

emdash_cli/commands/agent/handlers/__init__.py

@@ -0,0 +1,51 @@
+"""Slash command handlers for the agent CLI."""
+
+from .agents import handle_agents
+from .sessions import handle_session
+from .todos import handle_todos, handle_todo_add
+from .hooks import handle_hooks
+from .rules import handle_rules
+from .skills import handle_skills
+from .index import handle_index
+from .mcp import handle_mcp
+from .registry import handle_registry
+from .auth import handle_auth
+from .doctor import handle_doctor
+from .verify import handle_verify, handle_verify_loop
+from .setup import handle_setup
+from .misc import (
+    handle_status,
+    handle_pr,
+    handle_projectmd,
+    handle_research,
+    handle_context,
+    handle_compact,
+    handle_diff,
+)
+from .telegram import handle_telegram
+
+__all__ = [
+    "handle_agents",
+    "handle_session",
+    "handle_todos",
+    "handle_todo_add",
+    "handle_hooks",
+    "handle_rules",
+    "handle_skills",
+    "handle_index",
+    "handle_mcp",
+    "handle_registry",
+    "handle_auth",
+    "handle_doctor",
+    "handle_verify",
+    "handle_verify_loop",
+    "handle_setup",
+    "handle_status",
+    "handle_pr",
+    "handle_projectmd",
+    "handle_research",
+    "handle_context",
+    "handle_compact",
+    "handle_diff",
+    "handle_telegram",
+]