code-puppy 0.0.45__tar.gz → 0.0.47__tar.gz

{code_puppy-0.0.45 → code_puppy-0.0.47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.45
+Version: 0.0.47
 Summary: Code generation agent
 Author: Michael Pfaffenberger
 License: MIT

{code_puppy-0.0.45 → code_puppy-0.0.47}/code_puppy/agent_prompts.py

@@ -27,52 +27,49 @@ YOU MUST USE THESE TOOLS to complete tasks (do not just describe what should be
 File Operations:
    - list_files(directory=".", recursive=True): ALWAYS use this to explore directories before trying to read/modify files
    - read_file(file_path): ALWAYS use this to read existing files before modifying them.
-   - write_to_file(path, content): Use this to write or overwrite files with complete content.
-   - replace_in_file(path, diff): Use this to make exact replacements in a file using JSON format.
-   - delete_snippet_from_file(file_path, snippet): Use this to remove specific code snippets from files
+   - edit_file(path, diff): Use this single tool to create new files, overwrite entire files, perform targeted replacements, or delete snippets depending on the JSON/raw payload provided.
    - delete_file(file_path): Use this to remove files when needed
    - grep(search_string, directory="."): Use this to recursively search for a string across files starting from the specified directory, capping results at 200 matches.
-   - grab_json_from_url(url: str): Use this to grab JSON data from a specified URL, ensuring the response is of type application/json. It raises an error if the response type is not application/json and limits the output to 1000 lines.
 
 Tool Usage Instructions:
 
-## write_to_file
-Use this when you need to create a new file or completely replace an existing file's contents.
-- path: The path to the file (required)
-- content: The COMPLETE content of the file (required)
+## edit_file
+This is an all-in-one file-modification tool. It supports the following payload shapes for the `diff` argument:
+1. {{ "content": "…", "overwrite": true|false }}  →  Treated as full-file content when the target file does **not** exist.
+2. {{ "content": "…", "overwrite": true|false }}  →  Create or overwrite a file with the provided content.
+3. {{ "replacements": [ {{ "old_str": "…", "new_str": "…" }}, … ] }}  →  Perform exact text replacements inside an existing file.
+4. {{ "delete_snippet": "…" }}  →  Remove a snippet of text from an existing file.
 
-Example:
-```
-write_to_file(
-    path="path/to/file.txt",
-    content="Complete content of the file here..."
-)
-```
+Arguments:
+- path (required): Target file path.
+- diff (required): One of the payloads above (raw string or JSON string).
 
-## replace_in_file
-Use this to make targeted replacements in an existing file. Each replacement must match exactly what's in the file.
-- path: The path to the file (required)
-- diff: JSON string with replacements (required)
-
-The diff parameter should be a JSON string in this format:
+Example (create):
 ```json
-{{
-  "replacements": [
-    {{
-      "old_str": "exact string from file",
-      "new_str": "replacement string"
-    }}
-  ]
-}}
+edit_file("src/example.py", "print('hello')\n")
 ```
 
-For grab_json_from_url, this is super useful for hitting a swagger doc or openapi doc. That will allow you to
-write correct code to hit the API.
+Example (replacement):
+```json
+edit_file(
+  "src/example.py",
+  "{{"replacements":[{{"old_str":"foo","new_str":"bar"}}]}}"
+)
+```
 
-NEVER output an entire file, this is very expensive.
+NEVER output an entire file – this is very expensive.
 You may not edit file extensions: [.ipynb]
 You should specify the following arguments before the others: [TargetFile]
 
+Remember: ONE argument = ONE JSON string.
+
+Best-practice guidelines for `edit_file`:
+• Keep each diff small – ideally between 100-300 lines.  
+• Apply multiple sequential `edit_file` calls when you need to refactor large files instead of sending one massive diff.  
+• Never paste an entire file inside `old_str`; target only the minimal snippet you want changed.  
+• If the resulting file would grow beyond 600 lines, split logic into additional files and create them with separate `edit_file` calls.
+
+
 System Operations:
    - run_shell_command(command, cwd=None, timeout=60): Use this to execute commands, run tests, or start services
 
@@ -88,6 +85,8 @@ In the event that you want to see the entire output for the test, run a single t
 
 npm test -- ./path/to/test/file.tsx # or something like this.
 
+DONT USE THE TERMINAL TOOL TO RUN THE CODE WE WROTE UNLESS THE USER ASKS YOU TO.
+
 Reasoning & Explanation:
    - share_your_reasoning(reasoning, next_steps=None): Use this to explicitly share your thought process and planned next steps
 
@@ -95,7 +94,7 @@ Important rules:
 - You MUST use tools to accomplish tasks - DO NOT just output code or descriptions
 - Before every other tool use, you must use "share_your_reasoning" to explain your thought process and planned next steps
 - Check if files exist before trying to modify or delete them
-- Whenever possible, prefer to MODIFY existing files first (use `replace_in_file`, `delete_snippet_from_file`, or `write_to_file`) before creating brand-new files or deleting existing ones.
+- Whenever possible, prefer to MODIFY existing files first (use `edit_file`) before creating brand-new files or deleting existing ones.
 - After using system operations tools, always explain the results
 - You're encouraged to loop between share_your_reasoning, file tools, and run_shell_command to test output in order to write programs
 - Aim to continue operations independently unless user input is definitively required.

{code_puppy-0.0.45 → code_puppy-0.0.47}/code_puppy/command_line/prompt_toolkit_completion.py

@@ -90,6 +90,10 @@ async def get_input_with_combined_completion(prompt_str = '>>> ', history_file:
     @bindings.add(Keys.Escape, 'm')  # Alt+M
     def _(event):
         event.app.current_buffer.insert_text('\n')
+    @bindings.add(Keys.Escape)
+    def _(event):
+        """Cancel the current prompt when the user presses the ESC key alone."""
+        event.app.exit(exception=KeyboardInterrupt)
 
     session = PromptSession(
         completer=completer,

code_puppy-0.0.47/code_puppy/tools/file_modifications.py

@@ -0,0 +1,360 @@
+# file_modifications.py
+import os
+import difflib
+import json
+from code_puppy.tools.common import console
+from typing import Dict, Any, List
+from pydantic_ai import RunContext
+
+# ---------------------------------------------------------------------------
+# Module-level helper functions (exposed for unit tests; *not* registered)
+# ---------------------------------------------------------------------------
+
+def delete_snippet_from_file(context: RunContext | None, file_path: str, snippet: str) -> Dict[str, Any]:
+    """Remove *snippet* from *file_path* if present, returning a diff summary."""
+    file_path = os.path.abspath(file_path)
+    try:
+        if not os.path.exists(file_path) or not os.path.isfile(file_path):
+            return {"error": f"File '{file_path}' does not exist."}
+        with open(file_path, "r", encoding="utf-8") as f:
+            content = f.read()
+        if snippet not in content:
+            return {"error": f"Snippet not found in file '{file_path}'."}
+        modified_content = content.replace(snippet, "")
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(modified_content)
+        return {"success": True, "path": file_path, "message": "Snippet deleted from file."}
+    except PermissionError:
+        return {"error": f"Permission denied to modify '{file_path}'."}
+    except FileNotFoundError:
+        return {"error": f"File '{file_path}' does not exist."}
+    except Exception as exc:
+        return {"error": str(exc)}
+
+
+def write_to_file(context: RunContext | None, path: str, content: str) -> Dict[str, Any]:
+    file_path = os.path.abspath(path)
+    if os.path.exists(file_path):
+        return {
+            "success": False,
+            "path": file_path,
+            "message": f"Cowardly refusing to overwrite existing file: {file_path}",
+            "changed": False,
+        }
+    os.makedirs(os.path.dirname(file_path) or ".", exist_ok=True)
+    with open(file_path, "w", encoding="utf-8") as f:
+        f.write(content)
+    return {
+        "success": True,
+        "path": file_path,
+        "message": f"File '{file_path}' created successfully.",
+        "changed": True,
+    }
+
+
+def replace_in_file(context: RunContext | None, path: str, diff: str) -> Dict[str, Any]:
+    file_path = os.path.abspath(path)
+    if not os.path.exists(file_path):
+        return {"error": f"File '{file_path}' does not exist"}
+    try:
+        import json, ast, difflib
+        preview = (diff[:200] + '...') if len(diff) > 200 else diff
+        try:
+            replacements_data = json.loads(diff)
+        except json.JSONDecodeError as e1:
+            try:
+                replacements_data = json.loads(diff.replace("'", '"'))
+            except Exception as e2:
+                return {
+                    "error": "Could not parse diff as JSON.",
+                    "reason": str(e2),
+                    "received": preview,
+                }
+        # If still not a dict -> maybe python literal
+        if not isinstance(replacements_data, dict):
+            try:
+                replacements_data = ast.literal_eval(diff)
+            except Exception as e3:
+                return {
+                    "error": "Diff is neither valid JSON nor Python literal.",
+                    "reason": str(e3),
+                    "received": preview,
+                }
+        replacements = replacements_data.get("replacements", []) if isinstance(replacements_data, dict) else []
+        if not replacements:
+            return {
+                "error": "No valid replacements found in diff.",
+                "received": preview,
+            }
+        with open(file_path, "r", encoding="utf-8") as f:
+            original = f.read()
+        modified = original
+        for rep in replacements:
+            modified = modified.replace(rep.get("old_str", ""), rep.get("new_str", ""))
+        if modified == original:
+            return {"success": False, "path": file_path, "message": "No changes to apply.", "changed": False}
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(modified)
+        diff_text = "".join(difflib.unified_diff(original.splitlines(keepends=True), modified.splitlines(keepends=True)))
+        return {"success": True, "path": file_path, "message": "Replacements applied.", "diff": diff_text, "changed": True}
+    except Exception as exc:
+        return {"error": str(exc)}
+
+# ---------------------------------------------------------------------------
+
+def register_file_modifications_tools(agent):
+    # @agent.tool
+    def delete_snippet_from_file(context: RunContext, file_path: str, snippet: str) -> Dict[str, Any]:
+        console.log(f"🗑️ Deleting snippet from file [bold red]{file_path}[/bold red]")
+        file_path = os.path.abspath(file_path)
+        console.print("\n[bold white on red] SNIPPET DELETION [/bold white on red]")
+        console.print(f"[bold yellow]From file:[/bold yellow] {file_path}")
+        try:
+            if not os.path.exists(file_path):
+                console.print(f"[bold red]Error:[/bold red] File '{file_path}' does not exist")
+                return {"error": f"File '{file_path}' does not exist."}
+            if not os.path.isfile(file_path):
+                return {"error": f"'{file_path}' is not a file. Use rmdir for directories."}
+            with open(file_path, "r", encoding="utf-8") as f:
+                content = f.read()
+            if snippet not in content:
+                console.print(f"[bold red]Error:[/bold red] Snippet not found in file '{file_path}'")
+                return {"error": f"Snippet not found in file '{file_path}'."}
+            modified_content = content.replace(snippet, "")
+            diff_lines = list(difflib.unified_diff(content.splitlines(keepends=True), modified_content.splitlines(keepends=True), fromfile=f"a/{os.path.basename(file_path)}", tofile=f"b/{os.path.basename(file_path)}", n=3))
+            diff_text = "".join(diff_lines)
+            console.print("[bold cyan]Changes to be applied:[/bold cyan]")
+            if diff_text.strip():
+                formatted_diff = ""
+                for line in diff_lines:
+                    if line.startswith("+") and not line.startswith("+++"):
+                        formatted_diff += f"[bold green]{line}[/bold green]"
+                    elif line.startswith("-") and not line.startswith("---"):
+                        formatted_diff += f"[bold red]{line}[/bold red]"
+                    elif line.startswith("@"):
+                        formatted_diff += f"[bold cyan]{line}[/bold cyan]"
+                    else:
+                        formatted_diff += line
+                console.print(formatted_diff)
+            else:
+                console.print("[dim]No changes detected[/dim]")
+                return {"success": False, "path": file_path, "message": "No changes needed.", "diff": ""}
+            with open(file_path, "w", encoding="utf-8") as f:
+                f.write(modified_content)
+            return {"success": True, "path": file_path, "message": f"Snippet deleted from file '{file_path}'.", "diff": diff_text}
+        except PermissionError:
+            return {"error": f"Permission denied to delete '{file_path}'."}
+        except FileNotFoundError:
+            return {"error": f"File '{file_path}' does not exist."}
+        except Exception as e:
+            return {"error": f"Error deleting file '{file_path}': {str(e)}"}
+
+    # @agent.tool
+    def write_to_file(context: RunContext, path: str, content: str) -> Dict[str, Any]:
+        try:
+            file_path = os.path.abspath(path)
+            os.makedirs(os.path.dirname(file_path), exist_ok=True)
+            console.print("\n[bold white on blue] FILE WRITE [/bold white on blue]")
+            console.print(f"[bold yellow]Writing to:[/bold yellow] {file_path}")
+            file_exists = os.path.exists(file_path)
+            if file_exists:
+                console.print(f'[bold red]Refusing to overwrite existing file:[/bold red] {file_path}')
+                return {'success': False,'path': file_path,'message': f'Cowardly refusing to overwrite existing file: {file_path}','changed': False,}
+            trimmed_content = content
+            max_preview = 1000
+            if len(content) > max_preview:
+                trimmed_content = content[:max_preview] + '... [truncated]'
+            console.print('[bold magenta]Content to be written:[/bold magenta]')
+            console.print(trimmed_content, highlight=False)
+            with open(file_path, 'w', encoding='utf-8') as f:
+                f.write(content)
+            action = "updated" if file_exists else "created"
+            return {"success": True,"path": file_path,"message": f"File '{file_path}' {action} successfully.","diff": trimmed_content,"changed": True,}
+        except Exception as e:
+            console.print(f"[bold red]Error:[/bold red] {str(e)}")
+            return {"error": f"Error writing to file '{path}': {str(e)}"}
+
+    # @agent.tool(retries=5)
+    def replace_in_file(context: RunContext, path: str, diff: str) -> Dict[str, Any]:
+        try:
+            file_path = os.path.abspath(path)
+            console.print("\n[bold white on yellow] FILE REPLACEMENTS [/bold white on yellow]")
+            console.print(f"[bold yellow]Modifying:[/bold yellow] {file_path}")
+            if not os.path.exists(file_path):
+                console.print(f"[bold red]Error:[/bold red] File '{file_path}' does not exist")
+                return {"error": f"File '{file_path}' does not exist"}
+            if not os.path.isfile(file_path):
+                return {"error": f"'{file_path}' is not a file."}
+            # ------------------------------------------------------------------
+            # Robust parsing of the diff argument
+            # The agent sometimes sends single-quoted or otherwise invalid JSON.
+            # Attempt to recover by trying several strategies before giving up.
+            # ------------------------------------------------------------------
+            preview = (diff[:200] + '...') if len(diff) > 200 else diff
+            try:
+                replacements_data = json.loads(diff)
+            except json.JSONDecodeError as e1:
+                try:
+                    replacements_data = json.loads(diff.replace("'", '"'))
+                except Exception as e2:
+                    return {
+                        "error": "Could not parse diff as JSON.",
+                        "reason": str(e2),
+                        "received": preview,
+                    }
+            # If still not a dict -> maybe python literal
+            if not isinstance(replacements_data, dict):
+                try:
+                    replacements_data = ast.literal_eval(diff)
+                except Exception as e3:
+                    return {
+                        "error": "Diff is neither valid JSON nor Python literal.",
+                        "reason": str(e3),
+                        "received": preview,
+                    }
+            replacements = replacements_data.get("replacements", []) if isinstance(replacements_data, dict) else []
+            if not replacements:
+                return {
+                    "error": "No valid replacements found in diff.",
+                    "received": preview,
+                }
+            with open(file_path, "r", encoding="utf-8") as f:
+                current_content = f.read()
+            modified_content = current_content
+            applied_replacements = []
+            for i, replacement in enumerate(replacements, 1):
+                old_str = replacement.get("old_str", "")
+                new_str = replacement.get("new_str", "")
+                if not old_str:
+                    console.print(f"[bold yellow]Warning:[/bold yellow] Replacement #{i} has empty old_str")
+                    continue
+                if old_str not in modified_content:
+                    console.print(f"[bold red]Error:[/bold red] Text not found in file: {old_str[:50]}...")
+                    return {"error": f"Text to replace not found in file (replacement #{i})"}
+                modified_content = modified_content.replace(old_str, new_str)
+                applied_replacements.append({"old_str": old_str, "new_str": new_str})
+            diff_lines = list(difflib.unified_diff(current_content.splitlines(keepends=True), modified_content.splitlines(keepends=True), fromfile=f"a/{os.path.basename(file_path)}", tofile=f"b/{os.path.basename(file_path)}", n=3))
+            diff_text = "".join(diff_lines)
+            console.print("[bold cyan]Changes to be applied:[/bold cyan]")
+            if diff_text.strip():
+                formatted_diff = ""
+                for line in diff_lines:
+                    if line.startswith("+") and not line.startswith("+++"):
+                        formatted_diff += f"[bold green]{line}[/bold green]"
+                    elif line.startswith("-") and not line.startswith("---"):
+                        formatted_diff += f"[bold red]{line}[/bold red]"
+                    elif line.startswith("@"):
+                        formatted_diff += f"[bold cyan]{line}[/bold cyan]"
+                    else:
+                        formatted_diff += line
+                console.print(formatted_diff)
+            else:
+                console.print("[dim]No changes detected - file content is identical[/dim]")
+                return {"success": False,"path": file_path,"message": "No changes to apply.","diff": "","changed": False,}
+            with open(file_path, "w", encoding="utf-8") as f:
+                f.write(modified_content)
+            return {"success": True,"path": file_path,"message": f"Applied {len(applied_replacements)} replacements to '{file_path}'","diff": diff_text,"changed": True,"replacements_applied": len(applied_replacements)}
+        except Exception as e:
+            console.print(f"[bold red]Error:[/bold red] {str(e)}")
+            return {"error": f"Error replacing in file '{path}': {str(e)}"}
+
+    @agent.tool
+    def delete_file(context: RunContext, file_path: str) -> Dict[str, Any]:
+        console.log(f"🗑️ Deleting file [bold red]{file_path}[/bold red]")
+        file_path = os.path.abspath(file_path)
+        try:
+            if not os.path.exists(file_path):
+                return {"error": f"File '{file_path}' does not exist."}
+            if not os.path.isfile(file_path):
+                return {"error": f"'{file_path}' is not a file. Use rmdir for directories."}
+            os.remove(file_path)
+            return {"success": True,"path": file_path,"message": f"File '{file_path}' deleted successfully."}
+        except PermissionError:
+            return {"error": f"Permission denied to delete '{file_path}'."}
+        except FileNotFoundError:
+            return {"error": f"File '{file_path}' does not exist."}
+        except Exception as e:
+            return {"error": f"Error deleting file '{file_path}': {str(e)}"}
+
+    @agent.tool(retries=5)
+    def edit_file(context: RunContext, path: str, diff: str) -> Dict[str, Any]:
+        """
+        Unified file editing tool that can:
+        - Create/write a new file when the target does not exist (using raw content or a JSON payload with a "content" key)
+        - Replace text within an existing file via a JSON payload with "replacements" (delegates to internal replace logic)
+        - Delete a snippet from an existing file via a JSON payload with "delete_snippet"
+
+        Parameters
+        ----------
+        path : str
+            Path to the target file (relative or absolute)
+        diff : str
+            Either:
+              * Raw file content (for file creation)
+              * A JSON string with one of the following shapes:
+                  {"content": "full file contents", "overwrite": true}
+                  {"replacements": [ {"old_str": "foo", "new_str": "bar"}, ... ] }
+                  {"delete_snippet": "text to remove"}
+
+        The function auto-detects the payload type and routes to the appropriate internal helper.
+        """
+        file_path = os.path.abspath(path)
+
+        # 1. Attempt to parse the incoming `diff` as JSON (robustly, allowing single quotes)
+        parsed_payload: Dict[str, Any] | None = None
+        try:
+            parsed_payload = json.loads(diff)
+        except json.JSONDecodeError:
+            # Fallback: try to sanitise single quotes
+            try:
+                parsed_payload = json.loads(diff.replace("'", '"'))
+            except Exception:
+                parsed_payload = None
+
+        # ------------------------------------------------------------------
+        # Case A: JSON payload recognised
+        # ------------------------------------------------------------------
+        if isinstance(parsed_payload, dict):
+            # Delete-snippet mode
+            if "delete_snippet" in parsed_payload:
+                snippet = parsed_payload["delete_snippet"]
+                return delete_snippet_from_file(context, file_path, snippet)
+
+            # Replacement mode
+            if "replacements" in parsed_payload:
+                # Forward the ORIGINAL diff string (not parsed) so that the existing logic
+                # which handles various JSON quirks can run unchanged.
+                return replace_in_file(context, file_path, diff)
+
+            # Write / create mode via content field
+            if "content" in parsed_payload:
+                content = parsed_payload["content"]
+                overwrite = bool(parsed_payload.get("overwrite", False))
+                file_exists = os.path.exists(file_path)
+                if file_exists and not overwrite:
+                    return {"success": False, "path": file_path, "message": f"File '{file_path}' exists. Set 'overwrite': true to replace.", "changed": False}
+                if file_exists and overwrite:
+                    # Overwrite directly
+                    try:
+                        with open(file_path, "w", encoding="utf-8") as f:
+                            f.write(content)
+                        return {"success": True, "path": file_path, "message": f"File '{file_path}' overwritten successfully.", "changed": True}
+                    except Exception as e:
+                        return {"error": f"Error overwriting file '{file_path}': {str(e)}"}
+                # File does not exist -> create
+                return write_to_file(context, file_path, content)
+
+        # ------------------------------------------------------------------
+        # Case B: Not JSON or unrecognised structure.
+        # Treat `diff` as raw content for file creation OR as replacement diff.
+        # ------------------------------------------------------------------
+        if not os.path.exists(file_path):
+            # Create new file with provided raw content
+            return write_to_file(context, file_path, diff)
+
+        # If file exists, attempt to treat the raw input as a replacement diff spec.
+        replacement_result = replace_in_file(context, file_path, diff)
+        if replacement_result.get("error"):
+            # Fallback: refuse to overwrite blindly
+            return {"success": False, "path": file_path, "message": "Unrecognised payload and cannot derive edit instructions.", "changed": False}
+        return replacement_result

{code_puppy-0.0.45 → code_puppy-0.0.47}/code_puppy/tools/file_operations.py

@@ -5,6 +5,83 @@ from typing import List, Dict, Any
 from code_puppy.tools.common import console
 from pydantic_ai import RunContext
 
+# ---------------------------------------------------------------------------
+# Module-level helper functions (exposed for unit tests _and_ used as tools)
+# ---------------------------------------------------------------------------
+IGNORE_PATTERNS = [
+    "**/node_modules/**",
+    "**/.git/**",
+    "**/__pycache__/**",
+    "**/.DS_Store",
+    "**/.env",
+    "**/.venv/**",
+    "**/venv/**",
+    "**/.idea/**",
+    "**/.vscode/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/*.pyc",
+    "**/*.pyo",
+    "**/*.pyd",
+    "**/*.so",
+    "**/*.dll",
+    "**/*.exe",
+]
+
+def should_ignore_path(path: str) -> bool:
+    """Return True if *path* matches any pattern in IGNORE_PATTERNS."""
+    for pattern in IGNORE_PATTERNS:
+        if fnmatch.fnmatch(path, pattern):
+            return True
+    return False
+
+def list_files(context: RunContext | None, directory: str = ".", recursive: bool = True) -> List[Dict[str, Any]]:
+    """Light-weight `list_files` implementation sufficient for unit-tests and agent tooling."""
+    directory = os.path.abspath(directory)
+    results: List[Dict[str, Any]] = []
+    if not os.path.exists(directory) or not os.path.isdir(directory):
+        return [{"error": f"Directory '{directory}' does not exist or is not a directory"}]
+    for root, dirs, files in os.walk(directory):
+        rel_root = os.path.relpath(root, directory)
+        if rel_root == ".":
+            rel_root = ""
+        for f in files:
+            fp = os.path.join(rel_root, f) if rel_root else f
+            results.append({"path": fp, "type": "file"})
+        if not recursive:
+            break
+    return results
+
+def read_file(context: RunContext | None, file_path: str) -> Dict[str, Any]:
+    file_path = os.path.abspath(file_path)
+    if not os.path.exists(file_path):
+        return {"error": f"File '{file_path}' does not exist"}
+    if not os.path.isfile(file_path):
+        return {"error": f"'{file_path}' is not a file"}
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            content = f.read()
+        return {"content": content, "path": file_path, "total_lines": len(content.splitlines())}
+    except Exception as exc:
+        return {"error": str(exc)}
+
+def grep(context: RunContext | None, search_string: str, directory: str = ".") -> List[Dict[str, Any]]:
+    matches: List[Dict[str, Any]] = []
+    directory = os.path.abspath(directory)
+    for root, dirs, files in os.walk(directory):
+        for f in files:
+            file_path = os.path.join(root, f)
+            try:
+                with open(file_path, "r", encoding="utf-8") as fh:
+                    for ln, line in enumerate(fh, 1):
+                        if search_string in line:
+                            matches.append({"file_path": file_path, "line_number": ln})
+                            if len(matches) >= 200:
+                                return matches
+            except Exception:
+                continue
+    return matches
+
 def register_file_operations_tools(agent):
     # Constants for file operations
     IGNORE_PATTERNS = [
@@ -145,26 +222,6 @@ def register_file_operations_tools(agent):
         console.print("[dim]" + "-" * 60 + "[/dim]\n")
         return results
 
-    @agent.tool
-    def create_file(context: RunContext, file_path: str, content: str = "") -> Dict[str, Any]:
-        file_path = os.path.abspath(file_path)
-        if os.path.exists(file_path):
-            return {"error": f"File '{file_path}' already exists. Use replace_in_file or write_to_file to edit it."}
-        directory = os.path.dirname(file_path)
-        if directory and not os.path.exists(directory):
-            try:
-                os.makedirs(directory)
-            except Exception as e:
-                return {"error": f"Error creating directory '{directory}': {str(e)}"}
-        try:
-            with open(file_path, "w", encoding="utf-8") as f:
-                console.print("[yellow]Writing to file:[/yellow]")
-                console.print(content)
-                f.write(content)
-            return {"success": True, "path": file_path, "message": f"File created at '{file_path}'", "content_length": len(content)}
-        except Exception as e:
-            return {"error": f"Error creating file '{file_path}': {str(e)}"}
-
     @agent.tool
     def read_file(context: RunContext, file_path: str) -> Dict[str, Any]:
         file_path = os.path.abspath(file_path)

{code_puppy-0.0.45 → code_puppy-0.0.47}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.45"
+version = "0.0.47"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.10"

code_puppy-0.0.45/code_puppy/tools/file_modifications.py

@@ -1,191 +0,0 @@
-# file_modifications.py
-import os
-import difflib
-import json
-from code_puppy.tools.common import console
-from typing import Dict, Any, List
-from pydantic_ai import RunContext
-
-def register_file_modifications_tools(agent):
-    @agent.tool
-    def delete_snippet_from_file(context: RunContext, file_path: str, snippet: str) -> Dict[str, Any]:
-        console.log(f"🗑️ Deleting snippet from file [bold red]{file_path}[/bold red]")
-        file_path = os.path.abspath(file_path)
-        console.print("\n[bold white on red] SNIPPET DELETION [/bold white on red]")
-        console.print(f"[bold yellow]From file:[/bold yellow] {file_path}")
-        try:
-            if not os.path.exists(file_path):
-                console.print(f"[bold red]Error:[/bold red] File '{file_path}' does not exist")
-                return {"error": f"File '{file_path}' does not exist."}
-            if not os.path.isfile(file_path):
-                return {"error": f"'{file_path}' is not a file. Use rmdir for directories."}
-            with open(file_path, "r", encoding="utf-8") as f:
-                content = f.read()
-            if snippet not in content:
-                console.print(f"[bold red]Error:[/bold red] Snippet not found in file '{file_path}'")
-                return {"error": f"Snippet not found in file '{file_path}'."}
-            modified_content = content.replace(snippet, "")
-            diff_lines = list(difflib.unified_diff(content.splitlines(keepends=True), modified_content.splitlines(keepends=True), fromfile=f"a/{os.path.basename(file_path)}", tofile=f"b/{os.path.basename(file_path)}", n=3))
-            diff_text = "".join(diff_lines)
-            console.print("[bold cyan]Changes to be applied:[/bold cyan]")
-            if diff_text.strip():
-                formatted_diff = ""
-                for line in diff_lines:
-                    if line.startswith("+") and not line.startswith("+++"):
-                        formatted_diff += f"[bold green]{line}[/bold green]"
-                    elif line.startswith("-") and not line.startswith("---"):
-                        formatted_diff += f"[bold red]{line}[/bold red]"
-                    elif line.startswith("@"):
-                        formatted_diff += f"[bold cyan]{line}[/bold cyan]"
-                    else:
-                        formatted_diff += line
-                console.print(formatted_diff)
-            else:
-                console.print("[dim]No changes detected[/dim]")
-                return {"success": False, "path": file_path, "message": "No changes needed.", "diff": ""}
-            with open(file_path, "w", encoding="utf-8") as f:
-                f.write(modified_content)
-            return {"success": True, "path": file_path, "message": f"Snippet deleted from file '{file_path}'.", "diff": diff_text}
-        except PermissionError:
-            return {"error": f"Permission denied to delete '{file_path}'."}
-        except FileNotFoundError:
-            return {"error": f"File '{file_path}' does not exist."}
-        except Exception as e:
-            return {"error": f"Error deleting file '{file_path}': {str(e)}"}
-
-    @agent.tool
-    def write_to_file(context: RunContext, path: str, content: str) -> Dict[str, Any]:
-        try:
-            file_path = os.path.abspath(path)
-            os.makedirs(os.path.dirname(file_path), exist_ok=True)
-            console.print("\n[bold white on blue] FILE WRITE [/bold white on blue]")
-            console.print(f"[bold yellow]Writing to:[/bold yellow] {file_path}")
-            file_exists = os.path.exists(file_path)
-            if file_exists:
-                console.print(f'[bold red]Refusing to overwrite existing file:[/bold red] {file_path}')
-                return {'success': False,'path': file_path,'message': f'Cowardly refusing to overwrite existing file: {file_path}','changed': False,}
-            trimmed_content = content
-            max_preview = 1000
-            if len(content) > max_preview:
-                trimmed_content = content[:max_preview] + '... [truncated]'
-            console.print('[bold magenta]Content to be written:[/bold magenta]')
-            console.print(trimmed_content, highlight=False)
-            with open(file_path, 'w', encoding='utf-8') as f:
-                f.write(content)
-            action = "updated" if file_exists else "created"
-            return {"success": True,"path": file_path,"message": f"File '{file_path}' {action} successfully.","diff": trimmed_content,"changed": True,}
-        except Exception as e:
-            console.print(f"[bold red]Error:[/bold red] {str(e)}")
-            return {"error": f"Error writing to file '{path}': {str(e)}"}
-
-    @agent.tool(retries=5)
-    def replace_in_file(context: RunContext, path: str, diff: str) -> Dict[str, Any]:
-        try:
-            file_path = os.path.abspath(path)
-            console.print("\n[bold white on yellow] FILE REPLACEMENTS [/bold white on yellow]")
-            console.print(f"[bold yellow]Modifying:[/bold yellow] {file_path}")
-            if not os.path.exists(file_path):
-                console.print(f"[bold red]Error:[/bold red] File '{file_path}' does not exist")
-                return {"error": f"File '{file_path}' does not exist"}
-            if not os.path.isfile(file_path):
-                return {"error": f"'{file_path}' is not a file."}
-            # ------------------------------------------------------------------
-            # Robust parsing of the diff argument
-            # The agent sometimes sends single-quoted or otherwise invalid JSON.
-            # Attempt to recover by trying several strategies before giving up.
-            # ------------------------------------------------------------------
-            parsed_successfully = False
-            replacements: List[Dict[str, str]] = []
-            try:
-                replacements_data = json.loads(diff)
-                replacements = replacements_data.get("replacements", [])
-                parsed_successfully = True
-            except json.JSONDecodeError:
-                # Fallback 1: convert single quotes to double quotes and retry
-                try:
-                    sanitized = diff.replace("'", '"')
-                    replacements_data = json.loads(sanitized)
-                    replacements = replacements_data.get("replacements", [])
-                    parsed_successfully = True
-                except json.JSONDecodeError:
-                    # Fallback 2: attempt Python literal eval
-                    try:
-                        import ast
-                        replacements_data = ast.literal_eval(diff)
-                        if isinstance(replacements_data, dict):
-                            replacements = replacements_data.get("replacements", []) if "replacements" in replacements_data else []
-                            # If dict keys look like a single replacement, wrap it
-                            if not replacements:
-                                # maybe it's already {"old_str": ..., "new_str": ...}
-                                if all(k in replacements_data for k in ("old_str", "new_str")):
-                                    replacements = [
-                                        {
-                                            "old_str": replacements_data["old_str"],
-                                            "new_str": replacements_data["new_str"],
-                                        }
-                                    ]
-                            parsed_successfully = True
-                    except Exception as e2:
-                        console.print(
-                            f"[bold red]Error:[/bold red] Could not parse diff as JSON or Python literal. Reason: {e2}"
-                        )
-            if not parsed_successfully or not replacements:
-                console.print("[bold red]Error:[/bold red] No valid replacements found in the diff after all parsing attempts")
-                return {"error": "No valid replacements found in the diff"}
-            with open(file_path, "r", encoding="utf-8") as f:
-                current_content = f.read()
-            modified_content = current_content
-            applied_replacements = []
-            for i, replacement in enumerate(replacements, 1):
-                old_str = replacement.get("old_str", "")
-                new_str = replacement.get("new_str", "")
-                if not old_str:
-                    console.print(f"[bold yellow]Warning:[/bold yellow] Replacement #{i} has empty old_str")
-                    continue
-                if old_str not in modified_content:
-                    console.print(f"[bold red]Error:[/bold red] Text not found in file: {old_str[:50]}...")
-                    return {"error": f"Text to replace not found in file (replacement #{i})"}
-                modified_content = modified_content.replace(old_str, new_str)
-                applied_replacements.append({"old_str": old_str, "new_str": new_str})
-            diff_lines = list(difflib.unified_diff(current_content.splitlines(keepends=True), modified_content.splitlines(keepends=True), fromfile=f"a/{os.path.basename(file_path)}", tofile=f"b/{os.path.basename(file_path)}", n=3))
-            diff_text = "".join(diff_lines)
-            console.print("[bold cyan]Changes to be applied:[/bold cyan]")
-            if diff_text.strip():
-                formatted_diff = ""
-                for line in diff_lines:
-                    if line.startswith("+") and not line.startswith("+++"):
-                        formatted_diff += f"[bold green]{line}[/bold green]"
-                    elif line.startswith("-") and not line.startswith("---"):
-                        formatted_diff += f"[bold red]{line}[/bold red]"
-                    elif line.startswith("@"):
-                        formatted_diff += f"[bold cyan]{line}[/bold cyan]"
-                    else:
-                        formatted_diff += line
-                console.print(formatted_diff)
-            else:
-                console.print("[dim]No changes detected - file content is identical[/dim]")
-                return {"success": False,"path": file_path,"message": "No changes to apply.","diff": "","changed": False,}
-            with open(file_path, "w", encoding="utf-8") as f:
-                f.write(modified_content)
-            return {"success": True,"path": file_path,"message": f"Applied {len(applied_replacements)} replacements to '{file_path}'","diff": diff_text,"changed": True,"replacements_applied": len(applied_replacements)}
-        except Exception as e:
-            console.print(f"[bold red]Error:[/bold red] {str(e)}")
-            return {"error": f"Error replacing in file '{path}': {str(e)}"}
-
-    @agent.tool
-    def delete_file(context: RunContext, file_path: str) -> Dict[str, Any]:
-        console.log(f"🗑️ Deleting file [bold red]{file_path}[/bold red]")
-        file_path = os.path.abspath(file_path)
-        try:
-            if not os.path.exists(file_path):
-                return {"error": f"File '{file_path}' does not exist."}
-            if not os.path.isfile(file_path):
-                return {"error": f"'{file_path}' is not a file. Use rmdir for directories."}
-            os.remove(file_path)
-            return {"success": True,"path": file_path,"message": f"File '{file_path}' deleted successfully."}
-        except PermissionError:
-            return {"error": f"Permission denied to delete '{file_path}'."}
-        except FileNotFoundError:
-            return {"error": f"File '{file_path}' does not exist."}
-        except Exception as e:
-            return {"error": f"Error deleting file '{file_path}': {str(e)}"}