emdash-cli 0.1.25__py3-none-any.whl → 0.1.35__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

@@ -52,6 +52,8 @@ class EmdashClient:
         session_id: Optional[str] = None,
         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.
 
@@ -61,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
@@ -87,6 +91,10 @@ class EmdashClient:
             payload["model"] = model
         if session_id:
             payload["session_id"] = session_id
+        if images:
+            payload["images"] = images
+        if history:
+            payload["history"] = history
 
         try:
             with self._client.stream(
@@ -105,17 +113,21 @@ class EmdashClient:
         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(
@@ -130,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.
 

emdash_cli/clipboard.py

@@ -0,0 +1,123 @@
+"""Clipboard utilities for image handling."""
+
+import base64
+import io
+from typing import Optional, Tuple
+
+
+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:
+        from PIL import ImageGrab, Image
+
+        # Try to grab image from clipboard
+        image = ImageGrab.grabclipboard()
+
+        if image 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
+        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.
+
+    Args:
+        path: Path to image file
+
+    Returns:
+        Tuple of (base64_data, format) if successful, None otherwise.
+    """
+    try:
+        from PIL import Image
+
+        image = Image.open(path)
+        buffer = io.BytesIO()
+
+        # 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')
+        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 image.
+
+    Args:
+        base64_data: Base64-encoded image data
+
+    Returns:
+        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
+    except Exception:
+        return None