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

code_puppy/agents/agent_manager.py

@@ -0,0 +1,211 @@
+"""Agent manager for handling different agent configurations."""
+
+import importlib
+import pkgutil
+import uuid
+from typing import Dict, Optional, Type, Union
+
+from code_puppy.config import get_value, set_config_value
+from .base_agent import BaseAgent
+from .json_agent import JSONAgent, discover_json_agents
+from ..callbacks import on_agent_reload
+from ..messaging import emit_warning
+
+# Registry of available agents (Python classes and JSON file paths)
+_AGENT_REGISTRY: Dict[str, Union[Type[BaseAgent], str]] = {}
+_CURRENT_AGENT_CONFIG: Optional[BaseAgent] = None
+
+
+def _discover_agents(message_group_id: Optional[str] = None):
+    """Dynamically discover all agent classes and JSON agents."""
+    # Always clear the registry to force refresh
+    _AGENT_REGISTRY.clear()
+
+    # 1. Discover Python agent classes in the agents package
+    import code_puppy.agents as agents_package
+
+    # Iterate through all modules in the agents package
+    for _, modname, _ in pkgutil.iter_modules(agents_package.__path__):
+        if modname.startswith("_") or modname in [
+            "base_agent",
+            "json_agent",
+            "agent_manager",
+        ]:
+            continue
+
+        try:
+            # Import the module
+            module = importlib.import_module(f"code_puppy.agents.{modname}")
+
+            # Look for BaseAgent subclasses
+            for attr_name in dir(module):
+                attr = getattr(module, attr_name)
+                if (
+                    isinstance(attr, type)
+                    and issubclass(attr, BaseAgent)
+                    and attr not in [BaseAgent, JSONAgent]
+                ):
+                    # Create an instance to get the name
+                    agent_instance = attr()
+                    _AGENT_REGISTRY[agent_instance.name] = attr
+
+        except Exception as e:
+            # Skip problematic modules
+            emit_warning(
+                f"Warning: Could not load agent module {modname}: {e}",
+                message_group=message_group_id,
+            )
+            continue
+
+    # 2. Discover JSON agents in user directory
+    try:
+        json_agents = discover_json_agents()
+
+        # Add JSON agents to registry (store file path instead of class)
+        for agent_name, json_path in json_agents.items():
+            _AGENT_REGISTRY[agent_name] = json_path
+
+    except Exception as e:
+        emit_warning(
+            f"Warning: Could not discover JSON agents: {e}",
+            message_group=message_group_id,
+        )
+
+
+def get_available_agents() -> Dict[str, str]:
+    """Get a dictionary of available agents with their display names.
+
+    Returns:
+        Dict mapping agent names to display names.
+    """
+    # Generate a message group ID for this operation
+    message_group_id = str(uuid.uuid4())
+    _discover_agents(message_group_id=message_group_id)
+
+    agents = {}
+    for name, agent_ref in _AGENT_REGISTRY.items():
+        try:
+            if isinstance(agent_ref, str):  # JSON agent (file path)
+                agent_instance = JSONAgent(agent_ref)
+            else:  # Python agent (class)
+                agent_instance = agent_ref()
+            agents[name] = agent_instance.display_name
+        except Exception:
+            agents[name] = name.title()  # Fallback
+
+    return agents
+
+
+def get_current_agent_name() -> str:
+    """Get the name of the currently active agent.
+
+    Returns:
+        The name of the current agent, defaults to 'code-puppy'.
+    """
+    return get_value("current_agent") or "code-puppy"
+
+
+def set_current_agent(agent_name: str) -> bool:
+    """Set the current agent by name.
+
+    Args:
+        agent_name: The name of the agent to set as current.
+
+    Returns:
+        True if the agent was set successfully, False if agent not found.
+    """
+    # Generate a message group ID for agent switching
+    message_group_id = str(uuid.uuid4())
+    _discover_agents(message_group_id=message_group_id)
+    # Clear the cached config when switching agents
+    global _CURRENT_AGENT_CONFIG
+    _CURRENT_AGENT_CONFIG = None
+    agent_obj = load_agent_config(agent_name)
+    on_agent_reload(agent_obj.id, agent_name)
+    set_config_value("current_agent", agent_name)
+    return True
+
+
+def get_current_agent_config() -> BaseAgent:
+    """Get the current agent configuration.
+
+    Returns:
+        The current agent configuration instance.
+    """
+    global _CURRENT_AGENT_CONFIG
+
+    _CURRENT_AGENT_CONFIG = load_agent_config(get_current_agent_name())
+
+    return _CURRENT_AGENT_CONFIG
+
+
+def load_agent_config(agent_name: str) -> BaseAgent:
+    """Load an agent configuration by name.
+
+    Args:
+        agent_name: The name of the agent to load.
+
+    Returns:
+        The agent configuration instance.
+
+    Raises:
+        ValueError: If the agent is not found.
+    """
+    # Generate a message group ID for agent loading
+    message_group_id = str(uuid.uuid4())
+    _discover_agents(message_group_id=message_group_id)
+
+    if agent_name not in _AGENT_REGISTRY:
+        # Fallback to code-puppy if agent not found
+        if "code-puppy" in _AGENT_REGISTRY:
+            agent_name = "code-puppy"
+        else:
+            raise ValueError(
+                f"Agent '{agent_name}' not found and no fallback available"
+            )
+
+    agent_ref = _AGENT_REGISTRY[agent_name]
+    if isinstance(agent_ref, str):  # JSON agent (file path)
+        return JSONAgent(agent_ref)
+    else:  # Python agent (class)
+        return agent_ref()
+
+
+def get_agent_descriptions() -> Dict[str, str]:
+    """Get descriptions for all available agents.
+
+    Returns:
+        Dict mapping agent names to their descriptions.
+    """
+    # Generate a message group ID for this operation
+    message_group_id = str(uuid.uuid4())
+    _discover_agents(message_group_id=message_group_id)
+
+    descriptions = {}
+    for name, agent_ref in _AGENT_REGISTRY.items():
+        try:
+            if isinstance(agent_ref, str):  # JSON agent (file path)
+                agent_instance = JSONAgent(agent_ref)
+            else:  # Python agent (class)
+                agent_instance = agent_ref()
+            descriptions[name] = agent_instance.description
+        except Exception:
+            descriptions[name] = "No description available"
+
+    return descriptions
+
+
+def clear_agent_cache():
+    """Clear the cached agent configuration to force reload."""
+    global _CURRENT_AGENT_CONFIG
+    _CURRENT_AGENT_CONFIG = None
+
+
+def refresh_agents():
+    """Refresh the agent discovery to pick up newly created agents.
+
+    This clears the agent registry cache and forces a rediscovery of all agents.
+    """
+    # Generate a message group ID for agent refreshing
+    message_group_id = str(uuid.uuid4())
+    _discover_agents(message_group_id=message_group_id)

code_puppy/agents/base_agent.py

@@ -0,0 +1,60 @@
+"""Base agent configuration class for defining agent properties."""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+import uuid
+
+
+class BaseAgent(ABC):
+    """Base class for all agent configurations."""
+
+    def __init__(self):
+        self.id = str(uuid.uuid4())
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Unique identifier for the agent."""
+        pass
+
+    @property
+    @abstractmethod
+    def display_name(self) -> str:
+        """Human-readable name for the agent."""
+        pass
+
+    @property
+    @abstractmethod
+    def description(self) -> str:
+        """Brief description of what this agent does."""
+        pass
+
+    @abstractmethod
+    def get_system_prompt(self) -> str:
+        """Get the system prompt for this agent."""
+        pass
+
+    @abstractmethod
+    def get_available_tools(self) -> List[str]:
+        """Get list of tool names that this agent should have access to.
+
+        Returns:
+            List of tool names to register for this agent.
+        """
+        pass
+
+    def get_tools_config(self) -> Optional[Dict[str, Any]]:
+        """Get tool configuration for this agent.
+
+        Returns:
+            Dict with tool configuration, or None to use default tools.
+        """
+        return None
+
+    def get_user_prompt(self) -> Optional[str]:
+        """Get custom user prompt for this agent.
+
+        Returns:
+            Custom prompt string, or None to use default.
+        """
+        return None

code_puppy/agents/json_agent.py

@@ -0,0 +1,129 @@
+"""JSON-based agent configuration system."""
+
+import json
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from .base_agent import BaseAgent
+
+
+class JSONAgent(BaseAgent):
+    """Agent configured from a JSON file."""
+
+    def __init__(self, json_path: str):
+        """Initialize agent from JSON file.
+
+        Args:
+            json_path: Path to the JSON configuration file.
+        """
+        super().__init__()
+        self.json_path = json_path
+        self._config = self._load_config()
+        self._validate_config()
+
+    def _load_config(self) -> Dict:
+        """Load configuration from JSON file."""
+        try:
+            with open(self.json_path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, FileNotFoundError) as e:
+            raise ValueError(
+                f"Failed to load JSON agent config from {self.json_path}: {e}"
+            )
+
+    def _validate_config(self) -> None:
+        """Validate required fields in configuration."""
+        required_fields = ["name", "description", "system_prompt", "tools"]
+        for field in required_fields:
+            if field not in self._config:
+                raise ValueError(
+                    f"Missing required field '{field}' in JSON agent config: {self.json_path}"
+                )
+
+        # Validate tools is a list
+        if not isinstance(self._config["tools"], list):
+            raise ValueError(
+                f"'tools' must be a list in JSON agent config: {self.json_path}"
+            )
+
+        # Validate system_prompt is string or list
+        system_prompt = self._config["system_prompt"]
+        if not isinstance(system_prompt, (str, list)):
+            raise ValueError(
+                f"'system_prompt' must be a string or list in JSON agent config: {self.json_path}"
+            )
+
+    @property
+    def name(self) -> str:
+        """Get agent name from JSON config."""
+        return self._config["name"]
+
+    @property
+    def display_name(self) -> str:
+        """Get display name from JSON config, fallback to name with emoji."""
+        return self._config.get("display_name", f"{self.name.title()} 🤖")
+
+    @property
+    def description(self) -> str:
+        """Get description from JSON config."""
+        return self._config["description"]
+
+    def get_system_prompt(self) -> str:
+        """Get system prompt from JSON config."""
+        system_prompt = self._config["system_prompt"]
+
+        # If it's a list, join with newlines
+        if isinstance(system_prompt, list):
+            return "\n".join(system_prompt)
+
+        return system_prompt
+
+    def get_available_tools(self) -> List[str]:
+        """Get available tools from JSON config."""
+        # Filter out any tools that don't exist in our registry
+        from code_puppy.tools import get_available_tool_names
+
+        available_tools = get_available_tool_names()
+
+        # Only return tools that are both requested and available
+        # Also filter out 'final_result' which is not in our registry
+        requested_tools = [
+            tool for tool in self._config["tools"] if tool in available_tools
+        ]
+
+        return requested_tools
+
+    def get_user_prompt(self) -> Optional[str]:
+        """Get custom user prompt from JSON config."""
+        return self._config.get("user_prompt")
+
+    def get_tools_config(self) -> Optional[Dict]:
+        """Get tool configuration from JSON config."""
+        return self._config.get("tools_config")
+
+
+def discover_json_agents() -> Dict[str, str]:
+    """Discover JSON agent files in the user's agents directory.
+
+    Returns:
+        Dict mapping agent names to their JSON file paths.
+    """
+    from code_puppy.config import get_user_agents_directory
+
+    agents = {}
+    agents_dir = Path(get_user_agents_directory())
+
+    if not agents_dir.exists() or not agents_dir.is_dir():
+        return agents
+
+    # Find all .json files in the agents directory
+    for json_file in agents_dir.glob("*.json"):
+        try:
+            # Try to load and validate the agent
+            agent = JSONAgent(str(json_file))
+            agents[agent.name] = str(json_file)
+        except Exception:
+            # Skip invalid JSON agent files
+            continue
+
+    return agents

code_puppy/callbacks.py

@@ -14,6 +14,7 @@ PhaseType = Literal[
     "run_shell_command",
     "load_model_config",
     "load_prompt",
+    "agent_reload",
 ]
 CallbackFunc = Callable[..., Any]
 
@@ -28,6 +29,7 @@ _callbacks: Dict[PhaseType, List[CallbackFunc]] = {
     "run_shell_command": [],
     "load_model_config": [],
     "load_prompt": [],
+    "agent_reload": [],
 }
 
 logger = logging.getLogger(__name__)
@@ -166,5 +168,9 @@ def on_run_shell_command(*args, **kwargs) -> Any:
     return _trigger_callbacks_sync("run_shell_command", *args, **kwargs)
 
 
+def on_agent_reload(*args, **kwargs) -> Any:
+    return _trigger_callbacks_sync("agent_reload", *args, **kwargs)
+
+
 def on_load_prompt():
     return _trigger_callbacks_sync("load_prompt")

code_puppy/command_line/command_handler.py

@@ -13,7 +13,7 @@ COMMANDS_HELP = """
 [bold magenta]Commands Help[/bold magenta]
 /help, /h             Show this help message
 /cd <dir>             Change directory or show directories
-
+/agent <name>         Switch to a different agent or show available agents
 /exit, /quit          Exit interactive mode
 /generate-pr-description [@dir]  Generate comprehensive PR description
 /m <model>            Set active model
@@ -141,6 +141,7 @@ def handle_command(command: str):
             get_compaction_threshold,
             get_yolo_mode,
         )
+        from code_puppy.agents import get_current_agent_config
 
         from code_puppy.config import get_compaction_strategy
 
@@ -152,10 +153,14 @@ def handle_command(command: str):
         compaction_threshold = get_compaction_threshold()
         compaction_strategy = get_compaction_strategy()
 
+        # Get current agent info
+        current_agent = get_current_agent_config()
+
         status_msg = f"""[bold magenta]🐶 Puppy Status[/bold magenta]
 
 [bold]puppy_name:[/bold]            [cyan]{puppy_name}[/cyan]
 [bold]owner_name:[/bold]            [cyan]{owner_name}[/cyan]
+[bold]current_agent:[/bold]         [magenta]{current_agent.display_name}[/magenta]
 [bold]model:[/bold]                 [green]{model}[/green]
 [bold]YOLO_MODE:[/bold]             {"[red]ON[/red]" if yolo_mode else "[yellow]off[/yellow]"}
 [bold]protected_tokens:[/bold]      [cyan]{protected_tokens:,}[/cyan] recent tokens preserved
@@ -207,6 +212,91 @@ def handle_command(command: str):
         emit_info(markdown_content)
         return True
 
+    if command.startswith("/agent"):
+        # Handle agent switching
+        from code_puppy.agents import (
+            get_available_agents,
+            get_current_agent_config,
+            set_current_agent,
+            get_agent_descriptions,
+        )
+        from code_puppy.agent import get_code_generation_agent
+
+        tokens = command.split()
+
+        if len(tokens) == 1:
+            # Show current agent and available agents
+            current_agent = get_current_agent_config()
+            available_agents = get_available_agents()
+            descriptions = get_agent_descriptions()
+
+            # Generate a group ID for all messages in this command
+            import uuid
+
+            group_id = str(uuid.uuid4())
+
+            emit_info(
+                f"[bold green]Current Agent:[/bold green] {current_agent.display_name}",
+                message_group=group_id,
+            )
+            emit_info(
+                f"[dim]{current_agent.description}[/dim]\n", message_group=group_id
+            )
+
+            emit_info(
+                "[bold magenta]Available Agents:[/bold magenta]", message_group=group_id
+            )
+            for name, display_name in available_agents.items():
+                description = descriptions.get(name, "No description")
+                current_marker = (
+                    " [green]← current[/green]" if name == current_agent.name else ""
+                )
+                emit_info(
+                    f"  [cyan]{name:<12}[/cyan] {display_name}{current_marker}",
+                    message_group=group_id,
+                )
+                emit_info(f"    [dim]{description}[/dim]", message_group=group_id)
+
+            emit_info(
+                "\n[yellow]Usage:[/yellow] /agent <agent-name>", message_group=group_id
+            )
+            return True
+
+        elif len(tokens) == 2:
+            agent_name = tokens[1].lower()
+
+            # Generate a group ID for all messages in this command
+            import uuid
+
+            group_id = str(uuid.uuid4())
+
+            if set_current_agent(agent_name):
+                # Reload the agent with new configuration
+                get_code_generation_agent(force_reload=True)
+                new_agent = get_current_agent_config()
+                emit_success(
+                    f"Switched to agent: {new_agent.display_name}",
+                    message_group=group_id,
+                )
+                emit_info(f"[dim]{new_agent.description}[/dim]", message_group=group_id)
+                return True
+            else:
+                # Generate a group ID for all messages in this command
+                import uuid
+
+                group_id = str(uuid.uuid4())
+
+                available_agents = get_available_agents()
+                emit_error(f"Agent '{agent_name}' not found", message_group=group_id)
+                emit_warning(
+                    f"Available agents: {', '.join(available_agents.keys())}",
+                    message_group=group_id,
+                )
+                return True
+        else:
+            emit_warning("Usage: /agent [agent-name]")
+            return True
+
     if command.startswith("/m"):
         # Try setting model and show confirmation
         new_input = update_model_in_input(command)

code_puppy/config.py

@@ -9,6 +9,7 @@ MCP_SERVERS_FILE = os.path.join(CONFIG_DIR, "mcp_servers.json")
 COMMAND_HISTORY_FILE = os.path.join(CONFIG_DIR, "command_history.txt")
 MODELS_FILE = os.path.join(CONFIG_DIR, "models.json")
 EXTRA_MODELS_FILE = os.path.join(CONFIG_DIR, "extra_models.json")
+AGENTS_DIR = os.path.join(CONFIG_DIR, "agents")
 
 DEFAULT_SECTION = "puppy"
 REQUIRED_KEYS = ["puppy_name", "owner_name"]
@@ -303,6 +304,17 @@ def normalize_command_history():
         direct_console.print(f"[bold red]{error_msg}[/bold red]")
 
 
+def get_user_agents_directory() -> str:
+    """Get the user's agents directory path.
+
+    Returns:
+        Path to the user's Code Puppy agents directory.
+    """
+    # Ensure the agents directory exists
+    os.makedirs(AGENTS_DIR, exist_ok=True)
+    return AGENTS_DIR
+
+
 def initialize_command_history_file():
     """Create the command history file if it doesn't exist.
     Handles migration from the old history file location for backward compatibility.

code_puppy/main.py

@@ -373,8 +373,13 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
 
     while True:
         from code_puppy.messaging import emit_info
+        from code_puppy.agents.agent_manager import get_current_agent_config
 
-        emit_info("[bold blue]Enter your coding task:[/bold blue]")
+        # Get the custom prompt from the current agent, or use default
+        current_agent = get_current_agent_config()
+        user_prompt = current_agent.get_user_prompt() or "Enter your coding task:"
+
+        emit_info(f"[bold blue]{user_prompt}[/bold blue]")
 
         try:
             # Use prompt_toolkit for enhanced input with path completion

code_puppy/tools/__init__.py

@@ -1,10 +1,63 @@
-from code_puppy.tools.command_runner import register_command_runner_tools
-from code_puppy.tools.file_modifications import register_file_modifications_tools
-from code_puppy.tools.file_operations import register_file_operations_tools
+from code_puppy.messaging import emit_warning
+from code_puppy.tools.command_runner import (
+    register_agent_run_shell_command,
+    register_agent_share_your_reasoning,
+)
+from code_puppy.tools.file_modifications import register_edit_file, register_delete_file
+from code_puppy.tools.file_operations import (
+    register_list_files,
+    register_read_file,
+    register_grep,
+)
+
+
+# Map of tool names to their individual registration functions
+TOOL_REGISTRY = {
+    # File Operations
+    "list_files": register_list_files,
+    "read_file": register_read_file,
+    "grep": register_grep,
+    # File Modifications
+    "edit_file": register_edit_file,
+    "delete_file": register_delete_file,
+    # Command Runner
+    "agent_run_shell_command": register_agent_run_shell_command,
+    "agent_share_your_reasoning": register_agent_share_your_reasoning,
+}
+
+
+def register_tools_for_agent(agent, tool_names: list[str]):
+    """Register specific tools for an agent based on tool names.
+
+    Args:
+        agent: The agent to register tools to.
+        tool_names: List of tool names to register.
+    """
+    for tool_name in tool_names:
+        if tool_name not in TOOL_REGISTRY:
+            # Skip unknown tools with a warning instead of failing
+            emit_warning(f"Warning: Unknown tool '{tool_name}' requested, skipping...")
+            continue
+
+        # Register the individual tool
+        register_func = TOOL_REGISTRY[tool_name]
+        register_func(agent)
 
 
 def register_all_tools(agent):
-    """Register all available tools to the provided agent."""
-    register_file_operations_tools(agent)
-    register_file_modifications_tools(agent)
-    register_command_runner_tools(agent)
+    """Register all available tools to the provided agent.
+
+    Args:
+        agent: The agent to register tools to.
+    """
+    all_tools = list(TOOL_REGISTRY.keys())
+    register_tools_for_agent(agent, all_tools)
+
+
+def get_available_tool_names() -> list[str]:
+    """Get list of all available tool names.
+
+    Returns:
+        List of all tool names that can be registered.
+    """
+    return list(TOOL_REGISTRY.keys())