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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emdash-core
-Version: 0.1.50
+Version: 0.1.53
 Summary: EmDash Core - FastAPI server for code intelligence
 Author: Em Dash Team
 Requires-Python: >=3.10,<4.0

{emdash_core-0.1.50 → emdash_core-0.1.53}/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.53}/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.53}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "emdash-core"
-version = "0.1.50"
+version = "0.1.53"
 description = "EmDash Core - FastAPI server for code intelligence"
 authors = ["Em Dash Team"]
 packages = [{include = "emdash_core"}]