code-puppy 0.0.30__py3-none-any.whl → 0.0.32__py3-none-any.whl

code_puppy/config.py

@@ -0,0 +1,53 @@
+import os
+import configparser
+
+CONFIG_DIR = os.path.join(os.path.expanduser("~"), ".code_puppy")
+CONFIG_FILE = os.path.join(CONFIG_DIR, "puppy.cfg")
+
+DEFAULT_SECTION = "puppy"
+REQUIRED_KEYS = ["puppy_name", "owner_name"]
+
+
+def ensure_config_exists():
+    """
+    Ensure that the .code_puppy dir and puppy.cfg exist, prompting if needed.
+    Returns configparser.ConfigParser for reading.
+    """
+    if not os.path.exists(CONFIG_DIR):
+        os.makedirs(CONFIG_DIR, exist_ok=True)
+    exists = os.path.isfile(CONFIG_FILE)
+    config = configparser.ConfigParser()
+    if exists:
+        config.read(CONFIG_FILE)
+    missing = []
+    if DEFAULT_SECTION not in config:
+        config[DEFAULT_SECTION] = {}
+    for key in REQUIRED_KEYS:
+        if not config[DEFAULT_SECTION].get(key):
+            missing.append(key)
+    if missing:
+        print("🐾 Let's get your Puppy ready!")
+        for key in missing:
+            if key == "puppy_name":
+                val = input("What should we name the puppy? ").strip()
+            elif key == "owner_name":
+                val = input("What's your name (so Code Puppy knows its master)? ").strip()
+            else:
+                val = input(f"Enter {key}: ").strip()
+            config[DEFAULT_SECTION][key] = val
+        with open(CONFIG_FILE, "w") as f:
+            config.write(f)
+    return config
+
+def get_value(key: str):
+    config = configparser.ConfigParser()
+    config.read(CONFIG_FILE)
+    val = config.get(DEFAULT_SECTION, key, fallback=None)
+    return val
+
+
+def get_puppy_name():
+    return get_value("puppy_name") or "Puppy"
+
+def get_owner_name():
+    return get_value("owner_name") or "Master"

code_puppy/main.py

@@ -5,6 +5,7 @@ from code_puppy.version_checker import fetch_latest_version
 from code_puppy import __version__
 import sys
 from dotenv import load_dotenv
+from code_puppy.config import ensure_config_exists
 from rich.console import Console
 from rich.markdown import Markdown
 from rich.console import ConsoleOptions, RenderResult
@@ -12,12 +13,13 @@ from rich.markdown import CodeBlock
 from rich.text import Text
 from rich.syntax import Syntax
 from code_puppy.command_line.prompt_toolkit_completion import (
-    get_input_with_path_completion,
+    get_input_with_combined_completion,
+    get_prompt_with_active_model
 )
 
 # Initialize rich console for pretty output
 from code_puppy.tools.common import console
-from code_puppy.agent import code_generation_agent
+from code_puppy.agent import get_code_generation_agent, session_memory
 
 from code_puppy.tools import *
 
@@ -31,6 +33,8 @@ def get_secret_file_path():
 
 
 async def main():
+    # Ensure the config directory and puppy.cfg with name info exist (prompt user if needed)
+    ensure_config_exists()
     current_version = __version__
     latest_version = fetch_latest_version('code-puppy')
     console.print(f'Current version: {current_version}')
@@ -59,9 +63,18 @@ async def main():
         command = " ".join(args.command)
         try:
             while not shutdown_flag:
-                response = await code_generation_agent.run(command)
+                agent = get_code_generation_agent()
+                response = await agent.run(command)
                 agent_response = response.output
                 console.print(agent_response.output_message)
+                # Log to session memory
+                session_memory().log_task(
+                    f'Command executed: {command}',
+                    extras={ 
+                        'output': agent_response.output_message,
+                        'awaiting_user_input': agent_response.awaiting_user_input
+                    }
+                )
                 if agent_response.awaiting_user_input:
                     console.print(
                         "[bold red]The agent requires further input. Interactive mode is recommended for such tasks."
@@ -82,13 +95,12 @@ async def main():
 
 # Add the file handling functionality for interactive mode
 async def interactive_mode(history_file_path: str) -> None:
+    from code_puppy.command_line.meta_command_handler import handle_meta_command
     """Run the agent in interactive mode."""
     console.print("[bold green]Code Puppy[/bold green] - Interactive Mode")
     console.print("Type 'exit' or 'quit' to exit the interactive mode.")
     console.print("Type 'clear' to reset the conversation history.")
-    console.print(
-        "Type [bold blue]@[/bold blue] followed by a path to use file path completion."
-    )
+    console.print("Type [bold blue]@[/bold blue] for path completion, or [bold blue]~m[/bold blue] to pick a model.")
 
     # Check if prompt_toolkit is installed
     try:
@@ -133,9 +145,10 @@ async def interactive_mode(history_file_path: str) -> None:
         try:
             # Use prompt_toolkit for enhanced input with path completion
             try:
-                # Use the async version of get_input_with_path_completion
-                task = await get_input_with_path_completion(
-                    ">>> 🐶 ", symbol="@", history_file=history_file_path_prompt
+                # Use the async version of get_input_with_combined_completion
+                task = await get_input_with_combined_completion(
+                    get_prompt_with_active_model(),
+                    history_file=history_file_path_prompt
                 )
             except ImportError:
                 # Fall back to basic input if prompt_toolkit is not available
@@ -151,8 +164,8 @@ async def interactive_mode(history_file_path: str) -> None:
             console.print("[bold green]Goodbye![/bold green]")
             break
 
-        # Check for clear command
-        if task.strip().lower() == "clear":
+        # Check for clear command (supports both `clear` and `~clear`)
+        if task.strip().lower() in ("clear", "~clear"):
             message_history = []
             console.print("[bold yellow]Conversation history cleared![/bold yellow]")
             console.print(
@@ -160,6 +173,10 @@ async def interactive_mode(history_file_path: str) -> None:
             )
             continue
 
+        # Handle ~ meta/config commands before anything else
+        if task.strip().startswith('~'):
+            if handle_meta_command(task.strip(), console):
+                continue
         if task.strip():
             console.print(f"\n[bold blue]Processing task:[/bold blue] {task}\n")
 
@@ -175,15 +192,28 @@ async def interactive_mode(history_file_path: str) -> None:
                 # Store agent's full response
                 agent_response = None
 
-                result = await code_generation_agent.run(
-                    task, message_history=message_history
-                )
+                agent = get_code_generation_agent()
+                result = await agent.run(task, message_history=message_history)
                 # Get the structured response
                 agent_response = result.output
                 console.print(agent_response.output_message)
+                # Log to session memory
+                session_memory().log_task(
+                    f'Interactive task: {task}',
+                    extras={ 
+                        'output': agent_response.output_message,
+                        'awaiting_user_input': agent_response.awaiting_user_input
+                    }
+                )
 
-                # Update message history with all messages from this interaction
-                message_history = result.new_messages()
+                # Update message history but apply filters & limits
+                new_msgs = result.new_messages()
+                # 1. Drop any system/config messages (e.g., "agent loaded with model")
+                filtered = [m for m in new_msgs if not (isinstance(m, dict) and m.get("role") == "system")]
+                # 2. Append to existing history and keep only the most recent 40
+                message_history.extend(filtered)
+                if len(message_history) > 40:
+                    message_history = message_history[-40:]
 
                 if agent_response and agent_response.awaiting_user_input:
                     console.print(

code_puppy/session_memory.py

@@ -0,0 +1,71 @@
+import json
+from pathlib import Path
+from datetime import datetime, timedelta
+from typing import Any, List, Dict, Optional
+
+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):
+        self.storage_path = storage_path
+        self.memory_limit = memory_limit
+        self._data = {
+            'history': [], # List of task/event dicts
+            'user_preferences': {},
+            'watched_files': [],
+        }
+        self._load()
+
+    def _load(self):
+        if self.storage_path.exists():
+            try:
+                self._data = json.loads(self.storage_path.read_text())
+            except Exception:
+                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:
+            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,
+        }
+        if extras:
+            entry.update(extras)
+        self._data['history'].append(entry)
+        # Trim memory
+        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'])
+        cutoff = datetime.utcnow() - timedelta(minutes=within_minutes)
+        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._save()
+
+    def get_preference(self, key: str, default: Any = None) -> Any:
+        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)
+            self._save()
+
+    def list_watched_files(self) -> List[str]:
+        return list(self._data['watched_files'])
+
+    def clear(self):
+        self._data = {'history': [], 'user_preferences': {}, 'watched_files': []}
+        self._save()

code_puppy/tools/__init__.py

@@ -1,4 +1,11 @@
-import code_puppy.tools.file_modifications
-import code_puppy.tools.file_operations
-import code_puppy.tools.command_runner
-import code_puppy.tools.web_search
+from code_puppy.tools.file_operations import register_file_operations_tools
+from code_puppy.tools.file_modifications import register_file_modifications_tools
+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)
+    register_file_modifications_tools(agent)
+    register_command_runner_tools(agent)
+    register_web_search_tools(agent)

code_puppy/tools/code_map.py

@@ -0,0 +1,86 @@
+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
+
+
+def summarize_node(node: ast.AST) -> str:
+    if isinstance(node, ast.ClassDef):
+        return f"class {node.name}"
+    if isinstance(node, ast.FunctionDef):
+        return f"def {node.name}()"
+    return ""
+
+
+def get_docstring(node: ast.AST) -> str:
+    doc = ast.get_docstring(node)
+    if doc:
+        lines = doc.strip().split("\n")
+        return lines[0] if lines else doc.strip()
+    return ""
+
+
+def map_python_file(file_path: str, show_doc: bool = True) -> Tree:
+    tree = Tree(Text(file_path, style="bold cyan"))
+    with open(file_path, "r", encoding="utf-8") as f:
+        root = ast.parse(f.read(), filename=file_path)
+    for node in root.body:
+        summary = summarize_node(node)
+        if summary:
+            t = Tree(summary)
+            if show_doc:
+                doc = get_docstring(node)
+                if doc:
+                    t.add(Text(f'"{doc}"', style="dim"))
+            # Add inner functions
+            if hasattr(node, 'body'):
+                for subnode in getattr(node, 'body'):
+                    subsum = summarize_node(subnode)
+                    if subsum:
+                        sub_t = Tree(subsum)
+                        doc2 = get_docstring(subnode)
+                        if doc2:
+                            sub_t.add(Text(f'"{doc2}"', style="dim"))
+                        t.add(sub_t)
+            tree.add(t)
+    return tree
+
+
+def load_gitignore(directory: str):
+    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)
+        return spec
+    else:
+        return pathspec.PathSpec.from_lines('gitwildmatch', [])
+
+def make_code_map(directory: str, show_doc: bool = True) -> Tree:
+    """
+    Recursively build a Tree displaying the code structure of all .py files in a directory,
+    ignoring files listed in .gitignore if present.
+    """
+    base_tree = Tree(Text(directory, style="bold magenta"))
+
+    spec = load_gitignore(directory)
+    abs_directory = os.path.abspath(directory)
+
+    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)))]
+        for fname in files:
+            rel_file = os.path.normpath(os.path.join(rel_root, fname))
+            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"))
+                        base_tree.add(err)
+    return base_tree

code_puppy/tools/command_runner.py

@@ -4,207 +4,71 @@ import time
 import os
 from typing import Dict, Any
 from code_puppy.tools.common import console
-from code_puppy.agent import code_generation_agent
 from pydantic_ai import RunContext
 from rich.markdown import Markdown
 from rich.syntax import Syntax
 
-# Environment variables used in this module:
-# - YOLO_MODE: When set to "true" (case-insensitive), bypasses the safety confirmation
-#              prompt when running shell commands. This allows commands to execute
-#              without user intervention, which can be useful for automation but
-#              introduces security risks. Default is "false".
-
-
-@code_generation_agent.tool
-def run_shell_command(
-    context: RunContext, command: str, cwd: str = None, timeout: int = 60
-) -> Dict[str, Any]:
-    """Run a shell command and return its output.
-
-    Args:
-        command: The shell command to execute.
-        cwd: The current working directory to run the command in. Defaults to None (current directory).
-        timeout: Maximum time in seconds to wait for the command to complete. Defaults to 60.
-
-    Returns:
-        A dictionary with the command result, including stdout, stderr, and exit code.
-    """
-    if not command or not command.strip():
-        console.print("[bold red]Error:[/bold red] Command cannot be empty")
-        return {"error": "Command cannot be empty"}
-
-    # Display command execution in a visually distinct way
-    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]")
-
-    # Check for YOLO_MODE environment variable to bypass safety check
-    yolo_mode = os.getenv("YOLO_MODE", "false").lower() == "true"
-
-    if not yolo_mode:
-        # Prompt user for confirmation before running the command
-        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()
-
-        # Execute the command with timeout
-        process = subprocess.Popen(
-            command,
-            shell=True,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            cwd=cwd,
-        )
-
+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]")
+        yolo_mode = os.getenv("YOLO_MODE", "false").lower() == "true"
+        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:
-            stdout, stderr = process.communicate(timeout=timeout)
-            exit_code = process.returncode
-            execution_time = time.time() - start_time
-
-            # Display command output
-            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",
-                    )
-                )
-
-            # Show execution summary
-            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]"
-                )
-
+            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)
             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:
-            # Kill the process if it times out
-            process.kill()
-            stdout, stderr = process.communicate()
-            execution_time = time.time() - start_time
-
-            # Display timeout information
-            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,  # No exit code since the process was killed
-                "execution_time": execution_time,
-                "timeout": True,
-                "error": f"Command timed out after {timeout} seconds",
-            }
-    except Exception as e:
-        # Display error information
-        console.print_exception(show_locals=True)
+            return {"success": False, "command": command, "error": f"Error executing command: {str(e)}", "stdout": "", "stderr": "", "exit_code": -1, "timeout": False}
+
+    @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": False,
-            "command": command,
-            "error": f"Error executing command: {str(e)}",
-            "stdout": "",
-            "stderr": "",
-            "exit_code": -1,
-            "timeout": False,
-        }
-
-
-@code_generation_agent.tool
-def share_your_reasoning(
-    context: RunContext, reasoning: str, next_steps: str = None
-) -> Dict[str, Any]:
-    """Share the agent's current reasoning and planned next steps with the user.
-
-    Args:
-        reasoning: The agent's current reasoning or thought process.
-        next_steps: Optional description of what the agent plans to do next.
-
-    Returns:
-        A dictionary with the reasoning information.
-    """
-    console.print("\n[bold white on purple] AGENT REASONING [/bold white on purple]")
-
-    # Display the reasoning with markdown formatting
-    console.print("[bold cyan]Current reasoning:[/bold cyan]")
-    console.print(Markdown(reasoning))
-
-    # Display next steps if provided
-    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}
+        return {"success": True, "reasoning": reasoning, "next_steps": next_steps}

code_puppy/tools/common.py

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