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

emdash_core/agent/tools/coding.py

@@ -231,94 +231,333 @@ Creates the file if it doesn't exist, or overwrites if it does."""
         )
 
 
+class EditFileTool(CodingTool):
+    """Performs exact string replacements in files."""
+
+    name = "edit_file"
+    description = """Performs exact string replacements in files.
+
+Usage:
+- You must use read_file at least once before editing. This tool will error if you attempt an edit without reading the file first.
+- When editing text from read_file output, preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix.
+- ALWAYS prefer editing existing files. NEVER write new files unless explicitly required.
+- The edit will FAIL if old_string is not unique in the file. Either provide more surrounding context to make it unique or use replace_all.
+- Use replace_all for replacing/renaming strings across the file (e.g., renaming a variable)."""
+
+    def execute(
+        self,
+        file_path: str,
+        old_string: str,
+        new_string: str,
+        replace_all: bool = False,
+    ) -> ToolResult:
+        """Edit a file using search and replace.
+
+        Args:
+            file_path: Absolute path to the file to modify
+            old_string: The text to replace
+            new_string: The text to replace it with (must be different from old_string)
+            replace_all: Replace all occurrences of old_string (default: false)
+
+        Returns:
+            ToolResult indicating success
+        """
+        valid, error, full_path = self._validate_path(file_path)
+        if not valid:
+            return ToolResult.error_result(error)
+
+        if not full_path.exists():
+            return ToolResult.error_result(f"File not found: {file_path}")
+
+        # Validate old_string != new_string
+        if old_string == new_string:
+            return ToolResult.error_result("old_string and new_string must be different")
+
+        try:
+            content = full_path.read_text()
+
+            # Check if old_string exists in file
+            if old_string not in content:
+                # Try to find similar content for better error message
+                lines = content.split('\n')
+                search_lines = old_string.split('\n')
+                first_search = search_lines[0].strip() if search_lines else ""
+
+                # Find lines that might be close matches
+                close_matches = []
+                for i, line in enumerate(lines):
+                    if first_search and first_search in line:
+                        close_matches.append(f"  Line {i+1}: {line.strip()[:80]}")
+
+                error_msg = f"old_string not found in file"
+                if close_matches:
+                    error_msg += f"\n\nSimilar lines found:\n" + "\n".join(close_matches[:5])
+                    error_msg += "\n\nMake sure whitespace/indentation matches exactly."
+
+                return ToolResult.error_result(error_msg)
+
+            # Check for uniqueness if not replace_all
+            if not replace_all:
+                count = content.count(old_string)
+                if count > 1:
+                    return ToolResult.error_result(
+                        f"old_string found {count} times. Use replace_all=true or provide more context to make it unique."
+                    )
+
+            # Perform replacement
+            if replace_all:
+                new_content = content.replace(old_string, new_string)
+                replacements = content.count(old_string)
+            else:
+                new_content = content.replace(old_string, new_string, 1)
+                replacements = 1
+
+            # Write back
+            full_path.write_text(new_content)
+
+            return ToolResult.success_result(
+                data={
+                    "file_path": file_path,
+                    "replacements": replacements,
+                },
+            )
+
+        except Exception as e:
+            return ToolResult.error_result(f"Failed to edit file: {e}")
+
+    def get_schema(self) -> dict:
+        """Get OpenAI function schema."""
+        return self._make_schema(
+            properties={
+                "file_path": {
+                    "type": "string",
+                    "description": "The absolute path to the file to modify",
+                },
+                "old_string": {
+                    "type": "string",
+                    "description": "The text to replace",
+                },
+                "new_string": {
+                    "type": "string",
+                    "description": "The text to replace it with (must be different from old_string)",
+                },
+                "replace_all": {
+                    "type": "boolean",
+                    "description": "Replace all occurrences of old_string (default: false)",
+                    "default": False,
+                },
+            },
+            required=["file_path", "old_string", "new_string"],
+        )
+
+
 class ApplyDiffTool(CodingTool):
-    """Apply a diff/patch to a file."""
+    """Apply a search/replace diff to a file with fuzzy matching."""
 
     name = "apply_diff"
-    description = """Apply a unified diff to a file.
-The diff should be in standard unified diff format."""
+    description = """Apply changes to a file using search/replace blocks with fuzzy matching.
+
+Format:
+<<<<<<< SEARCH
+[exact content to find - include enough context for uniqueness]
+=======
+[replacement content]
+>>>>>>> REPLACE
+
+You can include multiple SEARCH/REPLACE blocks in one diff.
+The SEARCH content should match the file exactly (or very closely for fuzzy matching).
+Include enough surrounding lines to make the match unique.
+
+Example:
+<<<<<<< SEARCH
+def hello():
+    print("Hello")
+=======
+def hello():
+    print("Hello, World!")
+>>>>>>> REPLACE"""
+
+    # Confidence threshold for fuzzy matching (0.0-1.0)
+    CONFIDENCE_THRESHOLD = 0.85
+    # Buffer lines to extend search area around line hints
+    BUFFER_LINES = 40
 
     def execute(
         self,
-        path: str,
+        file_path: str,
         diff: str,
     ) -> ToolResult:
-        """Apply a diff to a file.
+        """Apply a search/replace diff to a file.
 
         Args:
-            path: Path to the file
-            diff: Unified diff content
+            file_path: Path to the file to modify
+            diff: Search/replace diff content
 
         Returns:
             ToolResult indicating success
         """
-        valid, error, full_path = self._validate_path(path)
+        valid, error, full_path = self._validate_path(file_path)
         if not valid:
             return ToolResult.error_result(error)
 
         if not full_path.exists():
-            return ToolResult.error_result(f"File not found: {path}")
+            return ToolResult.error_result(f"File not found: {file_path}")
 
         try:
-            # Try to apply with patch command
-            # --batch: suppress questions, --forward: skip already-applied patches
-            result = subprocess.run(
-                ["patch", "-p0", "--forward", "--batch"],
-                input=diff,
-                capture_output=True,
-                text=True,
-                cwd=self.repo_root,
-                timeout=30,
-            )
+            content = full_path.read_text()
+            original_content = content
 
-            if result.returncode != 0:
-                # Try with -p1
-                result = subprocess.run(
-                    ["patch", "-p1", "--forward", "--batch"],
-                    input=diff,
-                    capture_output=True,
-                    text=True,
-                    cwd=self.repo_root,
-                    timeout=30,
+            # Parse the diff into search/replace blocks
+            blocks = self._parse_diff_blocks(diff)
+            if not blocks:
+                return ToolResult.error_result(
+                    "No valid SEARCH/REPLACE blocks found in diff.\n"
+                    "Expected format:\n"
+                    "<<<<<<< SEARCH\n"
+                    "[content to find]\n"
+                    "=======\n"
+                    "[replacement]\n"
+                    ">>>>>>> REPLACE"
                 )
 
-            if result.returncode != 0:
+            # Apply each block
+            applied = 0
+            failed = []
+            for i, block in enumerate(blocks):
+                search_text = block["search"]
+                replace_text = block["replace"]
+
+                # Try exact match first
+                if search_text in content:
+                    # Check uniqueness
+                    count = content.count(search_text)
+                    if count > 1:
+                        failed.append(f"Block {i+1}: SEARCH text found {count} times, add more context")
+                        continue
+                    content = content.replace(search_text, replace_text, 1)
+                    applied += 1
+                else:
+                    # Try fuzzy matching
+                    match_result = self._fuzzy_find(content, search_text)
+                    if match_result:
+                        start, end, confidence = match_result
+                        if confidence >= self.CONFIDENCE_THRESHOLD:
+                            content = content[:start] + replace_text + content[end:]
+                            applied += 1
+                        else:
+                            failed.append(
+                                f"Block {i+1}: Best match confidence {confidence:.2f} "
+                                f"below threshold {self.CONFIDENCE_THRESHOLD}"
+                            )
+                    else:
+                        # Provide helpful error with similar lines
+                        similar = self._find_similar_lines(content, search_text)
+                        error_msg = f"Block {i+1}: SEARCH text not found"
+                        if similar:
+                            error_msg += f"\nSimilar lines:\n{similar}"
+                        failed.append(error_msg)
+
+            if applied == 0:
                 return ToolResult.error_result(
-                    f"Patch failed: {result.stderr}",
-                    suggestions=["Check the diff format", "Ensure the file matches the diff context"],
+                    f"Failed to apply any blocks:\n" + "\n".join(failed)
                 )
 
-            return ToolResult.success_result(
-                data={
-                    "path": path,
-                    "output": result.stdout,
-                },
-            )
+            # Write back
+            full_path.write_text(content)
+
+            result_data = {
+                "file_path": file_path,
+                "blocks_applied": applied,
+                "blocks_total": len(blocks),
+            }
+            if failed:
+                result_data["warnings"] = failed
+
+            return ToolResult.success_result(data=result_data)
 
-        except FileNotFoundError:
-            return ToolResult.error_result(
-                "patch command not found",
-                suggestions=["Install patch: brew install gpatch"],
-            )
-        except subprocess.TimeoutExpired:
-            return ToolResult.error_result("Patch timed out")
         except Exception as e:
             return ToolResult.error_result(f"Failed to apply diff: {e}")
 
+    def _parse_diff_blocks(self, diff: str) -> list[dict]:
+        """Parse diff into search/replace blocks."""
+        import re
+
+        blocks = []
+        # Pattern to match search/replace blocks
+        pattern = r'<<<<<<< SEARCH\n(.*?)\n=======\n(.*?)\n>>>>>>> REPLACE'
+        matches = re.findall(pattern, diff, re.DOTALL)
+
+        for search, replace in matches:
+            blocks.append({
+                "search": search,
+                "replace": replace,
+            })
+
+        return blocks
+
+    def _fuzzy_find(self, content: str, search_text: str) -> tuple[int, int, float] | None:
+        """Find best fuzzy match for search_text in content.
+
+        Returns (start_index, end_index, confidence) or None if no good match.
+        """
+        from difflib import SequenceMatcher
+
+        search_lines = search_text.split('\n')
+        content_lines = content.split('\n')
+        search_len = len(search_lines)
+
+        if search_len == 0:
+            return None
+
+        best_match = None
+        best_confidence = 0.0
+
+        # Sliding window approach
+        for i in range(len(content_lines) - search_len + 1):
+            window = '\n'.join(content_lines[i:i + search_len])
+            matcher = SequenceMatcher(None, search_text, window)
+            confidence = matcher.ratio()
+
+            if confidence > best_confidence:
+                best_confidence = confidence
+                # Calculate character positions
+                start = sum(len(line) + 1 for line in content_lines[:i])
+                end = start + len(window)
+                best_match = (start, end, confidence)
+
+        return best_match if best_confidence >= 0.5 else None
+
+    def _find_similar_lines(self, content: str, search_text: str) -> str:
+        """Find lines in content similar to the first line of search_text."""
+        lines = content.split('\n')
+        search_first = search_text.split('\n')[0].strip() if search_text else ""
+
+        if not search_first:
+            return ""
+
+        similar = []
+        for i, line in enumerate(lines):
+            if search_first[:20] in line or line.strip()[:20] in search_first:
+                similar.append(f"  Line {i+1}: {line.strip()[:60]}")
+                if len(similar) >= 3:
+                    break
+
+        return "\n".join(similar)
+
     def get_schema(self) -> dict:
         """Get OpenAI function schema."""
         return self._make_schema(
             properties={
-                "path": {
+                "file_path": {
                     "type": "string",
-                    "description": "Path to the file to patch",
+                    "description": "The absolute path to the file to modify",
                 },
                 "diff": {
                     "type": "string",
-                    "description": "Unified diff content to apply",
+                    "description": "Search/replace diff with <<<<<<< SEARCH ... ======= ... >>>>>>> REPLACE blocks",
                 },
             },
-            required=["path", "diff"],
+            required=["file_path", "diff"],
         )
 
 
@@ -468,22 +707,37 @@ class ExecuteCommandTool(CodingTool):
 
     name = "execute_command"
     description = """Execute a shell command in the repository.
-Commands are run from the repository root."""
+Commands are run from the repository root.
+
+Use run_in_background=true for long-running commands (builds, servers, tests).
+Background commands return immediately with a task_id. You'll be notified
+when they complete, or use task_output(task_id) to check status."""
 
     def execute(
         self,
         command: str,
         timeout: int = 60,
+        run_in_background: bool = False,
+        description: str = "",
     ) -> ToolResult:
         """Execute a command.
 
         Args:
             command: Command to execute
-            timeout: Timeout in seconds
+            timeout: Timeout in seconds (ignored for background commands)
+            run_in_background: Run command in background, return immediately
+            description: Short description of what this command does
 
         Returns:
-            ToolResult with command output
+            ToolResult with command output or task info for background
         """
+        if run_in_background:
+            return self._run_background(command, description)
+        else:
+            return self._run_sync(command, timeout)
+
+    def _run_sync(self, command: str, timeout: int) -> ToolResult:
+        """Run command synchronously."""
         try:
             result = subprocess.run(
                 command,
@@ -506,10 +760,39 @@ Commands are run from the repository root."""
         except subprocess.TimeoutExpired:
             return ToolResult.error_result(
                 f"Command timed out after {timeout}s",
+                suggestions=["Use run_in_background=true for long-running commands"],
             )
         except Exception as e:
             return ToolResult.error_result(f"Command failed: {e}")
 
+    def _run_background(self, command: str, description: str) -> ToolResult:
+        """Run command in background."""
+        from ..background import BackgroundTaskManager
+
+        try:
+            manager = BackgroundTaskManager.get_instance()
+            task_id = manager.start_shell(
+                command=command,
+                description=description or command[:50],
+                cwd=self.repo_root,
+            )
+
+            return ToolResult.success_result(
+                data={
+                    "task_id": task_id,
+                    "status": "running",
+                    "command": command,
+                    "message": "Command started in background. You'll be notified when it completes.",
+                },
+                suggestions=[
+                    f"Use task_output(task_id='{task_id}') to check status",
+                    f"Use kill_task(task_id='{task_id}') to stop it",
+                ],
+            )
+
+        except Exception as e:
+            return ToolResult.error_result(f"Failed to start background command: {e}")
+
     def get_schema(self) -> dict:
         """Get OpenAI function schema."""
         return self._make_schema(
@@ -520,9 +803,18 @@ Commands are run from the repository root."""
                 },
                 "timeout": {
                     "type": "integer",
-                    "description": "Timeout in seconds",
+                    "description": "Timeout in seconds (for synchronous execution)",
                     "default": 60,
                 },
+                "run_in_background": {
+                    "type": "boolean",
+                    "description": "Run in background and return immediately. Use for long-running commands.",
+                    "default": False,
+                },
+                "description": {
+                    "type": "string",
+                    "description": "Short description of what this command does",
+                },
             },
             required=["command"],
         )