emdash-core 0.1.50__tar.gz → 0.1.57__tar.gz

{emdash_core-0.1.50 → emdash_core-0.1.57}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emdash-core
-Version: 0.1.50
+Version: 0.1.57
 Summary: EmDash Core - FastAPI server for code intelligence
 Author: Em Dash Team
 Requires-Python: >=3.10,<4.0
@@ -27,6 +27,7 @@ Requires-Dist: openai (>=1.0.0)
 Requires-Dist: pydantic (>=2.5.0,<3.0.0)
 Requires-Dist: pydantic-settings (>=2.0.0,<3.0.0)
 Requires-Dist: pygithub (>=2.1.1,<3.0.0)
+Requires-Dist: pyobjc-framework-Cocoa (>=9.0) ; sys_platform == "darwin"
 Requires-Dist: pypng (>=0.0.21,<0.0.22)
 Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
 Requires-Dist: python-louvain (>=0.16,<0.17)

{emdash_core-0.1.50 → emdash_core-0.1.57}/emdash_core/agent/prompts/workflow.py

@@ -48,35 +48,38 @@ After receiving the plan:
 - "Fix this typo" → just fix it
 - "Add a log statement here" → just add it
 
-### 1. Understand Before Acting
-- Read code before modifying it
-- Search for similar patterns already in the codebase
-- When requirements are ambiguous, use `ask_followup_question` tool (not text output)
-  - ONLY after exploring the codebase first - questions should be informed by research
-  - ONLY one question at a time - never ask multiple questions in parallel
-  - Ask the most critical question first, then continue based on the answer
-  - NEVER ask generic questions like "What platform?" without first understanding the codebase
-
-### 2. Break Down Hard Problems
-When facing a task you don't immediately know how to solve:
-
-a) **Spawn Plan Agent**: Call `task(subagent_type="Plan", prompt="...")` to design the approach
-b) **Save Plan**: Write the returned plan to the plan file (specified in plan mode approval)
-c) **Present for Approval**: Call `exit_plan` to show the plan to the user
-d) **Execute**: After approval, implement the plan step by step
-e) **Validate**: Check your work against requirements
-
-### 3. Targeted vs Open-Ended Queries
-
-**Targeted queries** (you know what to look for) → Use direct tools:
+### 1. Know What To Do → Plan-First, Execute
+
+When you understand the task and know how to approach it:
+1. State a brief plan (3-5 steps)
+2. Execute directly - don't explore "just in case"
+3. Read only the files your plan requires
+
+Examples:
+- "Add logout button to settings" → You know where settings is, just do it
+- "Fix the typo in README" → Just fix it
+- "Update the API endpoint" → Read it, update it, done
+
+### 2. Don't Know What To Do → Explore First
+
+When you're genuinely uncertain about the codebase or approach:
+- **Spawn Explore agent** for open-ended research across multiple files
+- **Ask ONE clarifying question** if you need user input (not multiple)
+
+Examples:
+- "Where are errors handled?" → Explore agent (could be many places)
+- "How does authentication work?" → Explore agent (multiple files)
+- "What framework should I use?" → Ask user (decision needed)
+
+### 3. Direct Tools vs Explore Agent
+
+**Use direct tools** when you know what to look for:
 - "Read the router" → `glob("**/router*")` then `read_file`
-- "What's in config.ts?" → `read_file("config.ts")`
-- "Find the UserService class" → `grep("class UserService")`
+- "Find UserService class" → `grep("class UserService")`
 
-**Open-ended queries** (need to explore possibilities) → Spawn Explore agent:
-- "Where are errors handled?" → could be many places
-- "How does authentication work?" → requires understanding multiple files
-- "What is the codebase structure?" → broad exploration
+**Spawn Explore agent** when you need broad exploration:
+- "What is the codebase structure?"
+- "How does X integrate with Y?"
 
 ### 4. Parallel Tool Execution
 
@@ -338,6 +341,17 @@ Do this in ONE message:
 → All three run concurrently, results return together
 """
 
+# Plan-First rule to prevent over-exploration
+PLAN_FIRST_RULE = """
+## Plan-First Reminder
+
+**Know what to do?** → State a 3-5 step plan, then execute. Don't explore beyond your plan.
+
+**Don't know?** → Spawn Explore agent or ask ONE clarifying question.
+
+Trust user context - if they say "the file" or "this", they know which one.
+"""
+
 # Efficiency rules for sub-agents with limited turns
 EFFICIENCY_RULES = """
 ## Efficiency Rules

{emdash_core-0.1.50 → emdash_core-0.1.57}/emdash_core/agent/runner/agent_runner.py

@@ -310,24 +310,27 @@ class AgentRunner(PlanMixin):
         from ..tools.modes import ModeState
         ModeState.get_instance().reset_cycle()
 
-        # Build user message
+        # Build user message content
         if context:
-            user_message = {
-                "role": "user",
-                "content": f"Context:\n{context}\n\nQuestion: {query}",
-            }
+            text_content = f"Context:\n{context}\n\nQuestion: {query}"
         else:
-            user_message = {
-                "role": "user",
-                "content": query,
-            }
+            text_content = query
+
+        # Format content with images if provided
+        if images:
+            content = self.provider.format_content_with_images(text_content, images)
+        else:
+            content = text_content
+
+        user_message = {
+            "role": "user",
+            "content": content,
+        }
 
         # Save user message to history BEFORE running (so it's preserved even if interrupted)
         self._messages.append(user_message)
         messages = list(self._messages)  # Copy for the loop
 
-        # TODO: Handle images if provided
-
         # Get tool schemas
         tools = self.toolkit.get_all_schemas()
 
@@ -793,10 +796,16 @@ DO NOT output more text. Use a tool NOW.""",
         # Store query for reranking context frame
         self._current_query = message
 
+        # Format content with images if provided
+        if images:
+            content = self.provider.format_content_with_images(message, images)
+        else:
+            content = message
+
         # Add new user message to history
         self._messages.append({
             "role": "user",
-            "content": message,
+            "content": content,
         })
 
         # Get tool schemas

{emdash_core-0.1.50 → emdash_core-0.1.57}/emdash_core/api/agent.py

@@ -251,9 +251,13 @@ def _run_agent_sync(
         # Convert image data if provided
         agent_images = None
         if images:
+            import base64
             from ..agent.providers.base import ImageContent
             agent_images = [
-                ImageContent(data=img.data, format=img.format)
+                ImageContent(
+                    image_data=base64.b64decode(img.data),
+                    format=img.format
+                )
                 for img in images
             ]
 

{emdash_core-0.1.50 → emdash_core-0.1.57}/emdash_core/utils/image.py

@@ -110,7 +110,11 @@ def _check_macos_clipboard() -> bool:
 
     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
 
@@ -253,6 +257,8 @@ def _dib_to_png(dib_data: bytes) -> bytes:
 
 def _read_macos_clipboard() -> Optional[bytes]:
     """Read image from macOS clipboard."""
+    import tempfile
+
     AppKit = _import_mac_clipboard()
     if AppKit is None:
         raise ClipboardImageError(
@@ -268,19 +274,35 @@ def _read_macos_clipboard() -> Optional[bytes]:
         if data:
             return bytes(data)
 
-        # Try TIFF and convert (macOS often uses TIFF internally)
+        # 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
+            # Use sips command-line tool to convert TIFF to PNG (via temp files)
             try:
-                proc = subprocess.run(
-                    ["sips", "-s", "format", "png", "/dev/stdin", "--out", "/dev/stdout"],
-                    input=bytes(data),
-                    capture_output=True,
-                    timeout=5
-                )
-                if proc.returncode == 0 and proc.stdout:
-                    return proc.stdout
+                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
 

{emdash_core-0.1.50 → emdash_core-0.1.57}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "emdash-core"
-version = "0.1.50"
+version = "0.1.57"
 description = "EmDash Core - FastAPI server for code intelligence"
 authors = ["Em Dash Team"]
 packages = [{include = "emdash_core"}]
@@ -54,6 +54,9 @@ tqdm = "^4.66.1"
 pypng = "^0.0.21"
 pyyaml = "^6.0"
 
+# Clipboard (macOS only)
+pyobjc-framework-Cocoa = {version = ">=9.0", markers = "sys_platform == 'darwin'"}
+
 [tool.poetry.extras]
 graph = ["kuzu", "cmake"]