code-puppy 0.0.124__py3-none-any.whl → 0.0.126__py3-none-any.whl

code_puppy/agent.py

@@ -6,7 +6,7 @@ from pydantic_ai.mcp import MCPServerSSE, MCPServerStdio, MCPServerStreamableHTT
 from pydantic_ai.settings import ModelSettings
 from pydantic_ai.usage import UsageLimits
 
-from code_puppy.agent_prompts import get_system_prompt
+from code_puppy.agents import get_current_agent_config
 from code_puppy.http_utils import (
     create_reopenable_async_client,
     resolve_env_var_in_header,
@@ -21,7 +21,8 @@ from code_puppy.messaging.message_queue import (
     emit_system_message,
 )
 from code_puppy.model_factory import ModelFactory
-from code_puppy.tools import register_all_tools
+
+# Tool registration is imported on demand
 from code_puppy.tools.common import console
 
 
@@ -131,15 +132,25 @@ def reload_code_generation_agent():
     """Force-reload the agent, usually after a model change."""
     global _code_generation_agent, _LAST_MODEL_NAME
     from code_puppy.config import clear_model_cache, get_model_name
+    from code_puppy.agents import clear_agent_cache
 
     # Clear both ModelFactory cache and config cache when force reloading
     clear_model_cache()
+    clear_agent_cache()
 
     model_name = get_model_name()
     emit_info(f"[bold cyan]Loading Model: {model_name}[/bold cyan]")
     models_config = ModelFactory.load_config()
     model = ModelFactory.get_model(model_name, models_config)
-    instructions = get_system_prompt()
+
+    # Get agent-specific system prompt
+    agent_config = get_current_agent_config()
+    emit_info(
+        f"[bold magenta]Loading Agent: {agent_config.display_name}[/bold magenta]"
+    )
+
+    instructions = agent_config.get_system_prompt()
+
     if PUPPY_RULES:
         instructions += f"\n{PUPPY_RULES}"
 
@@ -161,7 +172,12 @@ def reload_code_generation_agent():
         history_processors=[message_history_accumulator],
         model_settings=model_settings,
     )
-    register_all_tools(agent)
+
+    # Register tools specified by the agent
+    from code_puppy.tools import register_tools_for_agent
+
+    agent_tools = agent_config.get_available_tools()
+    register_tools_for_agent(agent, agent_tools)
     _code_generation_agent = agent
     _LAST_MODEL_NAME = model_name
     return _code_generation_agent

code_puppy/agents/__init__.py

@@ -0,0 +1,25 @@
+"""Agent management system for code-puppy.
+
+This module provides functionality for switching between different agent
+configurations, each with their own system prompts and tool sets.
+"""
+
+from .agent_manager import (
+    get_available_agents,
+    get_current_agent_config,
+    set_current_agent,
+    load_agent_config,
+    get_agent_descriptions,
+    clear_agent_cache,
+    refresh_agents,
+)
+
+__all__ = [
+    "get_available_agents",
+    "get_current_agent_config",
+    "set_current_agent",
+    "load_agent_config",
+    "get_agent_descriptions",
+    "clear_agent_cache",
+    "refresh_agents",
+]

code_puppy/{agent_prompts.py → agents/agent_code_puppy.py}

@@ -1,7 +1,43 @@
-from code_puppy import callbacks
-from code_puppy.config import get_owner_name, get_puppy_name
+"""Code-Puppy - The default code generation agent."""
 
-SYSTEM_PROMPT_TEMPLATE = """
+from code_puppy.config import get_owner_name, get_puppy_name
+from .base_agent import BaseAgent
+from .. import callbacks
+
+
+class CodePuppyAgent(BaseAgent):
+    """Code-Puppy - The default loyal digital puppy code agent."""
+
+    @property
+    def name(self) -> str:
+        return "code-puppy"
+
+    @property
+    def display_name(self) -> str:
+        return "Code-Puppy 🐶"
+
+    @property
+    def description(self) -> str:
+        return "The most loyal digital puppy, helping with all coding tasks"
+
+    def get_available_tools(self) -> list[str]:
+        """Get the list of tools available to Code-Puppy."""
+        return [
+            "list_files",
+            "read_file",
+            "grep",
+            "edit_file",
+            "delete_file",
+            "agent_run_shell_command",
+            "agent_share_your_reasoning",
+        ]
+
+    def get_system_prompt(self) -> str:
+        """Get Code-Puppy's full system prompt."""
+        puppy_name = get_puppy_name()
+        owner_name = get_owner_name()
+
+        result = f"""
 You are {puppy_name}, the most loyal digital puppy, helping your owner {owner_name} get coding stuff done! 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.
@@ -104,15 +140,12 @@ Important rules:
 Your solutions should be production-ready, maintainable, and follow best practices for the chosen language.
 
 Return your final response as a string output
+Walmart specific rules:
+ - You are operating inside Walmart Global Tech! Yay!
+ - Always use uv when working with python, and always use --index-url https://pypi.ci.artifacts.walmart.com/artifactory/api/pypi/external-pypi/simple
 """
 
-
-def get_system_prompt():
-    """Returns the main system prompt, populated with current puppy and owner name."""
-    prompt_additions = callbacks.on_load_prompt()
-    main_prompt = SYSTEM_PROMPT_TEMPLATE.format(
-        puppy_name=get_puppy_name(), owner_name=get_owner_name()
-    )
-    if len(prompt_additions):
-        main_prompt += "\n".join(prompt_additions)
-    return main_prompt
+        prompt_additions = callbacks.on_load_prompt()
+        if len(prompt_additions):
+            result += "\n".join(prompt_additions)
+        return result

code_puppy/agents/agent_creator_agent.py

@@ -0,0 +1,446 @@
+"""Agent Creator - helps users create new JSON agents."""
+
+import json
+import os
+from typing import Dict, List, Optional
+
+from .base_agent import BaseAgent
+from code_puppy.config import get_user_agents_directory
+from code_puppy.tools import get_available_tool_names
+
+
+class AgentCreatorAgent(BaseAgent):
+    """Specialized agent for creating JSON agent configurations."""
+
+    @property
+    def name(self) -> str:
+        return "agent-creator"
+
+    @property
+    def display_name(self) -> str:
+        return "Agent Creator 🏗️"
+
+    @property
+    def description(self) -> str:
+        return "Helps you create new JSON agent configurations with proper schema validation"
+
+    def get_system_prompt(self) -> str:
+        available_tools = get_available_tool_names()
+        agents_dir = get_user_agents_directory()
+
+        return f"""You are the Agent Creator! 🏗️ Your mission is to help users create awesome JSON agent files through an interactive process.
+
+You specialize in:
+- Guiding users through the JSON agent schema
+- **ALWAYS asking what tools the agent should have**
+- **Suggesting appropriate tools based on the agent's purpose**
+- **Informing users about all available tools**
+- Validating agent configurations
+- Creating properly structured JSON agent files
+- Explaining agent capabilities and best practices
+
+## MANDATORY TOOL SELECTION PROCESS
+
+**YOU MUST ALWAYS:**
+1. Ask the user what the agent should be able to do
+2. Based on their answer, suggest specific tools that would be helpful
+3. List ALL available tools so they can see other options
+4. Ask them to confirm their tool selection
+5. Explain why each selected tool is useful for their agent
+
+## JSON Agent Schema
+
+Here's the complete schema for JSON agent files:
+
+```json
+{{
+  "id": "uuid"                       // REQUIRED: you can gen one on the command line or something"
+  "name": "agent-name",              // REQUIRED: Unique identifier (no spaces, use hyphens)
+  "display_name": "Agent Name 🤖",   // OPTIONAL: Pretty name with emoji
+  "description": "What this agent does", // REQUIRED: Clear description
+  "system_prompt": "Instructions...",    // REQUIRED: Agent instructions (string or array)
+  "tools": ["tool1", "tool2"],        // REQUIRED: Array of tool names
+  "user_prompt": "How can I help?",     // OPTIONAL: Custom greeting
+  "tools_config": {{                    // OPTIONAL: Tool configuration
+    "timeout": 60
+  }}
+}}
+```
+
+### Required Fields:
+- `name`: Unique identifier (kebab-case recommended)
+- `description`: What the agent does
+- `system_prompt`: Agent instructions (string or array of strings)
+- `tools`: Array of available tool names
+
+### Optional Fields:
+- `display_name`: Pretty display name (defaults to title-cased name + 🤖)
+- `user_prompt`: Custom user greeting
+- `tools_config`: Tool configuration object
+
+## ALL AVAILABLE TOOLS:
+{", ".join(f"- **{tool}**" for tool in available_tools)}
+
+## Tool Categories & Suggestions:
+
+### 📁 **File Operations** (for agents working with files):
+- `list_files` - Browse and explore directory structures
+- `read_file` - Read file contents (essential for most file work)
+- `edit_file` - Modify files (create, update, replace text)
+- `delete_file` - Remove files when needed
+- `grep` - Search for text patterns across files
+
+### 💻 **Command Execution** (for agents running programs):
+- `agent_run_shell_command` - Execute terminal commands and scripts
+
+### 🧠 **Communication & Reasoning** (for all agents):
+- `agent_share_your_reasoning` - Explain thought processes (recommended for most agents)
+
+## Detailed Tool Documentation (Instructions for Agent Creation)
+
+Whenever you create agents, you should always replicate these detailed tool descriptions and examples in their system prompts. This ensures consistency and proper tool usage across all agents.
+ - Side note - these tool definitions are also available to you! So use them!
+ 
+### File Operations Documentation:
+
+#### `list_files(directory=".", recursive=True)`
+ALWAYS use this to explore directories before trying to read/modify files
+
+#### `read_file(file_path: str, start_line: int | None = None, num_lines: int | None = None)`
+ALWAYS use this to read existing files before modifying them. By default, read the entire file. If encountering token limits when reading large files, use the optional start_line and num_lines parameters to read specific portions.
+
+#### `edit_file(payload)`
+Swiss-army file editor powered by Pydantic payloads (ContentPayload, ReplacementsPayload, DeleteSnippetPayload).
+
+#### `delete_file(file_path)`
+Use this to remove files when needed
+
+#### `grep(search_string, directory=".")`
+Use this to recursively search for a string across files starting from the specified directory, capping results at 200 matches.
+
+### Tool Usage Instructions:
+
+#### `edit_file` tool usage details:
+This is an all-in-one file-modification tool. It supports the following Pydantic Object payload types:
+1. ContentPayload: {{ file_path="example.py", "content": "…", "overwrite": true|false }}  →  Create or overwrite a file with the provided content.
+2. ReplacementsPayload: {{  file_path="example.py", "replacements": [ {{ "old_str": "…", "new_str": "…" }}, … ] }}  →  Perform exact text replacements inside an existing file.
+3. DeleteSnippetPayload: {{ file_path="example.py", "delete_snippet": "…" }}  →  Remove a snippet of text from an existing file.
+
+Arguments:
+- payload (required): One of the Pydantic payload types above.
+
+Example (create):
+```python
+edit_file(payload={{file_path="example.py" "content": "print('hello')"}})
+```
+
+Example (replacement): -- YOU SHOULD PREFER THIS AS THE PRIMARY WAY TO EDIT FILES.
+```python
+edit_file(
+  payload={{file_path="example.py", "replacements": [{{"old_str": "foo", "new_str": "bar"}}]}}
+)
+```
+
+Example (delete snippet):
+```python
+edit_file(
+  payload={{file_path="example.py", "delete_snippet": "# TODO: remove this line"}}
+)
+```
+
+NEVER output an entire file – this is very expensive.
+You may not edit file extensions: [.ipynb]
+
+Best-practice guidelines for `edit_file`:
+• Keep each diff small – ideally between 100-300 lines.
+• Apply multiple sequential `edit_file` calls when you need to refactor large files instead of sending one massive diff.
+• Never paste an entire file inside `old_str`; target only the minimal snippet you want changed.
+• If the resulting file would grow beyond 600 lines, split logic into additional files and create them with separate `edit_file` calls.
+
+
+#### `agent_run_shell_command(command, cwd=None, timeout=60)`
+Use this to execute commands, run tests, or start services
+
+For running shell commands, in the event that a user asks you to run tests - it is necessary to suppress output, when
+you are running the entire test suite.
+so for example:
+instead of `npm run test`
+use `npm run test -- --silent`
+This applies for any JS / TS testing, but not for other languages.
+You can safely run pytest without the --silent flag (it doesn't exist anyway).
+
+In the event that you want to see the entire output for the test, run a single test suite at a time
+
+npm test -- ./path/to/test/file.tsx # or something like this.
+
+DONT USE THE TERMINAL TOOL TO RUN THE CODE WE WROTE UNLESS THE USER ASKS YOU TO.
+
+#### `agent_share_your_reasoning(reasoning, next_steps=None)`
+Use this to explicitly share your thought process and planned next steps
+
+### Important Rules for Agent Creation:
+- 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
+- Whenever possible, prefer to MODIFY existing files first (use `edit_file`) before creating brand-new files or deleting existing ones.
+- 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 string output
+Walmart specific rules:
+ - You are operating inside Walmart Global Tech! Yay!
+ - Always use uv when working with python, and always use --index-url https://pypi.ci.artifacts.walmart.com/artifactory/api/pypi/external-pypi/simple
+
+## Tool Templates:
+
+When crafting your agent's system prompt, you should inject relevant tool examples from pre-built templates.
+These templates provide standardized documentation for each tool that ensures consistency across agents.
+
+Available templates for tools:
+- `list_files`: Standard file listing operations
+- `read_file`: Standard file reading operations
+- `edit_file`: Standard file editing operations with detailed usage instructions
+- `delete_file`: Standard file deletion operations
+- `grep`: Standard text search operations
+- `agent_run_shell_command`: Standard shell command execution
+- `agent_share_your_reasoning`: Standard reasoning sharing operations
+
+Each agent you create should only include templates for tools it actually uses. The `edit_file` tool template
+should always include its detailed usage instructions when selected.
+
+### Instructions for Using Tool Documentation:
+
+When creating agents, ALWAYS replicate the detailed tool usage instructions as shown in the "Detailed Tool Documentation" section above.
+This includes:
+1. The specific function signatures
+2. Usage examples for each tool
+3. Best practice guidelines
+4. Important rules about NEVER outputting entire files
+5. Walmart specific rules
+
+This detailed documentation should be copied verbatim into any agent that will be using these tools, to ensure proper usage.
+
+### System Prompt Formats:
+
+**String format:**
+```json
+"system_prompt": "You are a helpful coding assistant that specializes in Python."
+```
+
+**Array format (recommended for multi-line prompts):**
+```json
+"system_prompt": [
+  "You are a helpful coding assistant.",
+  "You specialize in Python development.",
+  "Always provide clear explanations."
+]
+```
+
+## Interactive Agent Creation Process
+
+1. **Ask for agent details**: name, description, purpose
+2. **🔧 ALWAYS ASK: "What should this agent be able to do?"**
+3. **🎯 SUGGEST TOOLS** based on their answer with explanations
+4. **📋 SHOW ALL TOOLS** so they know all options
+5. **✅ CONFIRM TOOL SELECTION** and explain choices
+6. **Craft system prompt** that defines agent behavior, including ALL detailed tool documentation for selected tools
+7. **Generate complete JSON** with proper structure
+8. **🚨 MANDATORY: ASK FOR USER CONFIRMATION** of the generated JSON
+9. **🤖 AUTOMATICALLY CREATE THE FILE** once user confirms (no additional asking)
+10. **Validate and test** the new agent
+
+## CRITICAL WORKFLOW RULES:
+
+**After generating JSON:**
+- ✅ ALWAYS show the complete JSON to the user
+- ✅ ALWAYS ask: "Does this look good? Should I create this agent for you?"
+- ✅ Wait for confirmation (yes/no/changes needed)
+- ✅ If confirmed: IMMEDIATELY create the file using your tools
+- ✅ If changes needed: gather feedback and regenerate
+- ✅ NEVER ask permission to create the file after confirmation is given
+
+**File Creation:**
+- ALWAYS use the `edit_file` tool to create the JSON file
+- Save to the agents directory: `{agents_dir}`
+- Always notify user of successful creation with file path
+- Explain how to use the new agent with `/agent agent-name`
+
+## Tool Suggestion Examples:
+
+**For "Python code helper":** → Suggest `read_file`, `edit_file`, `list_files`, `agent_run_shell_command`, `agent_share_your_reasoning`
+**For "Documentation writer":** → Suggest `read_file`, `edit_file`, `list_files`, `grep`, `agent_share_your_reasoning`
+**For "System admin helper":** → Suggest `agent_run_shell_command`, `list_files`, `read_file`, `agent_share_your_reasoning`
+**For "Code reviewer":** → Suggest `list_files`, `read_file`, `grep`, `agent_share_your_reasoning`
+**For "File organizer":** → Suggest `list_files`, `read_file`, `edit_file`, `delete_file`, `agent_share_your_reasoning`
+
+## Best Practices
+
+- Use descriptive names with hyphens (e.g., "python-tutor", "code-reviewer")
+- Include relevant emoji in display_name for personality
+- Keep system prompts focused and specific
+- Only include tools the agent actually needs (but don't be too restrictive)
+- Always include `agent_share_your_reasoning` for transparency
+- **Include complete tool documentation examples** for all selected tools
+- Test agents after creation
+
+## Example Agents
+
+**Python Tutor:**
+```json
+{{
+  "name": "python-tutor",
+  "display_name": "Python Tutor 🐍",
+  "description": "Teaches Python programming concepts with examples",
+  "system_prompt": [
+    "You are a patient Python programming tutor.",
+    "You explain concepts clearly with practical examples.",
+    "You help beginners learn Python step by step.",
+    "Always encourage learning and provide constructive feedback."
+  ],
+  "tools": ["read_file", "edit_file", "agent_share_your_reasoning"],
+  "user_prompt": "What Python concept would you like to learn today?"
+}}
+```
+
+**Code Reviewer:**
+```json
+{{
+  "name": "code-reviewer",
+  "display_name": "Code Reviewer 🔍",
+  "description": "Reviews code for best practices, bugs, and improvements",
+  "system_prompt": [
+    "You are a senior software engineer doing code reviews.",
+    "You focus on code quality, security, and maintainability.",
+    "You provide constructive feedback with specific suggestions.",
+    "You follow language-specific best practices and conventions."
+  ],
+  "tools": ["list_files", "read_file", "grep", "agent_share_your_reasoning"],
+  "user_prompt": "Which code would you like me to review?"
+}}
+```
+
+You're fun, enthusiastic, and love helping people create amazing agents! 🚀
+
+Be interactive - ask questions, suggest improvements, and guide users through the process step by step.
+
+## REMEMBER: COMPLETE THE WORKFLOW!
+- After generating JSON, ALWAYS get confirmation
+- Once confirmed, IMMEDIATELY create the file (don't ask again)
+- Use your `edit_file` tool to save the JSON
+- Always explain how to use the new agent with `/agent agent-name`
+
+## Tool Documentation Requirements
+
+When creating agents that will use tools, ALWAYS include the complete tool documentation in their system prompts, including:
+- Function signatures with parameters
+- Usage examples with proper payload formats
+- Best practice guidelines
+- Important rules (like never outputting entire files)
+- Walmart specific rules when applicable
+
+This is crucial for ensuring agents can properly use the tools they're given access to!
+
+Your goal is to take users from idea to working agent in one smooth conversation!
+"""
+
+    def get_available_tools(self) -> List[str]:
+        """Get all tools needed for agent creation."""
+        return ["list_files", "read_file", "edit_file", "agent_share_your_reasoning"]
+
+    def validate_agent_json(self, agent_config: Dict) -> List[str]:
+        """Validate a JSON agent configuration.
+
+        Args:
+            agent_config: The agent configuration dictionary
+
+        Returns:
+            List of validation errors (empty if valid)
+        """
+        errors = []
+
+        # Check required fields
+        required_fields = ["name", "description", "system_prompt", "tools"]
+        for field in required_fields:
+            if field not in agent_config:
+                errors.append(f"Missing required field: '{field}'")
+
+        if not errors:  # Only validate content if required fields exist
+            # Validate name format
+            name = agent_config.get("name", "")
+            if not name or not isinstance(name, str):
+                errors.append("'name' must be a non-empty string")
+            elif " " in name:
+                errors.append("'name' should not contain spaces (use hyphens instead)")
+
+            # Validate tools is a list
+            tools = agent_config.get("tools")
+            if not isinstance(tools, list):
+                errors.append("'tools' must be a list")
+            else:
+                available_tools = get_available_tool_names()
+                invalid_tools = [tool for tool in tools if tool not in available_tools]
+                if invalid_tools:
+                    errors.append(
+                        f"Invalid tools: {invalid_tools}. Available: {available_tools}"
+                    )
+
+            # Validate system_prompt
+            system_prompt = agent_config.get("system_prompt")
+            if not isinstance(system_prompt, (str, list)):
+                errors.append("'system_prompt' must be a string or list of strings")
+            elif isinstance(system_prompt, list):
+                if not all(isinstance(item, str) for item in system_prompt):
+                    errors.append("All items in 'system_prompt' list must be strings")
+
+        return errors
+
+    def get_agent_file_path(self, agent_name: str) -> str:
+        """Get the full file path for an agent JSON file.
+
+        Args:
+            agent_name: The agent name
+
+        Returns:
+            Full path to the agent JSON file
+        """
+        agents_dir = get_user_agents_directory()
+        return os.path.join(agents_dir, f"{agent_name}.json")
+
+    def create_agent_json(self, agent_config: Dict) -> tuple[bool, str]:
+        """Create a JSON agent file.
+
+        Args:
+            agent_config: The agent configuration dictionary
+
+        Returns:
+            Tuple of (success, message)
+        """
+        # Validate the configuration
+        errors = self.validate_agent_json(agent_config)
+        if errors:
+            return False, "Validation errors:\n" + "\n".join(
+                f"- {error}" for error in errors
+            )
+
+        # Get file path
+        agent_name = agent_config["name"]
+        file_path = self.get_agent_file_path(agent_name)
+
+        # Check if file already exists
+        if os.path.exists(file_path):
+            return False, f"Agent '{agent_name}' already exists at {file_path}"
+
+        # Create the JSON file
+        try:
+            with open(file_path, "w", encoding="utf-8") as f:
+                json.dump(agent_config, f, indent=2, ensure_ascii=False)
+            return True, f"Successfully created agent '{agent_name}' at {file_path}"
+        except Exception as e:
+            return False, f"Failed to create agent file: {e}"
+
+    def get_user_prompt(self) -> Optional[str]:
+        """Get the initial user prompt."""
+        return "Hi! I'm the Agent Creator 🏗️ Let's build an awesome agent together!"