code-puppy 0.0.2__tar.gz

code_puppy-0.0.2/.gitignore

@@ -0,0 +1,12 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+.coverage

code_puppy-0.0.2/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,108 @@
+# 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/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_puppy-0.0.2/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_puppy-0.0.2/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_puppy-0.0.2/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_puppy-0.0.2/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_puppy-0.0.2/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