code-puppy 0.0.53__py3-none-any.whl → 0.0.55__py3-none-any.whl

code_puppy/session_memory.py

@@ -3,20 +3,24 @@ from pathlib import Path
 from datetime import datetime, timedelta
 from typing import Any, List, Dict, Optional
 
-DEFAULT_MEMORY_PATH = Path('.puppy_session_memory.json')
+DEFAULT_MEMORY_PATH = Path(".puppy_session_memory.json")
+
 
 class SessionMemory:
     """
     Simple persistent memory for Code Puppy agent sessions.
     Stores short histories of tasks, notes, user preferences, and watched files.
     """
-    def __init__(self, storage_path: Path = DEFAULT_MEMORY_PATH, memory_limit: int = 128):
+
+    def __init__(
+        self, storage_path: Path = DEFAULT_MEMORY_PATH, memory_limit: int = 128
+    ):
         self.storage_path = storage_path
         self.memory_limit = memory_limit
         self._data = {
-            'history': [], # List of task/event dicts
-            'user_preferences': {},
-            'watched_files': [],
+            "history": [],  # List of task/event dicts
+            "user_preferences": {},
+            "watched_files": [],
         }
         self._load()
 
@@ -25,47 +29,55 @@ class SessionMemory:
             try:
                 self._data = json.loads(self.storage_path.read_text())
             except Exception:
-                self._data = {'history': [], 'user_preferences': {}, 'watched_files': []}
+                self._data = {
+                    "history": [],
+                    "user_preferences": {},
+                    "watched_files": [],
+                }
 
     def _save(self):
         try:
             self.storage_path.write_text(json.dumps(self._data, indent=2))
-        except Exception as e:
+        except Exception:
             pass  # Don't crash the agent for memory fails
 
     def log_task(self, description: str, extras: Optional[Dict[str, Any]] = None):
         entry = {
-            'timestamp': datetime.utcnow().isoformat(),
-            'description': description,
+            "timestamp": datetime.utcnow().isoformat(),
+            "description": description,
         }
         if extras:
             entry.update(extras)
-        self._data['history'].append(entry)
+        self._data["history"].append(entry)
         # Trim memory
-        self._data['history'] = self._data['history'][-self.memory_limit:]
+        self._data["history"] = self._data["history"][-self.memory_limit :]
         self._save()
 
     def get_history(self, within_minutes: Optional[int] = None) -> List[Dict[str, Any]]:
         if not within_minutes:
-            return list(self._data['history'])
+            return list(self._data["history"])
         cutoff = datetime.utcnow() - timedelta(minutes=within_minutes)
-        return [h for h in self._data['history'] if datetime.fromisoformat(h['timestamp']) >= cutoff]
+        return [
+            h
+            for h in self._data["history"]
+            if datetime.fromisoformat(h["timestamp"]) >= cutoff
+        ]
 
     def set_preference(self, key: str, value: Any):
-        self._data['user_preferences'][key] = value
+        self._data["user_preferences"][key] = value
         self._save()
 
     def get_preference(self, key: str, default: Any = None) -> Any:
-        return self._data['user_preferences'].get(key, default)
+        return self._data["user_preferences"].get(key, default)
 
     def add_watched_file(self, path: str):
-        if path not in self._data['watched_files']:
-            self._data['watched_files'].append(path)
+        if path not in self._data["watched_files"]:
+            self._data["watched_files"].append(path)
             self._save()
 
     def list_watched_files(self) -> List[str]:
-        return list(self._data['watched_files'])
+        return list(self._data["watched_files"])
 
     def clear(self):
-        self._data = {'history': [], 'user_preferences': {}, 'watched_files': []}
+        self._data = {"history": [], "user_preferences": {}, "watched_files": []}
         self._save()

code_puppy/tools/__init__.py

@@ -3,6 +3,7 @@ from code_puppy.tools.file_modifications import register_file_modifications_tool
 from code_puppy.tools.command_runner import register_command_runner_tools
 from code_puppy.tools.web_search import register_web_search_tools
 
+
 def register_all_tools(agent):
     """Register all available tools to the provided agent."""
     register_file_operations_tools(agent)

code_puppy/tools/code_map.py

@@ -1,9 +1,7 @@
 import os
 import ast
-from typing import List, Tuple
 from rich.tree import Tree
 from rich.text import Text
-from pathlib import Path
 import pathspec
 
 
@@ -36,8 +34,8 @@ def map_python_file(file_path: str, show_doc: bool = True) -> Tree:
                 if doc:
                     t.add(Text(f'"{doc}"', style="dim"))
             # Add inner functions
-            if hasattr(node, 'body'):
-                for subnode in getattr(node, 'body'):
+            if hasattr(node, "body"):
+                for subnode in getattr(node, "body"):
                     subsum = summarize_node(subnode)
                     if subsum:
                         sub_t = Tree(subsum)
@@ -50,13 +48,14 @@ def map_python_file(file_path: str, show_doc: bool = True) -> Tree:
 
 
 def load_gitignore(directory: str):
-    gitignore_file = os.path.join(directory, '.gitignore')
+    gitignore_file = os.path.join(directory, ".gitignore")
     if os.path.exists(gitignore_file):
-        with open(gitignore_file, 'r') as f:
-            spec = pathspec.PathSpec.from_lines('gitwildmatch', f)
+        with open(gitignore_file, "r") as f:
+            spec = pathspec.PathSpec.from_lines("gitwildmatch", f)
         return spec
     else:
-        return pathspec.PathSpec.from_lines('gitwildmatch', [])
+        return pathspec.PathSpec.from_lines("gitwildmatch", [])
+
 
 def make_code_map(directory: str, show_doc: bool = True) -> Tree:
     """
@@ -71,16 +70,22 @@ def make_code_map(directory: str, show_doc: bool = True) -> Tree:
     for root, dirs, files in os.walk(directory):
         rel_root = os.path.relpath(root, abs_directory)
         # Remove ignored directories in-place for os.walk to not descend
-        dirs[:] = [d for d in dirs if not spec.match_file(os.path.normpath(os.path.join(rel_root, d)))]
+        dirs[:] = [
+            d
+            for d in dirs
+            if not spec.match_file(os.path.normpath(os.path.join(rel_root, d)))
+        ]
         for fname in files:
             rel_file = os.path.normpath(os.path.join(rel_root, fname))
-            if fname.endswith('.py') and not fname.startswith("__"):
+            if fname.endswith(".py") and not fname.startswith("__"):
                 if not spec.match_file(rel_file):
                     fpath = os.path.join(root, fname)
                     try:
                         file_tree = map_python_file(fpath, show_doc=show_doc)
                         base_tree.add(file_tree)
                     except Exception as e:
-                        err = Tree(Text(f"[error reading {fname}: {e}]", style="bold red"))
+                        err = Tree(
+                            Text(f"[error reading {fname}: {e}]", style="bold red")
+                        )
                         base_tree.add(err)
     return base_tree

code_puppy/tools/command_runner.py

@@ -1,75 +1,172 @@
-# command_runner.py
 import subprocess
 import time
-import os
 from typing import Dict, Any
 from code_puppy.tools.common import console
 from pydantic_ai import RunContext
 from rich.markdown import Markdown
 from rich.syntax import Syntax
 
-def register_command_runner_tools(agent):
-    @agent.tool
-    def run_shell_command(context: RunContext, command: str, cwd: str = None, timeout: int = 60) -> Dict[str, Any]:
-        if not command or not command.strip():
-            console.print("[bold red]Error:[/bold red] Command cannot be empty")
-            return {"error": "Command cannot be empty"}
-        console.print("\n[bold white on blue] SHELL COMMAND [/bold white on blue]")
-        console.print(f"[bold green]$ {command}[/bold green]")
-        if cwd:
-            console.print(f"[dim]Working directory: {cwd}[/dim]")
-        console.print("[dim]" + "-" * 60 + "[/dim]")
-        from code_puppy.config import get_yolo_mode
-        yolo_mode = get_yolo_mode()
-        if not yolo_mode:
-            user_input = input("Are you sure you want to run this command? (yes/no): ")
-            if user_input.strip().lower() not in {"yes", "y"}:
-                console.print("[bold yellow]Command execution canceled by user.[/bold yellow]")
-                return {"success": False, "command": command, "error": "User canceled command execution"}
+
+def run_shell_command(
+    context: RunContext, command: str, cwd: str = None, timeout: int = 60
+) -> Dict[str, Any]:
+    if not command or not command.strip():
+        console.print("[bold red]Error:[/bold red] Command cannot be empty")
+        return {"error": "Command cannot be empty"}
+    console.print(
+        f"\n[bold white on blue] SHELL COMMAND [/bold white on blue] \U0001f4c2 [bold green]$ {command}[/bold green]"
+    )
+    if cwd:
+        console.print(f"[dim]Working directory: {cwd}[/dim]")
+    console.print("[dim]" + "-" * 60 + "[/dim]")
+    from code_puppy.config import get_yolo_mode
+
+    yolo_mode = get_yolo_mode()
+    if not yolo_mode:
+        user_input = input("Are you sure you want to run this command? (yes/no): ")
+        if user_input.strip().lower() not in {"yes", "y"}:
+            console.print(
+                "[bold yellow]Command execution canceled by user.[/bold yellow]"
+            )
+            return {
+                "success": False,
+                "command": command,
+                "error": "User canceled command execution",
+            }
+    try:
+        start_time = time.time()
+        process = subprocess.Popen(
+            command,
+            shell=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            cwd=cwd,
+        )
         try:
-            start_time = time.time()
-            process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, cwd=cwd)
-            try:
-                stdout, stderr = process.communicate(timeout=timeout)
-                exit_code = process.returncode
-                execution_time = time.time() - start_time
-                if stdout.strip():
-                    console.print("[bold white]STDOUT:[/bold white]")
-                    console.print(Syntax(stdout.strip(), "bash", theme="monokai", background_color="default"))
-                if stderr.strip():
-                    console.print("[bold yellow]STDERR:[/bold yellow]")
-                    console.print(Syntax(stderr.strip(), "bash", theme="monokai", background_color="default"))
-                if exit_code == 0:
-                    console.print(f"[bold green]✓ Command completed successfully[/bold green] [dim](took {execution_time:.2f}s)[/dim]")
-                else:
-                    console.print(f"[bold red]✗ Command failed with exit code {exit_code}[/bold red] [dim](took {execution_time:.2f}s)[/dim]")
-                console.print("[dim]" + "-" * 60 + "[/dim]\n")
-                return {"success": exit_code == 0, "command": command, "stdout": stdout, "stderr": stderr, "exit_code": exit_code, "execution_time": execution_time, "timeout": False}
-            except subprocess.TimeoutExpired:
-                process.kill()
-                stdout, stderr = process.communicate()
-                execution_time = time.time() - start_time
-                if stdout.strip():
-                    console.print("[bold white]STDOUT (incomplete due to timeout):[/bold white]")
-                    console.print(Syntax(stdout.strip(), "bash", theme="monokai", background_color="default"))
-                if stderr.strip():
-                    console.print("[bold yellow]STDERR:[/bold yellow]")
-                    console.print(Syntax(stderr.strip(), "bash", theme="monokai", background_color="default"))
-                console.print(f"[bold red]⏱ Command timed out after {timeout} seconds[/bold red] [dim](ran for {execution_time:.2f}s)[/dim]")
-                console.print("[dim]" + "-" * 60 + "[/dim]\n")
-                return {"success": False,"command": command, "stdout": stdout[-1000:], "stderr": stderr[-1000:], "exit_code": None, "execution_time": execution_time, "timeout": True, "error": f"Command timed out after {timeout} seconds"}
-        except Exception as e:
-            console.print_exception(show_locals=True)
+            stdout, stderr = process.communicate(timeout=timeout)
+            exit_code = process.returncode
+            execution_time = time.time() - start_time
+            if stdout.strip():
+                console.print("[bold white]STDOUT:[/bold white]")
+                console.print(
+                    Syntax(
+                        stdout.strip(),
+                        "bash",
+                        theme="monokai",
+                        background_color="default",
+                    )
+                )
+            else:
+                console.print("[yellow]No STDOUT output[/yellow]")
+            if stderr.strip():
+                console.print("[bold yellow]STDERR:[/bold yellow]")
+                console.print(
+                    Syntax(
+                        stderr.strip(),
+                        "bash",
+                        theme="monokai",
+                        background_color="default",
+                    )
+                )
+            if exit_code == 0:
+                console.print(
+                    f"[bold green]✓ Command completed successfully[/bold green] [dim](took {execution_time:.2f}s)[/dim]"
+                )
+            else:
+                console.print(
+                    f"[bold red]✗ Command failed with exit code {exit_code}[/bold red] [dim](took {execution_time:.2f}s)[/dim]"
+                )
+            if not stdout.strip() and not stderr.strip():
+                console.print(
+                    "[bold yellow]This command produced no output at all![/bold yellow]"
+                )
             console.print("[dim]" + "-" * 60 + "[/dim]\n")
-            return {"success": False, "command": command, "error": f"Error executing command: {str(e)}", "stdout": "", "stderr": "", "exit_code": -1, "timeout": False}
+            return {
+                "success": exit_code == 0,
+                "command": command,
+                "stdout": stdout,
+                "stderr": stderr,
+                "exit_code": exit_code,
+                "execution_time": execution_time,
+                "timeout": False,
+            }
+        except subprocess.TimeoutExpired:
+            process.kill()
+            stdout, stderr = process.communicate()
+            execution_time = time.time() - start_time
+            if stdout.strip():
+                console.print(
+                    "[bold white]STDOUT (incomplete due to timeout):[/bold white]"
+                )
+                console.print(
+                    Syntax(
+                        stdout.strip(),
+                        "bash",
+                        theme="monokai",
+                        background_color="default",
+                    )
+                )
+            if stderr.strip():
+                console.print("[bold yellow]STDERR:[/bold yellow]")
+                console.print(
+                    Syntax(
+                        stderr.strip(),
+                        "bash",
+                        theme="monokai",
+                        background_color="default",
+                    )
+                )
+            console.print(
+                f"[bold red]⏱ Command timed out after {timeout} seconds[/bold red] [dim](ran for {execution_time:.2f}s)[/dim]"
+            )
+            console.print("[dim]" + "-" * 60 + "[/dim]\n")
+            return {
+                "success": False,
+                "command": command,
+                "stdout": stdout[-1000:],
+                "stderr": stderr[-1000:],
+                "exit_code": None,
+                "execution_time": execution_time,
+                "timeout": True,
+                "error": f"Command timed out after {timeout} seconds",
+            }
+    except Exception as e:
+        console.print_exception(show_locals=True)
+        console.print("[dim]" + "-" * 60 + "[/dim]\n")
+        return {
+            "success": False,
+            "command": command,
+            "error": f"Error executing command: {str(e)}",
+            "stdout": "",
+            "stderr": "",
+            "exit_code": -1,
+            "timeout": False,
+        }
+
 
+def share_your_reasoning(
+    context: RunContext, reasoning: str, next_steps: str = None
+) -> Dict[str, Any]:
+    console.print("\n[bold white on purple] AGENT REASONING [/bold white on purple]")
+    console.print("[bold cyan]Current reasoning:[/bold cyan]")
+    console.print(Markdown(reasoning))
+    if next_steps and next_steps.strip():
+        console.print("\n[bold cyan]Planned next steps:[/bold cyan]")
+        console.print(Markdown(next_steps))
+    console.print("[dim]" + "-" * 60 + "[/dim]\n")
+    return {"success": True, "reasoning": reasoning, "next_steps": next_steps}
+
+
+def register_command_runner_tools(agent):
     @agent.tool
-    def share_your_reasoning(context: RunContext, reasoning: str, next_steps: str = None) -> Dict[str, Any]:
-        console.print("\n[bold white on purple] AGENT REASONING [/bold white on purple]")
-        console.print("[bold cyan]Current reasoning:[/bold cyan]")
-        console.print(Markdown(reasoning))
-        if next_steps and next_steps.strip():
-            console.print("\n[bold cyan]Planned next steps:[/bold cyan]")
-            console.print(Markdown(next_steps))
-        console.print("[dim]" + "-" * 60 + "[/dim]\n")
-        return {"success": True, "reasoning": reasoning, "next_steps": next_steps}
+    def agent_run_shell_command(
+        context: RunContext, command: str, cwd: str = None, timeout: int = 60
+    ) -> Dict[str, Any]:
+        return run_shell_command(context, command, cwd, timeout)
+
+    @agent.tool
+    def agent_share_your_reasoning(
+        context: RunContext, reasoning: str, next_steps: str = None
+    ) -> Dict[str, Any]:
+        return share_your_reasoning(context, reasoning, next_steps)

code_puppy/tools/common.py

@@ -1,5 +1,5 @@
 import os
 from rich.console import Console
 
-NO_COLOR = bool(int(os.environ.get('CODE_PUPPY_NO_COLOR', '0')))
+NO_COLOR = bool(int(os.environ.get("CODE_PUPPY_NO_COLOR", "0")))
 console = Console(no_color=NO_COLOR)