code-puppy 0.0.45__py3-none-any.whl → 0.0.47__py3-none-any.whl

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/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/tools/file_modifications.py

@@ -6,8 +6,104 @@ 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
+    # @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)
@@ -53,7 +149,7 @@ def register_file_modifications_tools(agent):
         except Exception as e:
             return {"error": f"Error deleting file '{file_path}': {str(e)}"}
 
-    @agent.tool
+    # @agent.tool
     def write_to_file(context: RunContext, path: str, content: str) -> Dict[str, Any]:
         try:
             file_path = os.path.abspath(path)
@@ -78,7 +174,7 @@ def register_file_modifications_tools(agent):
             console.print(f"[bold red]Error:[/bold red] {str(e)}")
             return {"error": f"Error writing to file '{path}': {str(e)}"}
 
-    @agent.tool(retries=5)
+    # @agent.tool(retries=5)
     def replace_in_file(context: RunContext, path: str, diff: str) -> Dict[str, Any]:
         try:
             file_path = os.path.abspath(path)
@@ -94,44 +190,34 @@ def register_file_modifications_tools(agent):
             # 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]] = []
+            preview = (diff[:200] + '...') if len(diff) > 200 else diff
             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
+            except json.JSONDecodeError as e1:
                 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"}
+                    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
@@ -189,3 +275,86 @@ def register_file_modifications_tools(agent):
             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/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.dist-info → code_puppy-0.0.47.dist-info}/METADATA

@@ -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.dist-info → code_puppy-0.0.47.dist-info}/RECORD

@@ -1,6 +1,6 @@
 code_puppy/__init__.py,sha256=orgffM-uGp8g1XCqXGKWaFB4tCCz8TVgsLMPKCOGNx0,81
 code_puppy/agent.py,sha256=avoOEorAYUyQYnYVVCezLz1QKDm0Qgx3i_C-BqgDiQQ,3198
-code_puppy/agent_prompts.py,sha256=O8vzlEPct6qRNhKSRctJRwq3aDOhT_-vyVozS5DtmVA,6554
+code_puppy/agent_prompts.py,sha256=A6ADydqbHozIAtwOy_UY-fYZ2XDE9_5oV3oxOMtVCFA,6782
 code_puppy/config.py,sha256=vBC4JFKNNXUSJ8l4yHF-Vp4lPwMlHNRafb1yxjIpxAE,2202
 code_puppy/main.py,sha256=bc27bk6rFge95H2BumTTzRLtOx43z5FnsmjIjQx_RpU,10052
 code_puppy/model_factory.py,sha256=Pi46jRr7JaBtJfNpSFk-fK2DlBy0Dv6tG2RcXLf4ZVI,11560
@@ -11,18 +11,18 @@ code_puppy/command_line/__init__.py,sha256=y7WeRemfYppk8KVbCGeAIiTuiOszIURCDjOMZ
 code_puppy/command_line/file_path_completion.py,sha256=HAlOu9XVYgJ7FbjdrhKBL0rFmCVFxSGGewdcfKTUsPw,2865
 code_puppy/command_line/meta_command_handler.py,sha256=w9aZoMZVhPQj2Vix3nqW_K9Psou6nU_Jb2dFwr37yKs,3453
 code_puppy/command_line/model_picker_completion.py,sha256=5VEa6OE9shsF0EafJXzBLpFXhFIkqevJi9RRD-eUvZA,3718
-code_puppy/command_line/prompt_toolkit_completion.py,sha256=pOX3gd2-nn42ReM3_pp3g-NxvslZ9tBSd0S_IeyNelk,5156
+code_puppy/command_line/prompt_toolkit_completion.py,sha256=QtXqqEzc6C8ODHTfvIDD1sY0fLaX40S7Sfbol43A9i8,5338
 code_puppy/command_line/utils.py,sha256=L1PnV9tNupEW1zeziyb5aGAq8DYP8sMiuQbFYLO5Nus,1236
 code_puppy/tools/__init__.py,sha256=48BVpMt0HAMtz8G_z9SQhX6LnRqR83_AVfMQMf7bY0g,557
 code_puppy/tools/code_map.py,sha256=BghDHaebhGDfDGvA34gwO_5r92Py4O0Q3J4RV-WtnWs,3155
 code_puppy/tools/command_runner.py,sha256=XDUdVo-9lIegYcYirdbI3qSuJgijBgLnujoYQq5MSe4,4755
 code_puppy/tools/common.py,sha256=dbmyZTrTBQh_0WWpaYN6jEync62W2mMrzNS8UFK0co4,146
-code_puppy/tools/file_modifications.py,sha256=V8as4Pp_qBJSUFuFl5Y-jpiJKH0tUEQ8dNdkGHzpQM0,11645
-code_puppy/tools/file_operations.py,sha256=9M-JntSSTElsLZ1EMLo9Xu2ifje-N0hjXbwARoBm2Tw,9722
+code_puppy/tools/file_modifications.py,sha256=nT87uAoY14RTAapnFCgkLTmW9g9P9bymxts2MpSpoo0,19297
+code_puppy/tools/file_operations.py,sha256=LJU_1b3WCXTAHa2B5VAbckrn1VVWb-HhcI3TF3BxYWs,11625
 code_puppy/tools/web_search.py,sha256=HhcwX0MMvMDPFO8gr8gzgesD5wPXOypjkxyLZeNwL5g,589
-code_puppy-0.0.45.data/data/code_puppy/models.json,sha256=7H-y97YK9BXhag5wJU19rtg24JtZWYx60RsBLBW3WiI,2162
-code_puppy-0.0.45.dist-info/METADATA,sha256=4Z0WVe0KJCQULd1GaPPLptRYEmk7MNGkJP5J_SByFKw,4716
-code_puppy-0.0.45.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-code_puppy-0.0.45.dist-info/entry_points.txt,sha256=d8YkBvIUxF-dHNJAj-x4fPEqizbY5d_TwvYpc01U5kw,58
-code_puppy-0.0.45.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
-code_puppy-0.0.45.dist-info/RECORD,,
+code_puppy-0.0.47.data/data/code_puppy/models.json,sha256=7H-y97YK9BXhag5wJU19rtg24JtZWYx60RsBLBW3WiI,2162
+code_puppy-0.0.47.dist-info/METADATA,sha256=X_fhgMeSahe4T6IeiwYvUIhWpaDTXqy14Oubz0I5Lsg,4716
+code_puppy-0.0.47.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+code_puppy-0.0.47.dist-info/entry_points.txt,sha256=d8YkBvIUxF-dHNJAj-x4fPEqizbY5d_TwvYpc01U5kw,58
+code_puppy-0.0.47.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
+code_puppy-0.0.47.dist-info/RECORD,,