code-puppy 0.0.2__py3-none-any.whl

code_agent/agent.py

@@ -0,0 +1,19 @@
+import os
+import pydantic
+from pydantic_ai import Agent
+from code_agent.agent_prompts import SYSTEM_PROMPT
+
+# Check if we have a valid API key
+api_key = os.environ.get("OPENAI_API_KEY", "")
+
+class AgentResponse(pydantic.BaseModel):
+    """Represents a response from the agent."""
+    output_message: str = pydantic.Field(..., description="The final output message to display to the user")
+    awaiting_user_input: bool = pydantic.Field(False, description="True if user input is needed to continue the task")
+
+# Create agent with tool usage explicitly enabled
+code_generation_agent = Agent(
+    model='openai:gpt-4.1-mini',
+    system_prompt=SYSTEM_PROMPT,
+    output_type=AgentResponse,
+)

code_agent/agent_prompts.py

@@ -0,0 +1,52 @@
+SYSTEM_PROMPT = """
+You are a code-agent assistant with the ability to use tools to help users complete coding tasks. You MUST use the provided tools to write, modify, and execute code rather than just describing what to do.
+
+Be super informal - we're here to have fun. Writing software is super fun. Don't be scared of being a little bit sarcastic too.
+Be very pedantic about code principles like DRY, YAGNI, and SOLID.
+Be super pedantic about code quality and best practices.
+Be fun and playful. Don't be too serious.
+
+Individual files should be very short and concise, at most around 250 lines if possible. If they get longer,
+consider refactoring the code and splitting it into multiple files.
+
+Always obey the Zen of Python, even if you are not writing Python code.
+
+When given a coding task:
+1. Analyze the requirements carefully
+2. Execute the plan by using appropriate tools
+3. Provide clear explanations for your implementation choices
+4. Continue autonomously whenever possible to achieve the task.
+
+YOU MUST USE THESE TOOLS to complete tasks (do not just describe what should be done - actually do it):
+
+File Operations:
+   - list_files(directory=".", recursive=True): ALWAYS use this to explore directories before trying to read/modify files
+   - read_file(file_path, start_line=0, end_line=None): ALWAYS use this to read existing files before modifying them. Don't read less than 500 lines at a time.
+   - create_file(file_path, content=""): Use this to create new files with content
+   - modify_file(file_path, proposed_changes, replace_content): Use this to replace specific content in files
+   - delete_snippet_from_file(file_path, snippet): Use this to remove specific code snippets from files
+   - delete_file(file_path): Use this to remove files when needed
+
+System Operations:
+   - run_shell_command(command, cwd=None, timeout=60): Use this to execute commands, run tests, or start services
+   - web_search(query): Use this to search the web for information
+   - web_crawl(url): Use this to crawl a website for information
+
+Reasoning & Explanation:
+   - share_your_reasoning(reasoning, next_steps=None): Use this to explicitly share your thought process and planned next steps
+
+Important rules:
+- You MUST use tools to accomplish tasks - DO NOT just output code or descriptions
+- Before every other tool use, you must use "share_your_reasoning" to explain your thought process and planned next steps
+- Check if files exist before trying to modify or delete them
+- After using system operations tools, always explain the results
+- You're encouraged to loop between share_your_reasoning, file tools, and run_shell_command to test output in order to write programs
+- Aim to continue operations independently unless user input is definitively required.
+
+Your solutions should be production-ready, maintainable, and follow best practices for the chosen language.
+
+Return your final response as a structured output having the following fields:
+ * output_message: The final output message to display to the user
+ * awaiting_user_input: True if user input is needed to continue the task. If you get an error, you might consider asking the user for help.
+
+"""

code_agent/main.py

@@ -0,0 +1,234 @@
+import asyncio
+import argparse
+import os
+import readline
+from dotenv import load_dotenv
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.console import ConsoleOptions, RenderResult
+from rich.markdown import CodeBlock
+from rich.text import Text
+from rich.syntax import Syntax
+
+# Initialize rich console for pretty output
+from code_agent.tools.common import console
+from code_agent.agent import code_generation_agent
+
+
+# Define a function to get the secret file path
+def get_secret_file_path():
+    hidden_directory = os.path.join(os.path.expanduser("~"), ".agent_secret")
+    if not os.path.exists(hidden_directory):
+        os.makedirs(hidden_directory)
+    return os.path.join(hidden_directory, "history.txt")
+
+
+async def main():
+    global shutdown_flag
+
+    # Load environment variables from .env file
+    load_dotenv()
+
+    # Set up argument parser
+    parser = argparse.ArgumentParser(
+        description="Code Generation Agent - Similar to Windsurf or Cursor"
+    )
+    parser.add_argument(
+        "--interactive", "-i", action="store_true", help="Run in interactive mode"
+    )
+    parser.add_argument("command", nargs="*", help="Run a single command")
+    args = parser.parse_args()
+
+    history_file_path = get_secret_file_path()
+
+    if args.command:
+        # Join the list of command arguments into a single string command
+        command = " ".join(args.command)
+        try:
+            while not shutdown_flag:
+                response = await code_generation_agent.run(command)
+                console.print(response.output_message)
+                if response.awaiting_user_input:
+                    console.print(
+                        "[bold red]The agent requires further input. Interactive mode is recommended for such tasks."
+                    )
+        except AttributeError as e:
+            console.print(f"[bold red]AttributeError:[/bold red] {str(e)}")
+            console.print(
+                "[bold yellow]\u26a0 The response might not be in the expected format, missing attributes like 'output_message'."
+            )
+        except Exception as e:
+            console.print(f"[bold red]Unexpected Error:[/bold red] {str(e)}")
+    elif args.interactive:
+        await interactive_mode(history_file_path)
+    else:
+        parser.print_help()
+
+
+# Add the file handling functionality for interactive mode
+async def interactive_mode(history_file_path: str) -> None:
+    """Run the agent in interactive mode."""
+    console.print("[bold green]Code Generation Agent[/bold green] - Interactive Mode")
+    console.print("Type 'exit' or 'quit' to exit the interactive mode.")
+    console.print("Type 'clear' to reset the conversation history.")
+
+    message_history = []
+
+    # Set up readline history file in home directory
+    history_file = os.path.expanduser("~/.code_agent_history.txt")
+    history_dir = os.path.dirname(history_file)
+
+    # Ensure history directory exists
+    if history_dir and not os.path.exists(history_dir):
+        try:
+            os.makedirs(history_dir, exist_ok=True)
+        except Exception as e:
+            console.print(
+                f"[yellow]Warning: Could not create history directory: {e}[/yellow]"
+            )
+
+    # Try to read history file
+    try:
+        if os.path.exists(history_file):
+            readline.read_history_file(history_file)
+    except (FileNotFoundError, OSError) as e:
+        console.print(f"[yellow]Warning: Could not read history file: {e}[/yellow]")
+
+    readline.set_history_length(100)
+
+    while True:
+        console.print("[bold blue]Enter your coding task:[/bold blue]")
+
+        try:
+            # Simple single-line input
+            task = input(">>> ")
+
+            # Add to readline history if not empty
+            if task.strip():
+                readline.add_history(task)
+
+            # Save history
+            try:
+                readline.write_history_file(history_file)
+            except Exception as e:
+                console.print(
+                    f"[yellow]Warning: Could not write history file: {e}[/yellow]"
+                )
+
+        except (KeyboardInterrupt, EOFError):
+            # Handle Ctrl+C or Ctrl+D
+            console.print("\n[yellow]Input cancelled[/yellow]")
+            continue
+
+        # Check for exit commands
+        if task.strip().lower() in ["exit", "quit"]:
+            console.print("[bold green]Goodbye![/bold green]")
+            break
+
+        # Check for clear command
+        if task.strip().lower() == "clear":
+            message_history = []
+            console.print("[bold yellow]Conversation history cleared![/bold yellow]")
+            console.print(
+                "[dim]The agent will not remember previous interactions.[/dim]\n"
+            )
+            continue
+
+        if task.strip():
+            console.print(f"\n[bold blue]Processing task:[/bold blue] {task}\n")
+
+            # Write to the secret file for permanent history
+            with open(history_file_path, "a") as history_file:
+                history_file.write(f"{task}\n")
+
+            # Counter for consecutive auto-continue invocations
+            auto_continue_count = 0
+            max_auto_continues = 10
+            is_done = False
+
+            while not is_done and auto_continue_count <= max_auto_continues:
+                try:
+                    prettier_code_blocks()
+
+                    # Only show "asking" message for initial query or if not auto-continuing
+                    if auto_continue_count == 0:
+                        console.log(f"Asking: {task}...", style="cyan")
+                    else:
+                        console.log(
+                            f"Auto-continuing ({auto_continue_count}/{max_auto_continues})...",
+                            style="cyan",
+                        )
+
+                    # Store agent's full response
+                    agent_response = None
+
+                    result = await code_generation_agent.run(
+                        task, message_history=message_history
+                    )
+                    # Get the structured response
+                    agent_response = result.output
+                    console.print(agent_response.output_message)
+
+                    # Update message history with all messages from this interaction
+                    message_history = result.new_messages()
+                    if agent_response:
+                        # Check if the agent needs user input
+                        if agent_response.awaiting_user_input:
+                            console.print(
+                                "\n[bold yellow]\u26a0 Agent needs your input to continue.[/bold yellow]"
+                            )
+                            is_done = True  # Exit the loop to get user input
+                        # Otherwise, auto-continue if we haven't reached the limit
+                        elif auto_continue_count < max_auto_continues:
+                            auto_continue_count += 1
+                            task = "please continue"
+                            console.print(
+                                "\n[yellow]Agent continuing automatically...[/yellow]"
+                            )
+                        else:
+                            # Reached max auto-continues
+                            console.print(
+                                f"\n[bold yellow]\u26a0 Reached maximum of {max_auto_continues} automatic continuations.[/bold yellow]"
+                            )
+                            console.print(
+                                "[dim]You can enter a new request or type 'please continue' to resume.[/dim]"
+                            )
+                            is_done = True
+
+                    # Show context status
+                    console.print(
+                        f"[dim]Context: {len(message_history)} messages in history[/dim]\n"
+                    )
+
+                except Exception:
+                    console.print_exception(show_locals=True)
+                    is_done = True
+
+
+def prettier_code_blocks():
+    class SimpleCodeBlock(CodeBlock):
+        def __rich_console__(
+            self, console: Console, options: ConsoleOptions
+        ) -> RenderResult:
+            code = str(self.text).rstrip()
+            yield Text(self.lexer_name, style="dim")
+            syntax = Syntax(
+                code,
+                self.lexer_name,
+                theme=self.theme,
+                background_color="default",
+                line_numbers=True,
+            )
+            yield syntax
+            yield Text(f"/{self.lexer_name}", style="dim")
+
+    Markdown.elements["fence"] = SimpleCodeBlock
+
+
+def main_entry():
+    """Entry point for the installed CLI tool."""
+    asyncio.run(main())
+
+
+if __name__ == "__main__":
+    main_entry()

code_agent/models/__init__.py

@@ -0,0 +1,4 @@
+"""Code models package."""
+
+# Import models from codesnippet.py
+from code_agent.models.codesnippet import CodeSnippet, CodeResponse

code_agent/models/codesnippet.py

@@ -0,0 +1,20 @@
+from pydantic import BaseModel
+from typing import Optional, List
+
+
+class CodeSnippet(BaseModel):
+    """Model representing a code snippet with explanation."""
+
+    language: str
+    code: str
+    explanation: Optional[str] = None
+    imports: Optional[List[str]] = None
+
+
+class CodeResponse(BaseModel):
+    """Model representing a response with code snippets and explanation."""
+
+    snippets: List[CodeSnippet]
+    overall_explanation: Optional[str] = None
+    success: bool = True
+    error_message: Optional[str] = None

code_agent/tools/__init__.py

@@ -0,0 +1,4 @@
+import code_agent.tools.file_modifications
+import code_agent.tools.file_operations
+import code_agent.tools.command_runner
+import code_agent.tools.web_search

code_agent/tools/command_runner.py

@@ -0,0 +1,187 @@
+# command_runner.py
+import subprocess
+import time
+from typing import Dict, Any
+from code_agent.tools.common import console
+from code_agent.agent import code_generation_agent
+from pydantic_ai import RunContext
+from rich.markdown import Markdown
+from rich.syntax import Syntax
+
+
+@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]")
+
+    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,
+        )
+
+        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]"
+                )
+
+            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,
+                "stderr": stderr,
+                "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)
+        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}

code_agent/tools/common.py

@@ -0,0 +1,3 @@
+from rich.console import Console
+
+console = Console()

code_agent/tools/file_modifications.py

@@ -0,0 +1,264 @@
+# file_modifications.py
+import os
+import difflib
+from code_agent.tools.common import console
+from typing import Dict, Any, Optional
+from code_agent.agent import code_generation_agent
+from pydantic_ai import RunContext
+
+
+import os
+import difflib
+from code_agent.tools.common import console
+from typing import Dict, Any, Optional
+from code_agent.agent import code_generation_agent
+from pydantic_ai import RunContext
+
+@code_generation_agent.tool
+def modify_file(
+    context: RunContext,
+    file_path: str,
+    proposed_changes: str,
+    replace_content: str,
+    overwrite_entire_file: bool = False
+) -> Dict[str, Any]:
+    """Modify a file with proposed changes, generating a diff and applying the changes.
+
+    Args:
+        file_path: Path of the file to modify.
+        proposed_changes: The new content to replace the targeted section or entire file content.
+        replace_content: The content to replace. If blank or not present in the file, the whole file will be replaced ONLY if overwrite_entire_file is True.
+        overwrite_entire_file: Explicitly allow replacing the entire file content (default False). You MUST supply True to allow this.
+
+    Returns:
+        A dictionary with the operation result, including success status, message, and diff.
+    """
+    file_path = os.path.abspath(file_path)
+
+    console.print("\n[bold white on yellow] FILE MODIFICATION [/bold white on yellow]")
+    console.print(f"[bold yellow]Modifying:[/bold yellow] {file_path}")
+
+    try:
+        # Check if the file exists
+        if not os.path.exists(file_path):
+            console.print(f"[bold red]Error:[/bold red] File '{file_path}' does not exist")
+            return {"error": f"File '{file_path}' does not exist"}
+
+        if not os.path.isfile(file_path):
+            console.print(f"[bold red]Error:[/bold red] '{file_path}' is not a file")
+            return {"error": f"'{file_path}' is not a file."}
+
+        with open(file_path, "r", encoding="utf-8") as f:
+            current_content = f.read()
+
+        # Decide how to modify
+        targeted_replacement = bool(replace_content) and (replace_content in current_content)
+        replace_content_provided = bool(replace_content)
+
+        if targeted_replacement:
+            modified_content = current_content.replace(replace_content, proposed_changes)
+            console.print(f"[cyan]Replacing targeted content in '{file_path}'[/cyan]")
+        elif not targeted_replacement:
+            # Only allow full replacement if explicitly authorized
+            if overwrite_entire_file:
+                modified_content = proposed_changes
+                if replace_content_provided:
+                    console.print(f"[bold yellow]Target content not found—replacing the entire file by explicit request (overwrite_entire_file=True).[/bold yellow]")
+                else:
+                    console.print(f"[bold yellow]No target provided—replacing the entire file by explicit request (overwrite_entire_file=True).[/bold yellow]")
+            else:
+                if not replace_content_provided:
+                    msg = "Refusing to replace the entire file: No replace_content provided and overwrite_entire_file=False."
+                else:
+                    msg = "Refusing to replace the entire file: Target content not found in file and overwrite_entire_file=False."
+                console.print(f"[bold red]Error:[/bold red] {msg}")
+                return {
+                    "success": False,
+                    "path": file_path,
+                    "message": msg,
+                    "diff": "",
+                    "changed": False,
+                }
+
+        # Generate a diff for display
+        diff_lines = list(difflib.unified_diff(
+            current_content.splitlines(keepends=True),
+            modified_content.splitlines(keepends=True),
+            fromfile=f"a/{os.path.basename(file_path)}",
+            tofile=f"b/{os.path.basename(file_path)}",
+            n=3,
+        ))
+        diff_text = "".join(diff_lines)
+        console.print("[bold cyan]Changes to be applied:[/bold cyan]")
+        if diff_text.strip():
+            formatted_diff = ""
+            for line in diff_lines:
+                if line.startswith("+") and not line.startswith("+++"):
+                    formatted_diff += f"[bold green]{line}[/bold green]"
+                elif line.startswith("-") and not line.startswith("---"):
+                    formatted_diff += f"[bold red]{line}[/bold red]"
+                elif line.startswith("@"):
+                    formatted_diff += f"[bold cyan]{line}[/bold cyan]"
+                else:
+                    formatted_diff += line
+            console.print(formatted_diff)
+        else:
+            console.print("[dim]No changes detected - file content is identical[/dim]")
+            return {
+                "success": False,
+                "path": file_path,
+                "message": "No changes to apply.",
+                "diff": diff_text,
+                "changed": False,
+            }
+
+        # Write the modified content to the file
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(modified_content)
+
+        return {
+            "success": True,
+            "path": file_path,
+            "message": f"File modified at '{file_path}'",
+            "diff": diff_text,
+            "changed": True,
+        }
+    except Exception as e:
+        return {"error": f"Error modifying file '{file_path}': {str(e)}"}
+
+
+@code_generation_agent.tool
+def delete_snippet_from_file(context: RunContext, file_path: str, snippet: str) -> Dict[str, Any]:
+    console.log(f"🗑️ Deleting snippet from file [bold red]{file_path}[/bold red]")
+    """Delete a snippet from a file at the given file path.
+    
+    Args:
+        file_path: Path to the file to delete.
+        snippet: The snippet to delete.
+        
+    Returns:
+        A dictionary with status and message about the operation.
+    """
+    file_path = os.path.abspath(file_path)
+
+    console.print("\n[bold white on red] SNIPPET DELETION [/bold white on red]")
+    console.print(f"[bold yellow]From file:[/bold yellow] {file_path}")
+
+    try:
+        # Check if the file exists
+        if not os.path.exists(file_path):
+            console.print(f"[bold red]Error:[/bold red] File '{file_path}' does not exist")
+            return {"error": f"File '{file_path}' does not exist."}
+
+        # Check if it's a file (not a directory)
+        if not os.path.isfile(file_path):
+            console.print(f"[bold red]Error:[/bold red] '{file_path}' is not a file")
+            return {"error": f"'{file_path}' is not a file. Use rmdir for directories."}
+
+        # Read the file content
+        with open(file_path, "r", encoding="utf-8") as f:
+            content = f.read()
+
+        # Check if the snippet exists in the file
+        if snippet not in content:
+            console.print(f"[bold red]Error:[/bold red] Snippet not found in file '{file_path}'")
+            return {"error": f"Snippet not found in file '{file_path}'."}
+
+        # Remove the snippet from the file content
+        modified_content = content.replace(snippet, "")
+        
+        # Generate a diff
+        diff_lines = list(
+            difflib.unified_diff(
+                content.splitlines(keepends=True),
+                modified_content.splitlines(keepends=True),
+                fromfile=f"a/{os.path.basename(file_path)}",
+                tofile=f"b/{os.path.basename(file_path)}",
+                n=3,  # Context lines
+            )
+        )
+        
+        diff_text = "".join(diff_lines)
+        
+        # Display the diff
+        console.print("[bold cyan]Changes to be applied:[/bold cyan]")
+        
+        if diff_text.strip():
+            # Format the diff for display with colorization
+            formatted_diff = ""
+            for line in diff_lines:
+                if line.startswith("+") and not line.startswith("+++"):
+                    formatted_diff += f"[bold green]{line}[/bold green]"
+                elif line.startswith("-") and not line.startswith("---"):
+                    formatted_diff += f"[bold red]{line}[/bold red]"
+                elif line.startswith("@"):
+                    formatted_diff += f"[bold cyan]{line}[/bold cyan]"
+                else:
+                    formatted_diff += line
+
+            console.print(formatted_diff)
+        else:
+            console.print("[dim]No changes detected[/dim]")
+            return {
+                "success": False,
+                "path": file_path,
+                "message": "No changes needed.",
+                "diff": "",
+            }
+
+        # Write the modified content back to the file
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(modified_content)
+
+        return {
+            "success": True,
+            "path": file_path,
+            "message": f"Snippet deleted from file '{file_path}'.",
+            "diff": diff_text,
+        }
+    except PermissionError:
+        return {"error": f"Permission denied to delete '{file_path}'."}
+    except FileNotFoundError:
+        # This should be caught by the initial check, but just in case
+        return {"error": f"File '{file_path}' does not exist."}
+    except Exception as e:
+        return {"error": f"Error deleting file '{file_path}': {str(e)}"}
+
+
+@code_generation_agent.tool
+def delete_file(context: RunContext, file_path: str) -> Dict[str, Any]:
+    console.log(f"🗑️ Deleting file [bold red]{file_path}[/bold red]")
+    """Delete a file at the given file path.
+    
+    Args:
+        file_path: Path to the file to delete.
+        
+    Returns:
+        A dictionary with status and message about the operation.
+    """
+    file_path = os.path.abspath(file_path)
+
+    try:
+        # Check if the file exists
+        if not os.path.exists(file_path):
+            return {"error": f"File '{file_path}' does not exist."}
+
+        # Check if it's a file (not a directory)
+        if not os.path.isfile(file_path):
+            return {"error": f"'{file_path}' is not a file. Use rmdir for directories."}
+
+        # Attempt to delete the file
+        os.remove(file_path)
+
+        return {
+            "success": True,
+            "path": file_path,
+            "message": f"File '{file_path}' deleted successfully.",
+        }
+    except PermissionError:
+        return {"error": f"Permission denied to delete '{file_path}'."}
+    except FileNotFoundError:
+        # This should be caught by the initial check, but just in case
+        return {"error": f"File '{file_path}' does not exist."}
+    except Exception as e:
+        return {"error": f"Error deleting file '{file_path}': {str(e)}"}

code_agent/tools/file_operations.py

@@ -0,0 +1,350 @@
+# file_operations.py
+import os
+import fnmatch
+from typing import List, Dict, Any
+from code_agent.tools.common import console
+from pydantic_ai import RunContext
+from code_agent.agent import code_generation_agent
+
+
+# Constants for file operations
+IGNORE_PATTERNS = [
+    "**/node_modules/**",
+    "**/.git/**",
+    "**/__pycache__/**",
+    "**/.DS_Store",
+    "**/.env",
+    "**/.venv/**",
+    "**/venv/**",
+    "**/.idea/**",
+    "**/.vscode/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/*.pyc",
+    "**/*.pyo",
+    "**/*.pyd",
+    "**/*.so",
+    "**/*.dll",
+    "**/*.exe",
+]
+
+
+def should_ignore_path(path: str) -> bool:
+    """Check if the path should be ignored based on patterns."""
+    for pattern in IGNORE_PATTERNS:
+        if fnmatch.fnmatch(path, pattern):
+            return True
+    return False
+
+
+@code_generation_agent.tool
+def list_files(
+    context: RunContext, directory: str = ".", recursive: bool = True
+) -> List[Dict[str, Any]]:
+    """Recursively list all files in a directory, ignoring common patterns.
+
+    Args:
+        directory: The directory to list files from. Defaults to current directory.
+        recursive: Whether to search recursively. Defaults to True.
+
+    Returns:
+        A list of dictionaries with file information including path, size, and type.
+    """
+    results = []
+    directory = os.path.abspath(directory)
+
+    # Display directory listing header
+    console.print("\n[bold white on blue] DIRECTORY LISTING [/bold white on blue]")
+    console.print(
+        f"📂 [bold cyan]{directory}[/bold cyan] [dim](recursive={recursive})[/dim]"
+    )
+    console.print("[dim]" + "-" * 60 + "[/dim]")
+
+    if not os.path.exists(directory):
+        console.print(
+            f"[bold red]Error:[/bold red] Directory '{directory}' does not exist"
+        )
+        console.print("[dim]" + "-" * 60 + "[/dim]\n")
+        return [{"error": f"Directory '{directory}' does not exist"}]
+
+    if not os.path.isdir(directory):
+        console.print(f"[bold red]Error:[/bold red] '{directory}' is not a directory")
+        console.print("[dim]" + "-" * 60 + "[/dim]\n")
+        return [{"error": f"'{directory}' is not a directory"}]
+
+    # Track folders and files at each level for tree display
+    folder_structure = {}
+    file_list = []
+
+    for root, dirs, files in os.walk(directory):
+        # Skip ignored directories
+        dirs[:] = [d for d in dirs if not should_ignore_path(os.path.join(root, d))]
+
+        rel_path = os.path.relpath(root, directory)
+        depth = 0 if rel_path == "." else rel_path.count(os.sep) + 1
+
+        if rel_path == ".":
+            rel_path = ""
+
+        # Add directory entry to results
+        if rel_path:
+            dir_path = os.path.join(directory, rel_path)
+            results.append(
+                {
+                    "path": rel_path,
+                    "type": "directory",
+                    "size": 0,
+                    "full_path": dir_path,
+                    "depth": depth,
+                }
+            )
+
+            # Add to folder structure for display
+            folder_structure[rel_path] = {
+                "path": rel_path,
+                "depth": depth,
+                "full_path": dir_path,
+            }
+
+        # Add file entries
+        for file in files:
+            file_path = os.path.join(root, file)
+            if should_ignore_path(file_path):
+                continue
+
+            rel_file_path = os.path.join(rel_path, file) if rel_path else file
+
+            try:
+                size = os.path.getsize(file_path)
+                file_info = {
+                    "path": rel_file_path,
+                    "type": "file",
+                    "size": size,
+                    "full_path": file_path,
+                    "depth": depth,
+                }
+                results.append(file_info)
+                file_list.append(file_info)
+            except (FileNotFoundError, PermissionError):
+                # Skip files we can't access
+                continue
+
+        if not recursive:
+            break
+
+    # Helper function to format file size
+    def format_size(size_bytes):
+        if size_bytes < 1024:
+            return f"{size_bytes} B"
+        elif size_bytes < 1024 * 1024:
+            return f"{size_bytes / 1024:.1f} KB"
+        elif size_bytes < 1024 * 1024 * 1024:
+            return f"{size_bytes / (1024 * 1024):.1f} MB"
+        else:
+            return f"{size_bytes / (1024 * 1024 * 1024):.1f} GB"
+
+    # Helper function to get file icon based on extension
+    def get_file_icon(file_path):
+        ext = os.path.splitext(file_path)[1].lower()
+        if ext in [".py", ".pyw"]:
+            return "🐍"  # Python
+        elif ext in [".js", ".jsx", ".ts", ".tsx"]:
+            return "📜"  # JavaScript/TypeScript
+        elif ext in [".html", ".htm", ".xml"]:
+            return "🌐"  # HTML/XML
+        elif ext in [".css", ".scss", ".sass"]:
+            return "🎨"  # CSS
+        elif ext in [".md", ".markdown", ".rst"]:
+            return "📝"  # Markdown/docs
+        elif ext in [".json", ".yaml", ".yml", ".toml"]:
+            return "⚙️"  # Config files
+        elif ext in [".jpg", ".jpeg", ".png", ".gif", ".svg", ".webp"]:
+            return "🖼️"  # Images
+        elif ext in [".mp3", ".wav", ".ogg", ".flac"]:
+            return "🎵"  # Audio
+        elif ext in [".mp4", ".avi", ".mov", ".webm"]:
+            return "🎬"  # Video
+        elif ext in [".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx"]:
+            return "📄"  # Documents
+        elif ext in [".zip", ".tar", ".gz", ".rar", ".7z"]:
+            return "📦"  # Archives
+        elif ext in [".exe", ".dll", ".so", ".dylib"]:
+            return "⚡"  # Executables
+        else:
+            return "📄"  # Default file icon
+
+    # Display tree structure
+    if results:
+        # Sort directories and files
+        directories = sorted(
+            [d for d in results if d["type"] == "directory"], key=lambda x: x["path"]
+        )
+        files = sorted(
+            [f for f in results if f["type"] == "file"], key=lambda x: x["path"]
+        )
+
+        # First show directory itself
+        console.print(
+            f"📁 [bold blue]{os.path.basename(directory) or directory}[/bold blue]"
+        )
+
+# After gathering all results
+    # Combine both directories and files, then sort
+    all_items = sorted(results, key=lambda x: x['path'])
+
+    current_depth = 0
+    parent_dirs_with_content = set()
+
+    for i, item in enumerate(all_items):
+        # Skip root directory
+        if item["type"] == "directory" and not item["path"]:
+            continue
+
+        # Get parent directories to track which ones have content
+        if os.sep in item["path"]:
+            parent_path = os.path.dirname(item["path"])
+            parent_dirs_with_content.add(parent_path)
+
+        # Calculate depth from path
+        depth = item["path"].count(os.sep) + 1 if item["path"] else 0
+
+        # Calculate prefix for tree structure
+        prefix = ""
+        for d in range(depth):
+            if d == depth - 1:
+                prefix += "└── "
+            else:
+                prefix += "    "
+
+        # Display item with appropriate icon and color
+        name = os.path.basename(item["path"]) or item["path"]
+
+        if item["type"] == "directory":
+            console.print(f"{prefix}📁 [bold blue]{name}/[/bold blue]")
+        else:  # file
+            icon = get_file_icon(item["path"])
+            size_str = format_size(item["size"])
+            console.print(
+                f"{prefix}{icon} [green]{name}[/green] [dim]({size_str})[/dim]"
+            )
+    else:
+        console.print("[yellow]Directory is empty[/yellow]")
+
+    # Display summary
+    dir_count = sum(1 for item in results if item["type"] == "directory")
+    file_count = sum(1 for item in results if item["type"] == "file")
+    total_size = sum(item["size"] for item in results if item["type"] == "file")
+
+    console.print("\n[bold cyan]Summary:[/bold cyan]")
+    console.print(
+        f"📁 [blue]{dir_count} directories[/blue], 📄 [green]{file_count} files[/green] [dim]({format_size(total_size)} total)[/dim]"
+    )
+    console.print("[dim]" + "-" * 60 + "[/dim]\n")
+
+    return results
+
+
+@code_generation_agent.tool
+def create_file(
+    context: RunContext, file_path: str, content: str = ""
+) -> Dict[str, Any]:
+    console.log(f"✨ Creating new file [bold green]{file_path}[/bold green]")
+    """Create a new file with optional content.
+    
+    Args:
+        file_path: Path where the file should be created
+        content: Optional content to write to the file
+        
+    Returns:
+        A dictionary with the result of the operation
+    """
+    file_path = os.path.abspath(file_path)
+
+    # Check if file already exists
+    if os.path.exists(file_path):
+        return {
+            "error": f"File '{file_path}' already exists. Use modify_file to edit it."
+        }
+
+    # Create parent directories if they don't exist
+    directory = os.path.dirname(file_path)
+    if directory and not os.path.exists(directory):
+        try:
+            os.makedirs(directory)
+        except Exception as e:
+            return {"error": f"Error creating directory '{directory}': {str(e)}"}
+
+    # Create the file
+    try:
+        with open(file_path, "w", encoding="utf-8") as f:
+            console.print("[yellow]Writing to file:[/yellow]")
+            console.print(content)
+            f.write(content)
+
+        return {
+            "success": True,
+            "path": file_path,
+            "message": f"File created at '{file_path}'",
+            "content_length": len(content),
+        }
+    except Exception as e:
+        return {"error": f"Error creating file '{file_path}': {str(e)}"}
+
+
+@code_generation_agent.tool
+def read_file(
+    context: RunContext, file_path: str, start_line: int = 0, end_line: int = None
+) -> Dict[str, Any]:
+    console.log(
+        f"📄 Reading [bold cyan]{file_path}[/bold cyan] (lines {start_line} to {end_line or 'end'})"
+    )
+    """Read the contents of a file, optionally within a line range.
+    
+    Args:
+        file_path: Path to the file to read
+        start_line: Starting line number (0-indexed). Defaults to 0.
+        end_line: Ending line number (inclusive, 0-indexed). Defaults to None (read to end).
+        
+    Returns:
+        A dictionary with the file contents and metadata.
+    """
+    file_path = os.path.abspath(file_path)
+
+    if not os.path.exists(file_path):
+        return {"error": f"File '{file_path}' does not exist"}
+
+    if not os.path.isfile(file_path):
+        return {"error": f"'{file_path}' is not a file"}
+
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+
+        # Handle line range
+        if end_line is None:
+            end_line = len(lines) - 1
+
+        # Ensure valid range
+        start_line = max(0, min(start_line, len(lines) - 1))
+        end_line = max(start_line, min(end_line, len(lines) - 1))
+
+        selected_lines = lines[start_line : end_line + 1]
+        content = "".join(selected_lines)
+
+        # Get file extension
+        _, ext = os.path.splitext(file_path)
+
+        return {
+            "content": content,
+            "path": file_path,
+            "extension": ext.lstrip("."),
+            "total_lines": len(lines),
+            "read_lines": end_line - start_line + 1,
+            "start_line": start_line,
+            "end_line": end_line,
+        }
+    except UnicodeDecodeError:
+        # For binary files, return an error
+        return {"error": f"Cannot read '{file_path}' as text - it may be a binary file"}
+    except Exception as e:
+        return {"error": f"Error reading file '{file_path}': {str(e)}"}

code_agent/tools/web_search.py

@@ -0,0 +1,41 @@
+from code_agent.agent import code_generation_agent
+from typing import List, Dict
+import requests
+from bs4 import BeautifulSoup
+from pydantic_ai import RunContext
+
+
+@code_generation_agent.tool
+def web_search(
+    context: RunContext, query: str, num_results: int = 5
+) -> List[Dict[str, str]]:
+    """Perform a web search and return a list of results with titles and URLs.
+
+    Args:
+        query: The search query.
+        num_results: Number of results to return. Defaults to 5.
+
+    Returns:
+        A list of dictionaries, each containing 'title' and 'url' for a search result.
+    """
+    search_url = "https://www.google.com/search"
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3"
+    }
+    params = {"q": query}
+
+    response = requests.get(search_url, headers=headers, params=params)
+    response.raise_for_status()
+
+    soup = BeautifulSoup(response.text, "html.parser")
+    results = []
+
+    for g in soup.find_all("div", class_="tF2Cxc")[:num_results]:
+        title_element = g.find("h3")
+        link_element = g.find("a")
+        if title_element and link_element:
+            title = title_element.get_text()
+            url = link_element["href"]
+            results.append({"title": title, "url": url})
+
+    return results

code_puppy-0.0.2.dist-info/METADATA

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: code-puppy
+Version: 0.0.2
+Summary: Code generation agent similar to Windsurf or Cursor
+Author: Windsurf Engineering Team
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.9
+Requires-Dist: bs4>=0.0.2
+Requires-Dist: httpx>=0.24.1
+Requires-Dist: logfire>=0.7.1
+Requires-Dist: pydantic-ai>=0.1.0
+Requires-Dist: pydantic>=2.4.0
+Requires-Dist: pytest-cov>=6.1.1
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: rich>=13.4.2
+Requires-Dist: ruff>=0.11.11
+Description-Content-Type: text/markdown
+
+# Code Generation Agent
+
+## Overview
+
+This project is a sophisticated AI-powered code generation agent, designed to understand programming tasks, generate high-quality code, and explain its reasoning similar to tools like Windsurf and Cursor. 
+
+## Features
+
+- **Multi-language support**: Capable of generating code in various programming languages.
+- **Interactive CLI**: A command-line interface for interactive use.
+- **Detailed explanations**: Provides insights into generated code to understand its logic and structure.
+- **Easy Integration**: Embed it seamlessly into Python projects.
+
+## New Feature
+- **Real-time collaboration**: Allows multiple users to collaboratively edit and review code generation tasks in real-time.
+
+## Installation
+
+> **NOTE:** This project uses [astral-sh/uv](https://github.com/astral-sh/uv) for all dependency management and builds. Please install [uv](https://github.com/astral-sh/uv) before continuing.
+
+1. **Clone the repository**:
+   ```bash
+   git clone <repository_url>
+   cd <repository_name>
+   ```
+2. **Install dependencies**:
+   ```bash
+   uv pip install -e .
+   ```
+3. **(optional)** If contributing, install additional development dependencies:
+   ```bash
+   uv pip install -r dev-requirements.txt  # If present
+   ```
+4. **Configure environment variables**:
+   - Create an `.env` file in the root, using `.env.example` as a template, to store required API keys.
+
+## Usage
+
+### Command Line Interface
+
+Run specific tasks or engage in interactive mode:
+
+```bash
+# Execute a task directly
+uv run python main.py "write me a C++ hello world program in /tmp/main.cpp then compile it and run it"
+
+# Enter interactive mode
+uv run python main.py --interactive
+```
+
+### Python API
+
+Utilize the agent programmatically within your Python scripts:
+
+```python
+import asyncio
+from code_agent.agent_tools import generate_code
+
+async def main():
+    task = "Your task description"
+    response = await generate_code(None, task)
+    
+    if response.success:
+        for snippet in response.snippets:
+            print(f"Language: {snippet.language}")
+            print(snippet.code)
+            print(snippet.explanation)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Explore the `examples` directory for elaborated utilization samples.
+
+## Project Structure
+
+- **`code_agent/agent.py`** - Core functionalities of the agent.
+- **`code_agent/agent_tools.py`** - Tools and utilities for code generation.
+- **`code_agent/agent_prompts.py`** - Templates and prompts used by the system.
+- **`code_agent/models/`** - Data models for defining code and responses.
+- **`examples/`** - Example scripts showcasing agent capabilities.
+- **`main.py`** - Entry point for command-line interactions.
+
+## Contributing
+
+Contributions are welcome! Please follow these steps:
+
+1. Fork the repository.
+2. Create a new branch (`git checkout -b feature/xyz`).
+3. Commit your changes (`git commit -m 'Add feature'`).
+4. Push to the branch (`git push origin feature/xyz`).
+5. Open a Pull Request.
+
+## Requirements
+
+- Python 3.9+
+- [uv](https://github.com/astral-sh/uv) (for dependency management & builds)
+- OpenAI API key (for GPT models)
+- Optionally: Gemini API key (for Google's Gemini models)
+
+## Troubleshooting
+
+- Ensure all dependencies are installed correctly via uv and the environment is properly configured.
+- Check that API keys are valid and not expired.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

code_puppy-0.0.2.dist-info/RECORD

@@ -0,0 +1,16 @@
+code_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+code_agent/agent.py,sha256=kA_goXZ9zT87yPkfpyBIjzz0N3rfUn-C88wAV8iK7pA,689
+code_agent/agent_prompts.py,sha256=6DCCsFIxG8pCSa_uING_mITkQ30N1gh7FBITCl18rJY,3171
+code_agent/main.py,sha256=QuhbNK6bDsu5yRmut2pI174feZPN6WB-2mQsmWZ0yrI,8806
+code_agent/models/__init__.py,sha256=mczyauLuqkIeujryzootps3Zpu5ch2ZrQRAYpurXAE8,132
+code_agent/models/codesnippet.py,sha256=5fgH5HoxE3YZX7DsVwywsZ2-XXotnUfHdvEuzHk0oX8,523
+code_agent/tools/__init__.py,sha256=VOubgURQJYsL5Xp-44rOX5MVwO58PLQ8tMhxNo6ZTWs,157
+code_agent/tools/command_runner.py,sha256=Bz8tDEL7_9MGARX2ARto9xQxa1GtUVkSOgEFCJzCcFs,6514
+code_agent/tools/common.py,sha256=UpMqeJ0C8i0pkue1AHnnyyX0bFJ9zZeJ7HBR6yhuA8A,54
+code_agent/tools/file_modifications.py,sha256=FeDVi-pcKp0q5QJnZsnXaiBn0VDT2Z5pD2cl-fnVLLU,10672
+code_agent/tools/file_operations.py,sha256=NUHsHeO38ahO9sdOAjVES1UHj7-PyAVnyqnbpepRcTA,11747
+code_agent/tools/web_search.py,sha256=vMgfg3g5lEVP2Kbqc1zUWKGwUnNmKJ0CY_zIUGKE7aw,1347
+code_puppy-0.0.2.dist-info/METADATA,sha256=zfX-1rCFsYrCITbEW7E2wqvXBKFS1IQfBk-k4RtITBQ,4354
+code_puppy-0.0.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+code_puppy-0.0.2.dist-info/entry_points.txt,sha256=qzzQH24Qc3KtiZ-FQMBU9ogKmzY_OKm4OtXQv2_IUTw,58
+code_puppy-0.0.2.dist-info/RECORD,,

code_puppy-0.0.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

code_puppy-0.0.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+code-puppy = code_agent.main:main_entry