emdash-core 0.1.37__py3-none-any.whl → 0.1.60__py3-none-any.whl

emdash_core/models/agent.py

@@ -1,11 +1,17 @@
 """Pydantic models for agent API."""
 
+import os
 from enum import Enum
 from typing import Optional
 
 from pydantic import BaseModel, Field
 
 
+def _default_use_worktree() -> bool:
+    """Get default worktree setting from environment."""
+    return os.environ.get("EMDASH_USE_WORKTREE", "false").lower() in ("true", "1", "yes")
+
+
 class AgentMode(str, Enum):
     """Agent operation modes."""
 
@@ -33,6 +39,10 @@ class AgentChatOptions(BaseModel):
         default=0.6,
         description="Context window threshold for summarization (0-1)"
     )
+    use_worktree: bool = Field(
+        default_factory=_default_use_worktree,
+        description="Use git worktree for isolated changes (EMDASH_USE_WORKTREE env)"
+    )
 
 
 class AgentChatRequest(BaseModel):

emdash_core/server.py

@@ -89,18 +89,13 @@ async def lifespan(app: FastAPI):
     if config.repo_root:
         print(f"Repository root: {config.repo_root}")
 
-    # Write port file for CLI/Electron discovery
-    port_file = Path.home() / ".emdash" / "server.port"
-    port_file.parent.mkdir(parents=True, exist_ok=True)
-    port_file.write_text(str(config.port))
+    # Note: Port file management is handled by ServerManager (per-repo files)
 
     yield
 
     # Shutdown
     print("EmDash Core shutting down...")
     _shutdown_executors()
-    if port_file.exists():
-        port_file.unlink()
 
 
 def create_app(

emdash_core/sse/stream.py

@@ -8,6 +8,8 @@ from typing import Any, AsyncIterator
 
 from pydantic import BaseModel
 
+from ..utils.logger import log
+
 
 class EventType(str, Enum):
     """Types of events emitted by agents (matches emdash.agent.events.EventType)."""
@@ -27,10 +29,12 @@ class EventType(str, Enum):
     # Output
     RESPONSE = "response"
     PARTIAL_RESPONSE = "partial_response"
+    ASSISTANT_TEXT = "assistant_text"
 
     # Interaction
     CLARIFICATION = "clarification"
     CLARIFICATION_RESPONSE = "clarification_response"
+    PLAN_MODE_REQUESTED = "plan_mode_requested"
     PLAN_SUBMITTED = "plan_submitted"
 
     # Errors
@@ -100,9 +104,20 @@ class SSEHandler:
         if self._closed:
             return
 
+        # Convert event type, with error handling for unknown types
+        try:
+            event_type = EventType(event.type.value)
+        except ValueError:
+            log.warning(
+                f"Unknown SSE event type: {event.type.value} - event dropped. "
+                "This may indicate EventType enum in sse/stream.py is out of sync "
+                "with agent/events.py"
+            )
+            return
+
         # Convert to SSEEvent
         sse_event = SSEEvent(
-            type=EventType(event.type.value),
+            type=event_type,
             data=event.data,
             timestamp=event.timestamp,
             agent_name=event.agent_name or self._agent_name,

emdash_core/utils/__init__.py

@@ -7,7 +7,6 @@ from .image import (
     read_clipboard_image,
     encode_image_to_base64,
     encode_image_for_llm,
-    resize_image_if_needed,
     get_image_info,
     estimate_image_tokens,
     read_and_prepare_image,
@@ -31,7 +30,6 @@ __all__ = [
     "read_clipboard_image",
     "encode_image_to_base64",
     "encode_image_for_llm",
-    "resize_image_if_needed",
     "get_image_info",
     "estimate_image_tokens",
     "read_and_prepare_image",

emdash_core/utils/git.py

@@ -82,3 +82,106 @@ def get_normalized_remote_url(repo_root: Path) -> Optional[str]:
     if remote_url:
         return normalize_repo_url(remote_url)
     return None
+
+
+def get_current_branch(repo_root: Path) -> Optional[str]:
+    """Get the current git branch name.
+
+    Args:
+        repo_root: Path to the git repository root
+
+    Returns:
+        The current branch name or None if not found/not in a git repo
+    """
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            cwd=repo_root,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        pass
+    return None
+
+
+def get_git_status_summary(repo_root: Path) -> Optional[str]:
+    """Get a brief summary of git status.
+
+    Args:
+        repo_root: Path to the git repository root
+
+    Returns:
+        Brief status summary (e.g., "3 modified, 2 untracked") or None
+    """
+    try:
+        result = subprocess.run(
+            ["git", "status", "--porcelain"],
+            cwd=repo_root,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode != 0:
+            return None
+
+        lines = result.stdout.strip().split("\n") if result.stdout.strip() else []
+        if not lines:
+            return "clean"
+
+        # Count by status type
+        modified = 0
+        untracked = 0
+        staged = 0
+        deleted = 0
+
+        for line in lines:
+            if not line:
+                continue
+            status = line[:2]
+            if status == "??":
+                untracked += 1
+            elif status[0] in ("M", "A", "D", "R", "C"):
+                staged += 1
+            elif status[1] == "M":
+                modified += 1
+            elif status[1] == "D":
+                deleted += 1
+
+        parts = []
+        if staged:
+            parts.append(f"{staged} staged")
+        if modified:
+            parts.append(f"{modified} modified")
+        if deleted:
+            parts.append(f"{deleted} deleted")
+        if untracked:
+            parts.append(f"{untracked} untracked")
+
+        return ", ".join(parts) if parts else "clean"
+
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        pass
+    return None
+
+
+def get_repo_name(repo_root: Path) -> Optional[str]:
+    """Get the repository name from the remote URL or directory name.
+
+    Args:
+        repo_root: Path to the git repository root
+
+    Returns:
+        Repository name (e.g., "user/repo") or None
+    """
+    remote_url = get_normalized_remote_url(repo_root)
+    if remote_url:
+        # Extract user/repo from https://github.com/user/repo
+        parts = remote_url.rstrip("/").split("/")
+        if len(parts) >= 2:
+            return f"{parts[-2]}/{parts[-1]}"
+    # Fallback to directory name
+    return repo_root.name

emdash_core/utils/image.py

@@ -4,14 +4,16 @@ Provides functions to:
 - Read images from system clipboard
 - Encode images to base64 data URLs
 - Check clipboard image availability
-- Resize large images for LLM processing
+- Get image dimensions
+
+Uses pypng for pure-Python PNG handling (no compilation required).
 """
 
 import base64
 import io
 import os
 import platform
-import sys
+import subprocess
 from enum import Enum
 from typing import Optional
 
@@ -19,16 +21,11 @@ from typing import Optional
 class ImageFormat(str, Enum):
     """Supported image formats."""
     PNG = "png"
-    JPEG = "jpeg"
-    GIF = "gif"
 
 
 # Maximum image size for LLM processing (5MB)
 MAX_IMAGE_SIZE_BYTES = 5 * 1024 * 1024
 
-# Default max dimensions for resized images
-MAX_IMAGE_DIMENSION = 2048
-
 # Tokens per image for context estimation
 ESTIMATED_TOKENS_PER_IMAGE = 500
 
@@ -43,11 +40,11 @@ class ImageProcessingError(Exception):
     pass
 
 
-def _import_pillow():
-    """Try to import PIL, return None if not available."""
+def _import_png():
+    """Try to import pypng, return None if not available."""
     try:
-        from PIL import Image
-        return Image
+        import png
+        return png
     except ImportError:
         return None
 
@@ -66,10 +63,9 @@ def _import_mac_clipboard():
     """Try to import macOS clipboard modules."""
     try:
         import AppKit
-        import objc
-        return AppKit, objc
+        return AppKit
     except ImportError:
-        return None, None
+        return None
 
 
 def is_clipboard_image_available() -> bool:
@@ -108,13 +104,17 @@ def _check_windows_clipboard() -> bool:
 
 def _check_macos_clipboard() -> bool:
     """Check macOS clipboard for image data."""
-    AppKit, objc = _import_mac_clipboard()
+    AppKit = _import_mac_clipboard()
     if AppKit is None:
         return False
 
     try:
         pasteboard = AppKit.NSPasteboard.generalPasteboard()
-        return bool(pasteboard.dataForType_("public.png"))
+        # Check for PNG or TIFF (macOS screenshots use TIFF)
+        return bool(
+            pasteboard.dataForType_("public.png") or
+            pasteboard.dataForType_("public.tiff")
+        )
     except Exception:
         return False
 
@@ -171,12 +171,16 @@ def _read_windows_clipboard() -> Optional[bytes]:
     try:
         win32clipboard.OpenClipboard(0)
         try:
+            # Try to get PNG format first
+            png_format = win32clipboard.RegisterClipboardFormat("PNG")
+            if win32clipboard.IsClipboardFormatAvailable(png_format):
+                data = win32clipboard.GetClipboardData(png_format)
+                return bytes(data)
+
+            # Fall back to DIB and convert
             if win32clipboard.IsClipboardFormatAvailable(win32con.CF_DIB):
                 data = win32clipboard.GetClipboardData(win32con.CF_DIB)
                 return _dib_to_png(data)
-            elif win32clipboard.IsClipboardFormatAvailable(win32con.CF_BITMAP):
-                bitmap = win32clipboard.GetClipboardData(win32con.CF_BITMAP)
-                return _bitmap_to_png(bitmap)
             return None
         finally:
             win32clipboard.CloseClipboard()
@@ -185,47 +189,77 @@ def _read_windows_clipboard() -> Optional[bytes]:
 
 
 def _dib_to_png(dib_data: bytes) -> bytes:
-    """Convert DIB data to PNG bytes."""
-    Image = _import_pillow()
-    if Image is None:
-        raise ClipboardImageError("PIL/Pillow is required for image processing")
+    """Convert DIB (Device Independent Bitmap) data to PNG bytes.
 
+    DIB format: BITMAPINFOHEADER followed by pixel data.
+    """
     import struct
 
-    # Parse DIB header
+    png = _import_png()
+    if png is None:
+        raise ClipboardImageError("pypng is required for image processing")
+
     if len(dib_data) < 40:
         raise ClipboardImageError("Invalid DIB data")
 
+    # Parse BITMAPINFOHEADER (40 bytes)
     header_size = struct.unpack('<I', dib_data[0:4])[0]
-
-    if header_size == 40:  # BITMAPINFOHEADER
-        width = struct.unpack('<I', dib_data[4:8])[0]
-        height = struct.unpack('<I', dib_data[8:12])[0]
-        planes = struct.unpack('<H', dib_data[12:14])[0]
-        bit_count = struct.unpack('<H', dib_data[14:16])[0]
-    else:
-        # Use PIL to handle it
-        with io.BytesIO(dib_data) as bio:
-            img = Image.open(bio)
-            return _image_to_png_bytes(img)
-
-    with io.BytesIO(dib_data) as bio:
-        img = Image.open(bio)
-        return _image_to_png_bytes(img)
-
-
-def _bitmap_to_png(bitmap: int) -> bytes:
-    """Convert Windows bitmap handle to PNG bytes."""
-    Image = _import_pillow()
-    if Image is None:
-        raise ClipboardImageError("PIL/Pillow is required for image processing")
-
-    raise ClipboardImageError("Bitmap handle conversion not implemented")
+    width = struct.unpack('<i', dib_data[4:8])[0]
+    height = struct.unpack('<i', dib_data[8:12])[0]
+    planes = struct.unpack('<H', dib_data[12:14])[0]
+    bit_count = struct.unpack('<H', dib_data[14:16])[0]
+    compression = struct.unpack('<I', dib_data[16:20])[0]
+
+    # Handle negative height (top-down DIB)
+    top_down = height < 0
+    height = abs(height)
+
+    if compression != 0:  # BI_RGB = 0
+        raise ClipboardImageError(f"Unsupported DIB compression: {compression}")
+
+    if bit_count not in (24, 32):
+        raise ClipboardImageError(f"Unsupported DIB bit depth: {bit_count}")
+
+    # Calculate row stride (rows are padded to 4-byte boundaries)
+    bytes_per_pixel = bit_count // 8
+    row_size = ((width * bytes_per_pixel + 3) // 4) * 4
+
+    # Pixel data starts after header (and color table for indexed images)
+    pixel_offset = header_size
+
+    # Extract rows
+    rows = []
+    for y in range(height):
+        if top_down:
+            row_start = pixel_offset + y * row_size
+        else:
+            # Bottom-up DIB: first row in file is bottom of image
+            row_start = pixel_offset + (height - 1 - y) * row_size
+
+        row_data = dib_data[row_start:row_start + width * bytes_per_pixel]
+
+        # Convert BGR(A) to RGB(A)
+        row = []
+        for x in range(width):
+            offset = x * bytes_per_pixel
+            b = row_data[offset]
+            g = row_data[offset + 1]
+            r = row_data[offset + 2]
+            row.extend([r, g, b])
+        rows.append(row)
+
+    # Write PNG
+    output = io.BytesIO()
+    writer = png.Writer(width=width, height=height, greyscale=False, alpha=False)
+    writer.write(output, rows)
+    return output.getvalue()
 
 
 def _read_macos_clipboard() -> Optional[bytes]:
     """Read image from macOS clipboard."""
-    AppKit, objc = _import_mac_clipboard()
+    import tempfile
+
+    AppKit = _import_mac_clipboard()
     if AppKit is None:
         raise ClipboardImageError(
             "pyobjc is required for clipboard access on macOS. "
@@ -240,12 +274,37 @@ def _read_macos_clipboard() -> Optional[bytes]:
         if data:
             return bytes(data)
 
-        # Try other image types
-        for img_type in ["public.jpeg", "public.tiff", "com.compuserve.gif"]:
-            data = pasteboard.dataForType_(img_type)
-            if data:
-                img_data = bytes(data)
-                return _convert_to_png(img_data)
+        # Try TIFF and convert (macOS screenshots use TIFF internally)
+        data = pasteboard.dataForType_("public.tiff")
+        if data:
+            # Use sips command-line tool to convert TIFF to PNG (via temp files)
+            try:
+                with tempfile.NamedTemporaryFile(suffix='.tiff', delete=False) as tiff_file:
+                    tiff_path = tiff_file.name
+                    tiff_file.write(bytes(data))
+
+                png_path = tiff_path.replace('.tiff', '.png')
+                try:
+                    proc = subprocess.run(
+                        ["sips", "-s", "format", "png", tiff_path, "--out", png_path],
+                        capture_output=True,
+                        timeout=5
+                    )
+                    if proc.returncode == 0:
+                        with open(png_path, 'rb') as f:
+                            return f.read()
+                finally:
+                    # Clean up temp files
+                    try:
+                        os.unlink(tiff_path)
+                    except OSError:
+                        pass
+                    try:
+                        os.unlink(png_path)
+                    except OSError:
+                        pass
+            except (subprocess.TimeoutExpired, FileNotFoundError):
+                pass
 
         return None
     except Exception as e:
@@ -258,7 +317,6 @@ def _read_linux_clipboard() -> Optional[bytes]:
     result = os.system("which wl-paste > /dev/null 2>&1") == 0
     if result:
         try:
-            import subprocess
             proc = subprocess.run(
                 ["wl-paste", "-t", "image/png"],
                 capture_output=True,
@@ -273,7 +331,6 @@ def _read_linux_clipboard() -> Optional[bytes]:
     result = os.system("which xclip > /dev/null 2>&1") == 0
     if result:
         try:
-            import subprocess
             proc = subprocess.run(
                 ["xclip", "-selection", "clipboard", "-t", "image/png", "-o"],
                 capture_output=True,
@@ -291,31 +348,12 @@ def _read_linux_clipboard() -> Optional[bytes]:
     )
 
 
-def _convert_to_png(image_data: bytes) -> bytes:
-    """Convert image data to PNG format."""
-    Image = _import_pillow()
-    if Image is None:
-        raise ClipboardImageError("PIL/Pillow is required for image processing")
-
-    with io.BytesIO(image_data) as bio:
-        img = Image.open(bio)
-        return _image_to_png_bytes(img)
-
-
-def _image_to_png_bytes(img) -> bytes:
-    """Convert PIL Image to PNG bytes."""
-    output = io.BytesIO()
-    img.convert("RGB")  # Ensure RGB mode
-    img.save(output, format="PNG")
-    return output.getvalue()
-
-
 def encode_image_to_base64(image_data: bytes, format: ImageFormat = ImageFormat.PNG) -> str:
     """Encode image bytes to base64 data URL.
 
     Args:
         image_data: Raw image bytes.
-        format: Image format (PNG, JPEG, GIF).
+        format: Image format (PNG only supported).
 
     Returns:
         Base64 data URL string: data:image/{format};base64,{encoded_data}
@@ -344,101 +382,41 @@ def encode_image_for_llm(image_data: bytes, format: ImageFormat = ImageFormat.PN
     }
 
 
-def resize_image_if_needed(
-    image_data: bytes,
-    max_size: int = MAX_IMAGE_SIZE_BYTES,
-    max_dimension: int = MAX_IMAGE_DIMENSION
-) -> bytes:
-    """Resize image if it exceeds size or dimension limits.
-
-    Args:
-        image_data: Raw image bytes.
-        max_size: Maximum image size in bytes.
-        max_dimension: Maximum width/height dimension.
-
-    Returns:
-        Resized image bytes (always PNG format).
-    """
-    Image = _import_pillow()
-    if Image is None:
-        # Can't resize without Pillow, but if it's small enough, return as-is
-        if len(image_data) <= max_size:
-            return image_data
-        raise ImageProcessingError(
-            "PIL/Pillow is required to resize large images. "
-            "Install with: pip install pillow"
-        )
-
-    with io.BytesIO(image_data) as bio:
-        img = Image.open(bio)
-
-        # Check if resizing is needed
-        needs_resize = False
-
-        if len(image_data) > max_size:
-            needs_resize = True
-
-        width, height = img.size
-        if width > max_dimension or height > max_dimension:
-            needs_resize = True
-
-        if not needs_resize:
-            # Return original as PNG
-            return _image_to_png_bytes(img)
-
-        # Calculate new dimensions maintaining aspect ratio
-        if width > height:
-            new_width = min(width, max_dimension)
-            new_height = int(height * (new_width / width))
-        else:
-            new_height = min(height, max_dimension)
-            new_width = int(width * (new_height / height))
-
-        # Resize image
-        resized = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
-
-        # Optimize quality if still too large
-        output = io.BytesIO()
-        quality = 95
-        resized.save(output, format="PNG", quality=quality, optimize=True)
-
-        # If still too large, reduce quality
-        while len(output.getvalue()) > max_size and quality > 50:
-            quality -= 10
-            output = io.BytesIO()
-            resized.save(output, format="PNG", quality=quality, optimize=True)
-            if quality <= 50:
-                break
-
-        return output.getvalue()
-
-
 def get_image_info(image_data: bytes) -> dict:
-    """Get information about an image.
+    """Get information about a PNG image.
 
     Args:
-        image_data: Raw image bytes.
+        image_data: Raw PNG image bytes.
 
     Returns:
         Dict with image info: width, height, size, format.
     """
-    Image = _import_pillow()
-    if Image is None:
+    png = _import_png()
+    if png is None:
         return {
             "width": None,
             "height": None,
             "size_bytes": len(image_data),
             "format": "unknown",
-            "error": "PIL/Pillow not available"
+            "error": "pypng not available"
         }
 
-    with io.BytesIO(image_data) as bio:
-        img = Image.open(bio)
+    try:
+        reader = png.Reader(bytes=image_data)
+        width, height, rows, metadata = reader.read()
         return {
-            "width": img.width,
-            "height": img.height,
+            "width": width,
+            "height": height,
             "size_bytes": len(image_data),
-            "format": img.format or "unknown"
+            "format": "PNG"
+        }
+    except Exception as e:
+        return {
+            "width": None,
+            "height": None,
+            "size_bytes": len(image_data),
+            "format": "unknown",
+            "error": str(e)
         }
 
 
@@ -477,14 +455,16 @@ def read_and_prepare_image(
 ) -> Optional[bytes]:
     """Read image from clipboard and prepare for LLM.
 
-    Combines checking, reading, and resizing into one call.
+    Combines checking, reading into one call.
+    Note: Image resizing is not supported with pypng.
+    Large images will be rejected if they exceed max_size.
 
     Args:
         max_size: Maximum image size in bytes.
         raise_errors: If True, raises errors on failure. If False, returns None.
 
     Returns:
-        Prepared image bytes, or None if no image available.
+        Image bytes, or None if no image available.
     """
     try:
         if not is_clipboard_image_available():
@@ -494,9 +474,16 @@ def read_and_prepare_image(
         if image_data is None:
             return None
 
-        return resize_image_if_needed(image_data, max_size)
+        # Check size limit (no resize capability with pypng)
+        if len(image_data) > max_size:
+            raise ImageProcessingError(
+                f"Image too large ({len(image_data)} bytes, max {max_size}). "
+                "Please use a smaller image."
+            )
+
+        return image_data
 
-    except ClipboardImageError as e:
+    except (ClipboardImageError, ImageProcessingError):
         if raise_errors:
             raise
         return None