code-puppy 0.0.159__tar.gz → 0.0.161__tar.gz

{code_puppy-0.0.159 → code_puppy-0.0.161}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.159
+Version: 0.0.161
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

{code_puppy-0.0.159 → code_puppy-0.0.161}/code_puppy/tools/command_runner.py

@@ -494,104 +494,6 @@ def share_your_reasoning(
     return ReasoningOutput(**{"success": True})
 
 
-def register_command_runner_tools(agent):
-    @agent.tool
-    def agent_run_shell_command(
-        context: RunContext, command: str = "", cwd: str = None, timeout: int = 60
-    ) -> ShellCommandOutput:
-        """Execute a shell command with comprehensive monitoring and safety features.
-
-        This tool provides robust shell command execution with streaming output,
-        timeout handling, user confirmation (when not in yolo mode), and proper
-        process lifecycle management. Commands are executed in a controlled
-        environment with cross-platform process group handling.
-
-        Args:
-            context (RunContext): The PydanticAI runtime context for the agent.
-            command (str): The shell command to execute. Cannot be empty or whitespace-only.
-            cwd (str, optional): Working directory for command execution. If None,
-                uses the current working directory. Defaults to None.
-            timeout (int, optional): Inactivity timeout in seconds. If no output is
-                produced for this duration, the process will be terminated.
-                Defaults to 60 seconds.
-
-        Returns:
-            ShellCommandOutput: A structured response containing:
-                - success (bool): True if command executed successfully (exit code 0)
-                - command (str | None): The executed command string
-                - error (str | None): Error message if execution failed
-                - stdout (str | None): Standard output from the command (last 1000 lines)
-                - stderr (str | None): Standard error from the command (last 1000 lines)
-                - exit_code (int | None): Process exit code
-                - execution_time (float | None): Total execution time in seconds
-                - timeout (bool | None): True if command was terminated due to timeout
-                - user_interrupted (bool | None): True if user killed the process
-
-        Note:
-            - In interactive mode (not yolo), user confirmation is required before execution
-            - Commands have an absolute timeout of 270 seconds regardless of activity
-            - Process groups are properly managed for clean termination
-            - Output is streamed in real-time and displayed to the user
-            - Large output is truncated to the last 1000 lines for memory efficiency
-
-        Examples:
-            >>> result = agent_run_shell_command(ctx, "ls -la", cwd="/tmp", timeout=30)
-            >>> if result.success:
-            ...     print(f"Command completed in {result.execution_time:.2f}s")
-            ...     print(result.stdout)
-
-        Warning:
-            This tool can execute arbitrary shell commands. Exercise caution when
-            running untrusted commands, especially those that modify system state.
-        """
-        result = run_shell_command(context, command, cwd, timeout)
-        on_run_shell_command(result)
-
-    @agent.tool
-    def agent_share_your_reasoning(
-        context: RunContext, reasoning: str = "", next_steps: str | None = None
-    ) -> ReasoningOutput:
-        """Share the agent's current reasoning and planned next steps with the user.
-
-        This tool provides transparency into the agent's decision-making process
-        by displaying the current reasoning and upcoming actions in a formatted,
-        user-friendly manner. It's essential for building trust and understanding
-        between the agent and user.
-
-        Args:
-            context (RunContext): The PydanticAI runtime context for the agent.
-            reasoning (str): The agent's current thought process, analysis, or
-                reasoning for the current situation. This should be clear,
-                comprehensive, and explain the 'why' behind decisions.
-            next_steps (str | None, optional): Planned upcoming actions or steps
-                the agent intends to take. Can be None if no specific next steps
-                are determined. Defaults to None.
-
-        Returns:
-            ReasoningOutput: A simple response object containing:
-                - success (bool): Always True, indicating the reasoning was shared
-
-        Note:
-            - Reasoning is displayed with Markdown formatting for better readability
-            - Next steps are only shown if provided and non-empty
-            - Output is visually separated with dividers in TUI mode
-            - This tool should be called before major actions to explain intent
-
-        Examples:
-            >>> reasoning = "I need to analyze the codebase structure before making changes"
-            >>> next_steps = "First, I'll list the directory contents, then read key files"
-            >>> result = agent_share_your_reasoning(ctx, reasoning, next_steps)
-
-        Best Practice:
-            Use this tool frequently to maintain transparency. Call it:
-            - Before starting complex operations
-            - When changing strategy or approach
-            - To explain why certain decisions are being made
-            - When encountering unexpected situations
-        """
-        return share_your_reasoning(context, reasoning, next_steps)
-
-
 def register_agent_run_shell_command(agent):
     """Register only the agent_run_shell_command tool."""
 

{code_puppy-0.0.159 → code_puppy-0.0.161}/code_puppy/tools/file_modifications.py

@@ -448,168 +448,6 @@ def _delete_file(
     return res
 
 
-def register_file_modifications_tools(agent):
-    """Attach file-editing tools to *agent* with mandatory diff rendering."""
-
-    @agent.tool(retries=5)
-    def edit_file(context: RunContext, payload: EditFilePayload) -> Dict[str, Any]:
-        """Comprehensive file editing tool supporting multiple modification strategies.
-
-        This is the primary file modification tool that supports three distinct editing
-        approaches: full content replacement, targeted text replacements, and snippet
-        deletion. It provides robust diff generation, error handling, and automatic
-        retry capabilities for reliable file operations.
-
-        Args:
-            context (RunContext): The PydanticAI runtime context for the agent.
-            payload (EditFilePayload): One of three payload types:
-
-                ContentPayload:
-                    - content (str): Full file content to write
-                    - overwrite (bool, optional): Whether to overwrite existing files.
-                      Defaults to False (safe mode).
-
-                ReplacementsPayload:
-                    - replacements (List[Replacement]): List of text replacements where
-                      each Replacement contains:
-                      - old_str (str): Exact text to find and replace
-                      - new_str (str): Replacement text
-
-                DeleteSnippetPayload:
-                    - delete_snippet (str): Exact text snippet to remove from file
-
-                file_path (str): Path to the target file. Can be relative or absolute.
-                    File will be created if it doesn't exist (for ContentPayload).
-
-        Returns:
-            Dict[str, Any]: Operation result containing:
-                - success (bool): True if operation completed successfully
-                - path (str): Absolute path to the modified file
-                - message (str): Human-readable description of what occurred
-                - changed (bool): True if file content was actually modified
-                - error (str, optional): Error message if operation failed
-
-        Note:
-            - Automatic retry (up to 5 attempts) for transient failures
-            - Unified diff is generated and displayed for all operations
-            - Fuzzy matching (Jaro-Winkler) used for replacements when exact match fails
-            - Minimum similarity threshold of 0.95 for fuzzy replacements
-            - Creates parent directories automatically when needed
-            - UTF-8 encoding enforced for all file operations
-
-        Examples:
-            >>> # Create new file
-            >>> payload = ContentPayload(file_path="foo.py", content="print('Hello World')")
-            >>> result = edit_file(context, payload)
-
-            >>> # Replace specific text
-            >>> replacements = [Replacement(old_str="foo", new_str="bar")]
-            >>> payload = ReplacementsPayload(file_path="foo.py", replacements=replacements)
-            >>> result = edit_file(context, payload)
-
-            >>> # Delete code block
-            >>> payload = DeleteSnippetPayload(file_path="foo.py", delete_snippet="# TODO: remove this")
-            >>> result = edit_file(context, payload)
-
-        Warning:
-            - Always verify file contents after modification
-            - Use overwrite=False by default to prevent accidental data loss
-            - Large files may be slow due to diff generation
-            - Exact string matching required for reliable replacements
-
-        Best Practice:
-            - Use ReplacementsPayload for targeted changes to preserve file structure
-            - Read file first to understand current content before modifications
-            - Keep replacement strings specific and unique to avoid unintended matches
-            - Test modifications on non-critical files first
-        """
-        # Generate group_id for edit_file tool execution
-        if isinstance(payload, str):
-            # Fallback for weird models that just can't help but send json strings...
-            payload = json.loads(json_repair.repair_json(payload))
-            if "replacements" in payload:
-                payload = ReplacementsPayload(**payload)
-            elif "delete_snippet" in payload:
-                payload = DeleteSnippetPayload(**payload)
-            elif "content" in payload:
-                payload = ContentPayload(**payload)
-            else:
-                file_path = "Unknown"
-                if "file_path" in payload:
-                    file_path = payload["file_path"]
-                return {
-                    "success": False,
-                    "path": file_path,
-                    "message": "One of 'content', 'replacements', or 'delete_snippet' must be provided in payload.",
-                    "changed": False,
-                }
-        group_id = generate_group_id("edit_file", payload.file_path)
-        result = _edit_file(context, payload, group_id)
-        on_edit_file(result)
-        if "diff" in result:
-            del result["diff"]
-        return result
-
-    @agent.tool(retries=5)
-    def delete_file(context: RunContext, file_path: str) -> Dict[str, Any]:
-        """Safely delete files with comprehensive logging and diff generation.
-
-        This tool provides safe file deletion with automatic diff generation to show
-        exactly what content was removed. It includes proper error handling and
-        automatic retry capabilities for reliable operation.
-
-        Args:
-            context (RunContext): The PydanticAI runtime context for the agent.
-            file_path (str): Path to the file to delete. Can be relative or absolute.
-                Must be an existing regular file (not a directory).
-
-        Returns:
-            Dict[str, Any]: Operation result containing:
-                - success (bool): True if file was successfully deleted
-                - path (str): Absolute path to the deleted file
-                - message (str): Human-readable description of the operation
-                - changed (bool): True if file was actually removed
-                - error (str, optional): Error message if deletion failed
-
-        Note:
-            - Automatic retry (up to 5 attempts) for transient failures
-            - Complete file content is captured and shown in diff before deletion
-            - Only deletes regular files, not directories or special files
-            - Generates unified diff showing all removed content
-            - Error if file doesn't exist or is not accessible
-
-        Examples:
-            >>> # Delete temporary file
-            >>> result = delete_file(ctx, "temp_output.txt")
-            >>> if result['success']:
-            ...     print(f"Successfully deleted {result['path']}")
-
-            >>> # Delete with error handling
-            >>> result = delete_file(ctx, "config.bak")
-            >>> if 'error' in result:
-            ...     print(f"Deletion failed: {result['error']}")
-
-        Warning:
-            - File deletion is irreversible - ensure you have backups if needed
-            - Will not delete directories (use appropriate directory removal tools)
-            - No "trash" or "recycle bin" - files are permanently removed
-            - Check file importance before deletion
-
-        Best Practice:
-            - Always verify file path before deletion
-            - Review the generated diff to confirm deletion scope
-            - Consider moving files to backup location instead of deleting
-            - Use in combination with list_files to verify target
-        """
-        # Generate group_id for delete_file tool execution
-        group_id = generate_group_id("delete_file", file_path)
-        result = _delete_file(context, file_path, message_group=group_id)
-        on_delete_file(result)
-        if "diff" in result:
-            del result["diff"]
-        return result
-
-
 def register_edit_file(agent):
     """Register only the edit_file tool."""
 
@@ -682,39 +520,31 @@ def register_edit_file(agent):
         """
         # Handle string payload parsing (for models that send JSON strings)
         if isinstance(payload, str):
-            # Fallback for weird models that just can't help but send json strings...
-            payload = json.loads(json_repair.repair_json(payload))
-            if "replacements" in payload and "file_path" in payload:
-                payload = ReplacementsPayload(**payload)
-            elif "delete_snippet" in payload and "file_path" in payload:
-                payload = DeleteSnippetPayload(**payload)
-            elif "content" in payload and "file_path" in payload:
-                payload = ContentPayload(**payload)
-            else:
-                file_path = "Unknown"
-                if "file_path" in payload:
-                    file_path = payload["file_path"]
-                # Diagnose what's missing
-                missing = []
-                if "file_path" not in payload:
-                    missing.append("file_path")
-
-                payload_type = "unknown"
-                if "content" in payload:
-                    payload_type = "content"
-                elif "replacements" in payload:
-                    payload_type = "replacements"
+            try:
+                # Fallback for weird models that just can't help but send json strings...
+                payload = json.loads(json_repair.repair_json(payload))
+                if "replacements" in payload:
+                    payload = ReplacementsPayload(**payload)
                 elif "delete_snippet" in payload:
-                    payload_type = "delete_snippet"
+                    payload = DeleteSnippetPayload(**payload)
+                elif "content" in payload:
+                    payload = ContentPayload(**payload)
                 else:
-                    missing.append("content/replacements/delete_snippet")
-
-                missing_str = ", ".join(missing) if missing else "none"
+                    file_path = "Unknown"
+                    if "file_path" in payload:
+                        file_path = payload["file_path"]
+                    return {
+                        "success": False,
+                        "path": file_path,
+                        "message": "One of 'content', 'replacements', or 'delete_snippet' must be provided in payload.",
+                        "changed": False,
+                    }
+            except Exception as e:
                 return {
                     "success": False,
                     "path": file_path,
-                    "message": f"Invalid payload for {payload_type} operation. Missing required fields: {missing_str}. Payload keys: {list(payload.keys())}",
-                    "changed": False,
+                    "message": f"edit_file call failed: {str(e)}",
+                    "changed": False
                 }
 
         # Call _edit_file which will extract file_path from payload and handle group_id generation

{code_puppy-0.0.159 → code_puppy-0.0.161}/pyproject.toml

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