code-puppy 0.0.123__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

@@ -9,8 +9,12 @@ PhaseType = Literal[
     "invoke_agent",
     "agent_exception",
     "version_check",
+    "edit_file",
+    "delete_file",
+    "run_shell_command",
     "load_model_config",
     "load_prompt",
+    "agent_reload",
 ]
 CallbackFunc = Callable[..., Any]
 
@@ -20,8 +24,12 @@ _callbacks: Dict[PhaseType, List[CallbackFunc]] = {
     "invoke_agent": [],
     "agent_exception": [],
     "version_check": [],
+    "edit_file": [],
+    "delete_file": [],
+    "run_shell_command": [],
     "load_model_config": [],
     "load_prompt": [],
+    "agent_reload": [],
 }
 
 logger = logging.getLogger(__name__)
@@ -148,5 +156,21 @@ def on_load_model_config(*args, **kwargs) -> List[Any]:
     return _trigger_callbacks_sync("load_model_config", *args, **kwargs)
 
 
+def on_edit_file(*args, **kwargs) -> Any:
+    return _trigger_callbacks_sync("edit_file", *args, **kwargs)
+
+
+def on_delete_file(*args, **kwargs) -> Any:
+    return _trigger_callbacks_sync("delete_file", *args, **kwargs)
+
+
+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
@@ -22,7 +22,7 @@ COMMANDS_HELP = """
 /compact              Summarize and compact current chat history
 /dump_context <name>  Save current message history to file
 /load_context <name>  Load message history from file
-/set                  Set puppy config key-values (e.g., /set yolo_mode true)
+/set                  Set puppy config key-values (e.g., /set yolo_mode true, /set compaction_strategy truncation)
 /tools                Show available tools and capabilities
 /<unknown>            Show unknown command warning
 """
@@ -47,9 +47,12 @@ def handle_command(command: str):
         return True
 
     if command.strip().startswith("/compact"):
+        from code_puppy.config import get_compaction_strategy
         from code_puppy.message_history_processor import (
             estimate_tokens_for_message,
             summarize_messages,
+            truncation,
+            get_protected_token_count,
         )
         from code_puppy.messaging import (
             emit_error,
@@ -66,13 +69,23 @@ def handle_command(command: str):
                 return True
 
             before_tokens = sum(estimate_tokens_for_message(m) for m in history)
+            compaction_strategy = get_compaction_strategy()
             emit_info(
-                f"🤔 Compacting {len(history)} messages... (~{before_tokens} tokens)"
+                f"🤔 Compacting {len(history)} messages using {compaction_strategy} strategy... (~{before_tokens} tokens)"
             )
 
-            compacted, _ = summarize_messages(history, with_protection=False)
+            if compaction_strategy == "truncation":
+                protected_tokens = get_protected_token_count()
+                compacted = truncation(history, protected_tokens)
+                summarized_messages = []  # No summarization in truncation mode
+            else:
+                # Default to summarization
+                compacted, summarized_messages = summarize_messages(
+                    history, with_protection=False
+                )
+
             if not compacted:
-                emit_error("Summarization failed. History unchanged.")
+                emit_error("Compaction failed. History unchanged.")
                 return True
 
             set_message_history(compacted)
@@ -83,8 +96,14 @@ def handle_command(command: str):
                 if before_tokens > 0
                 else 0
             )
+
+            strategy_info = (
+                f"using {compaction_strategy} strategy"
+                if compaction_strategy == "truncation"
+                else "via summarization"
+            )
             emit_success(
-                f"✨ Done! History: {len(history)} → {len(compacted)} messages\n"
+                f"✨ Done! History: {len(history)} → {len(compacted)} messages {strategy_info}\n"
                 f"🏦 Tokens: {before_tokens:,} → {after_tokens:,} ({reduction_pct:.1f}% reduction)"
             )
             return True
@@ -119,25 +138,34 @@ def handle_command(command: str):
             get_owner_name,
             get_protected_token_count,
             get_puppy_name,
-            get_summarization_threshold,
+            get_compaction_threshold,
             get_yolo_mode,
         )
+        from code_puppy.agents import get_current_agent_config
+
+        from code_puppy.config import get_compaction_strategy
 
         puppy_name = get_puppy_name()
         owner_name = get_owner_name()
         model = get_active_model()
         yolo_mode = get_yolo_mode()
         protected_tokens = get_protected_token_count()
-        summary_threshold = get_summarization_threshold()
+        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
-[bold]summary_threshold:[/bold]     [cyan]{summary_threshold:.1%}[/cyan] context usage triggers summarization
+[bold]compaction_threshold:[/bold]     [cyan]{compaction_threshold:.1%}[/cyan] context usage triggers compaction
+[bold]compaction_strategy:[/bold]   [cyan]{compaction_strategy}[/cyan] (summarization or truncation)
 
 """
         emit_info(status_msg)
@@ -162,8 +190,11 @@ def handle_command(command: str):
             key = tokens[1]
             value = ""
         else:
+            config_keys = get_config_keys()
+            if "compaction_strategy" not in config_keys:
+                config_keys.append("compaction_strategy")
             emit_warning(
-                f"Usage: /set KEY=VALUE or /set KEY VALUE\nConfig keys: {', '.join(get_config_keys())}"
+                f"Usage: /set KEY=VALUE or /set KEY VALUE\nConfig keys: {', '.join(config_keys)}\n[dim]Note: compaction_strategy can be 'summarization' or 'truncation'[/dim]"
             )
             return True
         if key:
@@ -181,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)