code-puppy 0.0.58__tar.gz → 0.0.60__tar.gz

{code_puppy-0.0.58 → code_puppy-0.0.60}/PKG-INFO

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

{code_puppy-0.0.58 → code_puppy-0.0.60}/code_puppy/agent.py

@@ -18,12 +18,23 @@ from code_puppy.tools.common import console
 
 MODELS_JSON_PATH = os.environ.get("MODELS_JSON_PATH", None)
 
-# Load puppy rules if provided
+# Puppy rules loader
 PUPPY_RULES_PATH = Path(".puppy_rules")
 PUPPY_RULES = None
-if PUPPY_RULES_PATH.exists():
-    with open(PUPPY_RULES_PATH, "r") as f:
-        PUPPY_RULES = f.read()
+
+
+def load_puppy_rules(path=None):
+    global PUPPY_RULES
+    rules_path = Path(path) if path else PUPPY_RULES_PATH
+    if rules_path.exists():
+        with open(rules_path, "r") as f:
+            PUPPY_RULES = f.read()
+    else:
+        PUPPY_RULES = None
+
+
+# Load at import
+load_puppy_rules()
 
 
 class AgentResponse(pydantic.BaseModel):

{code_puppy-0.0.58 → code_puppy-0.0.60}/code_puppy/agent_prompts.py

@@ -49,7 +49,7 @@ Example (create):
 edit_file("src/example.py", "print('hello')\n")
 ```
 
-Example (replacement):
+Example (replacement): -- YOU SHOULD PREFER THIS AS THE PRIMARY WAY TO EDIT FILES.
 ```json
 edit_file(
   "src/example.py",

{code_puppy-0.0.58 → code_puppy-0.0.60}/code_puppy/command_line/meta_command_handler.py

@@ -6,6 +6,7 @@ from code_puppy.command_line.model_picker_completion import (
     load_model_names,
     update_model_in_input,
 )
+from code_puppy.config import get_config_keys
 from code_puppy.command_line.utils import make_directory_table
 
 META_COMMANDS_HELP = """
@@ -20,6 +21,12 @@ META_COMMANDS_HELP = """
 
 
 def handle_meta_command(command: str, console: Console) -> bool:
+    """
+    Handle meta/config commands prefixed with '~'.
+    Returns True if the command was handled (even if just an error/help), False if not.
+    """
+    command = command.strip()
+
     # ~codemap (code structure visualization)
     if command.startswith("~codemap"):
         from code_puppy.tools.code_map import make_code_map
@@ -35,11 +42,7 @@ def handle_meta_command(command: str, console: Console) -> bool:
         except Exception as e:
             console.print(f"[red]Error generating code map:[/red] {e}")
         return True
-    """
-    Handle meta/config commands prefixed with '~'.
-    Returns True if the command was handled (even if just an error/help), False if not.
-    """
-    command = command.strip()
+
     if command.startswith("~cd"):
         tokens = command.split()
         if len(tokens) == 1:
@@ -83,7 +86,7 @@ def handle_meta_command(command: str, console: Console) -> bool:
 
     if command.startswith("~set"):
         # Syntax: ~set KEY=VALUE or ~set KEY VALUE
-        from code_puppy.config import get_config_keys, set_config_value
+        from code_puppy.config import set_config_value
 
         tokens = command.split(None, 2)
         argstr = command[len("~set") :].strip()
@@ -100,8 +103,9 @@ def handle_meta_command(command: str, console: Console) -> bool:
             key = tokens[1]
             value = ""
         else:
-            console.print("[yellow]Usage:[/yellow] ~set KEY=VALUE or ~set KEY VALUE")
-            console.print("Config keys: " + ", ".join(get_config_keys()))
+            console.print(
+                f"[yellow]Usage:[/yellow] ~set KEY=VALUE or ~set KEY VALUE\nConfig keys: {', '.join(get_config_keys())}"
+            )
             return True
         if key:
             set_config_value(key, value)
@@ -116,9 +120,11 @@ def handle_meta_command(command: str, console: Console) -> bool:
         # Try setting model and show confirmation
         new_input = update_model_in_input(command)
         if new_input is not None:
+            from code_puppy.command_line.model_picker_completion import get_active_model
             from code_puppy.agent import get_code_generation_agent
 
             model = get_active_model()
+            # Make sure this is called for the test
             get_code_generation_agent(force_reload=True)
             console.print(
                 f"[bold green]Active model set and loaded:[/bold green] [cyan]{model}[/cyan]"
@@ -126,8 +132,8 @@ def handle_meta_command(command: str, console: Console) -> bool:
             return True
         # If no model matched, show available models
         model_names = load_model_names()
+        console.print("[yellow]Usage:[/yellow] ~m <model-name>")
         console.print(f"[yellow]Available models:[/yellow] {', '.join(model_names)}")
-        console.print("[yellow]Usage:[/yellow] ~m <model_name>")
         return True
     if command in ("~help", "~h"):
         console.print(META_COMMANDS_HELP)

{code_puppy-0.0.58 → code_puppy-0.0.60}/code_puppy/command_line/prompt_toolkit_completion.py

@@ -33,53 +33,60 @@ class SetCompleter(Completer):
         self.trigger = trigger
 
     def get_completions(self, document, complete_event):
-        text = document.text_before_cursor
-        if not text.strip().startswith(self.trigger):
+        text_before_cursor = document.text_before_cursor
+        stripped_text_for_trigger_check = text_before_cursor.lstrip()
+
+        if not stripped_text_for_trigger_check.startswith(self.trigger):
             return
-        # If the only thing typed is exactly '~set', suggest space
-        if text.strip() == self.trigger:
+
+        # Determine the part of the text that is relevant for this completer
+        # This handles cases like "  ~set foo" where the trigger isn't at the start of the string
+        actual_trigger_pos = text_before_cursor.find(self.trigger)
+        effective_input = text_before_cursor[
+            actual_trigger_pos:
+        ]  # e.g., "~set keypart" or "~set " or "~set"
+
+        tokens = effective_input.split()
+
+        # Case 1: Input is exactly the trigger (e.g., "~set") and nothing more (not even a trailing space on effective_input).
+        # Suggest adding a space.
+        if (
+            len(tokens) == 1
+            and tokens[0] == self.trigger
+            and not effective_input.endswith(" ")
+        ):
             yield Completion(
-                self.trigger + " ",
-                start_position=-len(self.trigger),
-                display=f"{self.trigger} ",
-                display_meta="set config",
+                text=self.trigger + " ",  # Text to insert
+                start_position=-len(tokens[0]),  # Replace the trigger itself
+                display=self.trigger + " ",  # Visual display
+                display_meta="set config key",
             )
-        tokens = text.strip().split()
-        # completion for the first arg after ~set
-        if len(tokens) == 1:
-            # user just typed ~set <-- suggest config keys
-            base = ""
-        else:
-            base = tokens[1]
+            return
+
+        # Case 2: Input is trigger + space (e.g., "~set ") or trigger + partial key (e.g., "~set partial")
+        base_to_complete = ""
+        if len(tokens) > 1:  # e.g., ["~set", "partialkey"]
+            base_to_complete = tokens[1]
+        # If len(tokens) == 1, it implies effective_input was like "~set ", so base_to_complete remains ""
+        # This means we list all keys.
+
         # --- SPECIAL HANDLING FOR 'model' KEY ---
-        if base == "model":
+        if base_to_complete == "model":
             # Don't return any completions -- let ModelNameCompleter handle it
             return
         for key in get_config_keys():
             if key == "model":
                 continue  # exclude 'model' from regular ~set completions
-            if key.startswith(base):
+            if key.startswith(base_to_complete):
                 prev_value = get_value(key)
-                # Ensure there's a space after '~set' if it's the only thing typed
-                if text.strip() == self.trigger or text.strip() == self.trigger + "":
-                    prefix = self.trigger + " "  # Always enforce a space
-                    insert_text = (
-                        f"{prefix}{key} = {prev_value}"
-                        if prev_value is not None
-                        else f"{prefix}{key} = "
-                    )
-                    sp = -len(text)
-                else:
-                    insert_text = (
-                        f"{key} = {prev_value}"
-                        if prev_value is not None
-                        else f"{key} = "
-                    )
-                    sp = -len(base)
-                # Make it obvious the value part is from before
+                value_part = f" = {prev_value}" if prev_value is not None else " = "
+                completion_text = f"{key}{value_part}"
+
                 yield Completion(
-                    insert_text,
-                    start_position=sp,
+                    completion_text,
+                    start_position=-len(
+                        base_to_complete
+                    ),  # Correctly replace only the typed part of the key
                     display_meta=f"puppy.cfg key (was: {prev_value})"
                     if prev_value is not None
                     else "puppy.cfg key",

{code_puppy-0.0.58 → code_puppy-0.0.60}/code_puppy/model_factory.py

@@ -1,14 +1,9 @@
-import asyncio
 import json
 import os
-import threading
-import time
-from collections import deque
 from typing import Any, Dict
 
 import httpx
 from anthropic import AsyncAnthropic
-from httpx import Response
 from openai import AsyncAzureOpenAI  # For Azure OpenAI client
 from pydantic_ai.models.anthropic import AnthropicModel
 from pydantic_ai.models.gemini import GeminiModel
@@ -27,98 +22,6 @@ from pydantic_ai.providers.openai import OpenAIProvider
 #   Example: "X-Api-Key": "$OPENAI_API_KEY" will use the value from os.environ.get("OPENAI_API_KEY")
 
 
-def make_client(
-    max_requests_per_minute: int = 10, max_retries: int = 3, retry_base_delay: int = 10
-) -> httpx.AsyncClient:
-    # Create a rate limiter using a token bucket approach
-    class RateLimiter:
-        def __init__(self, max_requests_per_minute):
-            self.max_requests_per_minute = max_requests_per_minute
-            self.interval = (
-                60.0 / max_requests_per_minute
-            )  # Time between requests in seconds
-            self.request_times = deque(maxlen=max_requests_per_minute)
-            self.lock = threading.Lock()
-
-        async def acquire(self):
-            """Wait until a request can be made according to the rate limit."""
-            while True:
-                with self.lock:
-                    now = time.time()
-
-                    # Remove timestamps older than 1 minute
-                    while self.request_times and now - self.request_times[0] > 60:
-                        self.request_times.popleft()
-
-                    # If we haven't reached the limit, add the timestamp and proceed
-                    if len(self.request_times) < self.max_requests_per_minute:
-                        self.request_times.append(now)
-                        return
-
-                    # Otherwise, calculate the wait time until we can make another request
-                    oldest = self.request_times[0]
-                    wait_time = max(0, oldest + 60 - now)
-
-                if wait_time > 0:
-                    print(
-                        f"Rate limit would be exceeded. Waiting {wait_time:.2f} seconds before sending request."
-                    )
-                    await asyncio.sleep(wait_time)
-                else:
-                    # Try again immediately
-                    continue
-
-    # Create the rate limiter instance
-    rate_limiter = RateLimiter(max_requests_per_minute)
-
-    def should_retry(response: Response) -> bool:
-        return response.status_code == 429 or (500 <= response.status_code < 600)
-
-    async def request_hook(request):
-        # Wait until we can make a request according to our rate limit
-        await rate_limiter.acquire()
-        return request
-
-    async def response_hook(response: Response) -> Response:
-        retries = getattr(response.request, "_retries", 0)
-
-        if should_retry(response) and retries < max_retries:
-            setattr(response.request, "_retries", retries + 1)
-
-            delay = retry_base_delay * (2**retries)
-
-            if response.status_code == 429:
-                print(
-                    f"Rate limit exceeded. Retrying in {delay:.2f} seconds (attempt {retries + 1}/{max_retries})"
-                )
-            else:
-                print(
-                    f"Server error {response.status_code}. Retrying in {delay:.2f} seconds (attempt {retries + 1}/{max_retries})"
-                )
-
-            await asyncio.sleep(delay)
-
-            new_request = response.request.copy()
-            async with httpx.AsyncClient() as client:
-                # Apply rate limiting to the retry request as well
-                await rate_limiter.acquire()
-                new_response = await client.request(
-                    new_request.method,
-                    str(new_request.url),
-                    headers=new_request.headers,
-                    content=new_request.content,
-                    params=dict(new_request.url.params),
-                )
-                return new_response
-        return response
-
-    # Setup both request and response hooks
-    event_hooks = {"request": [request_hook], "response": [response_hook]}
-
-    client = httpx.AsyncClient(event_hooks=event_hooks)
-    return client
-
-
 def get_custom_config(model_config):
     custom_config = model_config.get("custom_endpoint", {})
     if not custom_config:
@@ -167,17 +70,6 @@ class ModelFactory:
 
         model_type = model_config.get("type")
 
-        # Common configuration for rate limiting and retries
-        max_requests_per_minute = model_config.get("max_requests_per_minute", 100)
-        max_retries = model_config.get("max_retries", 3)
-        retry_base_delay = model_config.get("retry_base_delay", 1.0)
-
-        client = make_client(
-            max_requests_per_minute=max_requests_per_minute,
-            max_retries=max_retries,
-            retry_base_delay=retry_base_delay,
-        )
-
         if model_type == "gemini":
             provider = GoogleGLAProvider(api_key=os.environ.get("GEMINI_API_KEY", ""))
 

{code_puppy-0.0.58 → code_puppy-0.0.60}/code_puppy/models.json

@@ -1,38 +1,23 @@
 {
   "gemini-2.5-flash-preview-05-20": {
     "type": "gemini",
-    "name": "gemini-2.5-flash-preview-05-20",
-    "max_requests_per_minute": 10,
-    "max_retries": 3,
-    "retry_base_delay": 10
+    "name": "gemini-2.5-flash-preview-05-20"
   },
   "gpt-4.1": {
     "type": "openai",
-    "name": "gpt-4.1",
-    "max_requests_per_minute": 100,
-    "max_retries": 3,
-    "retry_base_delay": 10
+    "name": "gpt-4.1"
   },
   "gpt-4.1-mini": {
     "type": "openai",
-    "name": "gpt-4.1-mini",
-    "max_requests_per_minute": 100,
-    "max_retries": 3,
-    "retry_base_delay": 10
+    "name": "gpt-4.1-mini"
   },
   "gpt-4.1-nano": {
     "type": "openai",
-    "name": "gpt-4.1-nano",
-    "max_requests_per_minute": 100,
-    "max_retries": 3,
-    "retry_base_delay": 10
+    "name": "gpt-4.1-nano"
   },
   "gpt-4.1-custom": {
     "type": "custom_openai",
     "name": "gpt-4.1-custom",
-    "max_requests_per_minute": 100,
-    "max_retries": 3,
-    "retry_base_delay": 10,
     "custom_endpoint": {
       "url": "https://my.cute.endpoint:8080",
       "headers": {
@@ -44,9 +29,6 @@
   "ollama-llama3.3": {
     "type": "custom_openai",
     "name": "llama3.3",
-    "max_requests_per_minute": 100,
-    "max_retries": 3,
-    "retry_base_delay": 5,
     "custom_endpoint": {
       "url": "http://localhost:11434/v1"
     }
@@ -54,9 +36,6 @@
   "meta-llama/Llama-3.3-70B-Instruct-Turbo": {
     "type": "custom_openai",
     "name": "meta-llama/Llama-3.3-70B-Instruct-Turbo",
-    "max_requests_per_minute": 100,
-    "max_retries": 3,
-    "retry_base_delay": 5,
     "custom_endpoint": {
       "url": "https://api.together.xyz/v1",
       "api_key": "$TOGETHER_API_KEY"
@@ -65,9 +44,6 @@
   "grok-3-mini-fast": {
     "type": "custom_openai",
     "name": "grok-3-mini-fast",
-    "max_requests_per_minute": 100,
-    "max_retries": 3,
-    "retry_base_delay": 5,
     "custom_endpoint": {
       "url": "https://api.x.ai/v1",
       "api_key": "$XAI_API_KEY"
@@ -76,9 +52,6 @@
   "azure-gpt-4.1": {
     "type": "azure_openai",
     "name": "gpt-4.1",
-    "max_requests_per_minute": 100,
-    "max_retries": 3,
-    "retry_base_delay": 5,
     "api_version": "2024-12-01-preview",
     "api_key": "$AZURE_OPENAI_API_KEY",
     "azure_endpoint": "$AZURE_OPENAI_ENDPOINT"

{code_puppy-0.0.58 → code_puppy-0.0.60}/code_puppy/tools/command_runner.py

@@ -136,12 +136,17 @@ def run_shell_command(
     except Exception as e:
         console.print_exception(show_locals=True)
         console.print("[dim]" + "-" * 60 + "[/dim]\n")
+        # Ensure stdout and stderr are always defined
+        if "stdout" not in locals():
+            stdout = None
+        if "stderr" not in locals():
+            stderr = None
         return {
             "success": False,
             "command": command,
             "error": f"Error executing command: {str(e)}",
-            "stdout": stdout[-1000:],
-            "stderr": stderr[-1000:],
+            "stdout": stdout[-1000:] if stdout else None,
+            "stderr": stderr[-1000:] if stderr else None,
             "exit_code": -1,
             "timeout": False,
         }

{code_puppy-0.0.58 → code_puppy-0.0.60}/code_puppy/tools/file_modifications.py

@@ -205,83 +205,79 @@ def _write_to_file(
         return {"error": str(exc), "diff": ""}
 
 
-def register_file_modifications_tools(agent):
-    """Attach file-editing tools to *agent* with mandatory diff rendering."""
+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]")
+    res = _delete_snippet_from_file(context, file_path, snippet)
+    diff = res.get("diff", "")
+    if diff:
+        _print_diff(diff)
+    return res
 
-    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]")
-        res = _delete_snippet_from_file(context, file_path, snippet)
-        diff = res.get("diff", "")
-        if diff:
-            _print_diff(diff)
-        return res
-
-    def write_to_file(
-        context: RunContext, path: str, content: str, overwrite: bool
-    ) -> Dict[str, Any]:
-        console.log(f"✏️ Writing file [bold blue]{path}[/bold blue]")
-        res = _write_to_file(context, path, content, overwrite=overwrite)
-        diff = res.get("diff", "")
-        if diff:
-            _print_diff(diff)
-        return res
-
-    def replace_in_file(
-        context: RunContext, path: str, replacements: List[Dict[str, str]]
-    ) -> Dict[str, Any]:
-        console.log(f"♻️ Replacing text in [bold yellow]{path}[/bold yellow]")
-        res = _replace_in_file(context, path, replacements)
-        diff = res.get("diff", "")
-        if diff:
-            _print_diff(diff)
-        return res
 
-    @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.
-        """
-        console.print("\n[bold white on blue] EDIT FILE [/bold white on blue]")
-        file_path = os.path.abspath(path)
+def write_to_file(
+    context: RunContext, path: str, content: str, overwrite: bool
+) -> Dict[str, Any]:
+    console.log(f"✏️ Writing file [bold blue]{path}[/bold blue]")
+    res = _write_to_file(context, path, content, overwrite=overwrite)
+    diff = res.get("diff", "")
+    if diff:
+        _print_diff(diff)
+    return res
+
+
+def replace_in_file(
+    context: RunContext, path: str, replacements: List[Dict[str, str]]
+) -> Dict[str, Any]:
+    console.log(f"♻️ Replacing text in [bold yellow]{path}[/bold yellow]")
+    res = _replace_in_file(context, path, replacements)
+    diff = res.get("diff", "")
+    if diff:
+        _print_diff(diff)
+    return res
+
+
+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.
+    """
+    console.print("\n[bold white on blue] EDIT FILE [/bold white on blue]")
+    file_path = os.path.abspath(path)
+    try:
+        parsed_payload = json.loads(diff)
+    except json.JSONDecodeError:
         try:
-            parsed_payload = json.loads(diff)
-        except json.JSONDecodeError:
-            try:
-                console.print(
-                    "[bold yellow] JSON Parsing Failed! TRYING TO REPAIR! [/bold yellow]"
-                )
-                parsed_payload = json.loads(repair_json(diff))
-                console.print(
-                    "[bold green on cyan] SUCCESS - WOOF! [/bold green on cyan]"
-                )
-            except Exception as e:
-                console.print(
-                    f"[bold red] Unable to parse diff [/bold red] -- {str(e)}"
-                )
-                return {
-                    "success": False,
-                    "path": file_path,
-                    "message": f"Unable to parse diff JSON -- {str(e)}",
-                    "changed": False,
-                    "diff": "",
-                }
+            console.print(
+                "[bold yellow] JSON Parsing Failed! TRYING TO REPAIR! [/bold yellow]"
+            )
+            parsed_payload = json.loads(repair_json(diff))
+            console.print("[bold white on blue] SUCCESS - WOOF! [/bold white on blue]")
+        except Exception as e:
+            console.print(f"[bold red] Unable to parse diff [/bold red] -- {str(e)}")
+            return {
+                "success": False,
+                "path": file_path,
+                "message": f"Unable to parse diff JSON -- {str(e)}",
+                "changed": False,
+                "diff": "",
+            }
+    try:
         if isinstance(parsed_payload, dict):
             if "delete_snippet" in parsed_payload:
                 snippet = parsed_payload["delete_snippet"]
@@ -301,49 +297,60 @@ def register_file_modifications_tools(agent):
                         "changed": False,
                     }
                 return write_to_file(context, file_path, content, overwrite)
-        try:
-            write_to_file(context, file_path, diff, overwrite=False)
-        except Exception as e:
-            console.print(
-                "[bold red] Unable to route file modification tool call to sub-tool [/bold red]"
+        return write_to_file(context, file_path, diff, overwrite=False)
+    except Exception as e:
+        console.print(
+            "[bold red] Unable to route file modification tool call to sub-tool [/bold red]"
+        )
+        console.print(str(e))
+        return {
+            "success": False,
+            "path": file_path,
+            "message": f"Something went wrong in file editing: {str(e)}",
+            "changed": False,
+        }
+
+
+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) or not os.path.isfile(file_path):
+            res = {"error": f"File '{file_path}' does not exist.", "diff": ""}
+        else:
+            with open(file_path, "r", encoding="utf-8") as f:
+                original = f.read()
+            diff_text = "".join(
+                difflib.unified_diff(
+                    original.splitlines(keepends=True),
+                    [],
+                    fromfile=f"a/{os.path.basename(file_path)}",
+                    tofile=f"b/{os.path.basename(file_path)}",
+                    n=3,
+                )
             )
-            console.print(str(e))
-            return {
-                "success": False,
+            os.remove(file_path)
+            res = {
+                "success": True,
                 "path": file_path,
-                "message": "Wasn't able to route file modification to the right sub-tool!",
-                "changed": False,
+                "message": f"File '{file_path}' deleted successfully.",
+                "changed": True,
+                "diff": diff_text,
             }
+    except Exception as exc:
+        _log_error("Unhandled exception in delete_file", exc)
+        res = {"error": str(exc), "diff": ""}
+    _print_diff(res.get("diff", ""))
+    return res
+
+
+def register_file_modifications_tools(agent):
+    """Attach file-editing tools to *agent* with mandatory diff rendering."""
 
-    @agent.tool
+    @agent.tool(retries=5)
+    def edit_file(context: RunContext, path: str, diff: str) -> Dict[str, Any]:
+        return _edit_file(context, path, diff)
+
+    @agent.tool(retries=5)
     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) or not os.path.isfile(file_path):
-                res = {"error": f"File '{file_path}' does not exist.", "diff": ""}
-            else:
-                with open(file_path, "r", encoding="utf-8") as f:
-                    original = f.read()
-                diff_text = "".join(
-                    difflib.unified_diff(
-                        original.splitlines(keepends=True),
-                        [],
-                        fromfile=f"a/{os.path.basename(file_path)}",
-                        tofile=f"b/{os.path.basename(file_path)}",
-                        n=3,
-                    )
-                )
-                os.remove(file_path)
-                res = {
-                    "success": True,
-                    "path": file_path,
-                    "message": f"File '{file_path}' deleted successfully.",
-                    "changed": True,
-                    "diff": diff_text,
-                }
-        except Exception as exc:
-            _log_error("Unhandled exception in delete_file", exc)
-            res = {"error": str(exc), "diff": ""}
-        _print_diff(res.get("diff", ""))
-        return res
+        return _delete_file(context, file_path)

{code_puppy-0.0.58 → code_puppy-0.0.60}/code_puppy/tools/file_operations.py

@@ -12,16 +12,33 @@ from code_puppy.tools.common import console
 # ---------------------------------------------------------------------------
 IGNORE_PATTERNS = [
     "**/node_modules/**",
+    "**/node_modules/**/*.js",
+    "node_modules/**",
+    "node_modules",
     "**/.git/**",
+    "**/.git",
+    ".git/**",
+    ".git",
     "**/__pycache__/**",
+    "**/__pycache__",
+    "__pycache__/**",
+    "__pycache__",
     "**/.DS_Store",
+    ".DS_Store",
     "**/.env",
+    ".env",
     "**/.venv/**",
+    "**/.venv",
     "**/venv/**",
+    "**/venv",
     "**/.idea/**",
+    "**/.idea",
     "**/.vscode/**",
+    "**/.vscode",
     "**/dist/**",
+    "**/dist",
     "**/build/**",
+    "**/build",
     "**/*.pyc",
     "**/*.pyo",
     "**/*.pyd",

{code_puppy-0.0.58 → code_puppy-0.0.60}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.58"
+version = "0.0.60"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -24,6 +24,12 @@ dependencies = [
     "rapidfuzz>=3.13.0",
     "json-repair>=0.46.2",
 ]
+dev-dependencies = [
+    "pytest>=8.3.4",
+    "pytest-cov>=6.1.1",
+    "pytest-asyncio>=0.23.1",
+    "ruff>=0.11.11",
+]
 authors = [
     {name = "Michael Pfaffenberger"}
 ]