code-puppy 0.0.169__py3-none-any.whl → 0.0.366__py3-none-any.whl

code_puppy/agents/agent_manager.py

@@ -6,16 +6,19 @@ import os
 import pkgutil
 import uuid
 from pathlib import Path
-from typing import Dict, Optional, Type, Union
+from typing import Dict, List, Optional, Type, Union
 
-from ..callbacks import on_agent_reload
-from ..messaging import emit_warning
-from .base_agent import BaseAgent
-from .json_agent import JSONAgent, discover_json_agents
+from pydantic_ai.messages import ModelMessage
+
+from code_puppy.agents.base_agent import BaseAgent
+from code_puppy.agents.json_agent import JSONAgent, discover_json_agents
+from code_puppy.callbacks import on_agent_reload
+from code_puppy.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
+_AGENT_HISTORIES: Dict[str, List[ModelMessage]] = {}
+_CURRENT_AGENT: Optional[BaseAgent] = None
 
 # Terminal session-based agent selection
 _SESSION_AGENTS_CACHE: dict[str, str] = {}
@@ -25,9 +28,9 @@ _SESSION_FILE_LOADED: bool = False
 # Session persistence file path
 def _get_session_file_path() -> Path:
     """Get the path to the terminal sessions file."""
-    from ..config import CONFIG_DIR
+    from ..config import STATE_DIR
 
-    return Path(CONFIG_DIR) / "terminal_sessions.json"
+    return Path(STATE_DIR) / "terminal_sessions.json"
 
 
 def get_terminal_session_id() -> str:
@@ -48,21 +51,56 @@ def get_terminal_session_id() -> str:
 
 
 def _is_process_alive(pid: int) -> bool:
-    """Check if a process with the given PID is still alive.
+    """Check if a process with the given PID is still alive, cross-platform.
 
     Args:
         pid: Process ID to check
 
     Returns:
-        bool: True if process exists, False otherwise
+        bool: True if process likely exists, False otherwise
     """
     try:
-        # On Unix: os.kill(pid, 0) raises OSError if process doesn't exist
-        # On Windows: This also works with signal 0
-        os.kill(pid, 0)
+        if os.name == "nt":
+            # Windows: use OpenProcess to probe liveness safely
+            import ctypes
+            from ctypes import wintypes
+
+            PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
+            kernel32 = ctypes.windll.kernel32  # type: ignore[attr-defined]
+            kernel32.OpenProcess.argtypes = [
+                wintypes.DWORD,
+                wintypes.BOOL,
+                wintypes.DWORD,
+            ]
+            kernel32.OpenProcess.restype = wintypes.HANDLE
+            handle = kernel32.OpenProcess(
+                PROCESS_QUERY_LIMITED_INFORMATION, False, int(pid)
+            )
+            if handle:
+                kernel32.CloseHandle(handle)
+                return True
+            # If access denied, process likely exists but we can't query it
+            last_error = kernel32.GetLastError()
+            # ERROR_ACCESS_DENIED = 5
+            if last_error == 5:
+                return True
+            return False
+        else:
+            # Unix-like: signal 0 does not deliver a signal but checks existence
+            os.kill(int(pid), 0)
+            return True
+    except PermissionError:
+        # No permission to signal -> process exists
         return True
     except (OSError, ProcessLookupError):
+        # Process does not exist
         return False
+    except ValueError:
+        # Invalid signal or pid format
+        return False
+    except Exception:
+        # Be conservative – don't crash session cleanup due to platform quirks
+        return True
 
 
 def _cleanup_dead_sessions(sessions: dict[str, str]) -> dict[str, str]:
@@ -146,41 +184,6 @@ def _ensure_session_cache_loaded() -> None:
         _SESSION_FILE_LOADED = True
 
 
-# Persistent storage for agent message histories
-_AGENT_HISTORIES: Dict[str, Dict[str, any]] = {}
-# Structure: {agent_name: {"message_history": [...], "compacted_hashes": set(...)}}
-
-
-def _save_agent_history(agent_name: str, agent: BaseAgent) -> None:
-    """Save an agent's message history to persistent storage.
-
-    Args:
-        agent_name: The name of the agent
-        agent: The agent instance to save history from
-    """
-    global _AGENT_HISTORIES
-    _AGENT_HISTORIES[agent_name] = {
-        "message_history": agent.get_message_history().copy(),
-        "compacted_hashes": agent.get_compacted_message_hashes().copy(),
-    }
-
-
-def _restore_agent_history(agent_name: str, agent: BaseAgent) -> None:
-    """Restore an agent's message history from persistent storage.
-
-    Args:
-        agent_name: The name of the agent
-        agent: The agent instance to restore history to
-    """
-    global _AGENT_HISTORIES
-    if agent_name in _AGENT_HISTORIES:
-        stored_data = _AGENT_HISTORIES[agent_name]
-        agent.set_message_history(stored_data["message_history"])
-        # Restore compacted hashes
-        for hash_val in stored_data["compacted_hashes"]:
-            agent.add_compacted_message_hash(hash_val)
-
-
 def _discover_agents(message_group_id: Optional[str] = None):
     """Dynamically discover all agent classes and JSON agents."""
     # Always clear the registry to force refresh
@@ -222,6 +225,55 @@ def _discover_agents(message_group_id: Optional[str] = None):
             )
             continue
 
+    # 1b. Discover agents in sub-packages (like 'pack')
+    for _, subpkg_name, ispkg in pkgutil.iter_modules(agents_package.__path__):
+        if not ispkg or subpkg_name.startswith("_"):
+            continue
+
+        try:
+            # Import the sub-package
+            subpkg = importlib.import_module(f"code_puppy.agents.{subpkg_name}")
+
+            # Iterate through modules in the sub-package
+            if not hasattr(subpkg, "__path__"):
+                continue
+
+            for _, modname, _ in pkgutil.iter_modules(subpkg.__path__):
+                if modname.startswith("_"):
+                    continue
+
+                try:
+                    # Import the submodule
+                    module = importlib.import_module(
+                        f"code_puppy.agents.{subpkg_name}.{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:
+                    emit_warning(
+                        f"Warning: Could not load agent {subpkg_name}.{modname}: {e}",
+                        message_group=message_group_id,
+                    )
+                    continue
+
+        except Exception as e:
+            emit_warning(
+                f"Warning: Could not load agent sub-package {subpkg_name}: {e}",
+                message_group=message_group_id,
+            )
+            continue
+
     # 2. Discover JSON agents in user directory
     try:
         json_agents = discover_json_agents()
@@ -243,12 +295,21 @@ def get_available_agents() -> Dict[str, str]:
     Returns:
         Dict mapping agent names to display names.
     """
+    from ..config import PACK_AGENT_NAMES, get_pack_agents_enabled
+
     # Generate a message group ID for this operation
     message_group_id = str(uuid.uuid4())
     _discover_agents(message_group_id=message_group_id)
 
+    # Check if pack agents are enabled
+    pack_agents_enabled = get_pack_agents_enabled()
+
     agents = {}
     for name, agent_ref in _AGENT_REGISTRY.items():
+        # Filter out pack agents if disabled
+        if not pack_agents_enabled and name in PACK_AGENT_NAMES:
+            continue
+
         try:
             if isinstance(agent_ref, str):  # JSON agent (file path)
                 agent_instance = JSONAgent(agent_ref)
@@ -265,11 +326,21 @@ def get_current_agent_name() -> str:
     """Get the name of the currently active agent for this terminal session.
 
     Returns:
-        The name of the current agent for this session, defaults to 'code-puppy'.
+        The name of the current agent for this session.
+        Priority: session agent > config default > 'code-puppy'.
     """
     _ensure_session_cache_loaded()
     session_id = get_terminal_session_id()
-    return _SESSION_AGENTS_CACHE.get(session_id, "code-puppy")
+
+    # First check for session-specific agent
+    session_agent = _SESSION_AGENTS_CACHE.get(session_id)
+    if session_agent:
+        return session_agent
+
+    # Fall back to config default
+    from ..config import get_default_agent
+
+    return get_default_agent()
 
 
 def set_current_agent(agent_name: str) -> bool:
@@ -281,50 +352,49 @@ def set_current_agent(agent_name: str) -> bool:
     Returns:
         True if the agent was set successfully, False if agent not found.
     """
+    global _CURRENT_AGENT
+    curr_agent = get_current_agent()
+    if curr_agent is not None:
+        # Store a shallow copy so future mutations don't affect saved history
+        _AGENT_HISTORIES[curr_agent.name] = list(curr_agent.get_message_history())
     # Generate a message group ID for agent switching
     message_group_id = str(uuid.uuid4())
     _discover_agents(message_group_id=message_group_id)
 
     # Save current agent's history before switching
-    global _CURRENT_AGENT_CONFIG, _CURRENT_AGENT_NAME
-    if _CURRENT_AGENT_CONFIG is not None:
-        _save_agent_history(_CURRENT_AGENT_CONFIG.name, _CURRENT_AGENT_CONFIG)
 
     # Clear the cached config when switching agents
-    _CURRENT_AGENT_CONFIG = None
-    agent_obj = load_agent_config(agent_name)
-
-    # Restore the agent's history if it exists
-    _restore_agent_history(agent_name, agent_obj)
+    agent_obj = load_agent(agent_name)
+    _CURRENT_AGENT = agent_obj
 
     # Update session-based agent selection and persist to disk
     _ensure_session_cache_loaded()
     session_id = get_terminal_session_id()
     _SESSION_AGENTS_CACHE[session_id] = agent_name
     _save_session_data(_SESSION_AGENTS_CACHE)
-
+    if agent_obj.name in _AGENT_HISTORIES:
+        # Restore a copy to avoid sharing the same list instance
+        agent_obj.set_message_history(list(_AGENT_HISTORIES[agent_obj.name]))
     on_agent_reload(agent_obj.id, agent_name)
     return True
 
 
-def get_current_agent_config() -> BaseAgent:
+def get_current_agent() -> BaseAgent:
     """Get the current agent configuration.
 
     Returns:
         The current agent configuration instance.
     """
-    global _CURRENT_AGENT_CONFIG
+    global _CURRENT_AGENT
 
-    if _CURRENT_AGENT_CONFIG is None:
+    if _CURRENT_AGENT is None:
         agent_name = get_current_agent_name()
-        _CURRENT_AGENT_CONFIG = load_agent_config(agent_name)
-        # Restore the agent's history if it exists
-        _restore_agent_history(agent_name, _CURRENT_AGENT_CONFIG)
+        _CURRENT_AGENT = load_agent(agent_name)
 
-    return _CURRENT_AGENT_CONFIG
+    return _CURRENT_AGENT
 
 
-def load_agent_config(agent_name: str) -> BaseAgent:
+def load_agent(agent_name: str) -> BaseAgent:
     """Load an agent configuration by name.
 
     Args:
@@ -362,12 +432,21 @@ def get_agent_descriptions() -> Dict[str, str]:
     Returns:
         Dict mapping agent names to their descriptions.
     """
+    from ..config import PACK_AGENT_NAMES, get_pack_agents_enabled
+
     # Generate a message group ID for this operation
     message_group_id = str(uuid.uuid4())
     _discover_agents(message_group_id=message_group_id)
 
+    # Check if pack agents are enabled
+    pack_agents_enabled = get_pack_agents_enabled()
+
     descriptions = {}
     for name, agent_ref in _AGENT_REGISTRY.items():
+        # Filter out pack agents if disabled
+        if not pack_agents_enabled and name in PACK_AGENT_NAMES:
+            continue
+
         try:
             if isinstance(agent_ref, str):  # JSON agent (file path)
                 agent_instance = JSONAgent(agent_ref)
@@ -380,26 +459,6 @@ def get_agent_descriptions() -> Dict[str, str]:
     return descriptions
 
 
-def clear_agent_cache():
-    """Clear the cached agent configuration to force reload."""
-    global _CURRENT_AGENT_CONFIG
-    _CURRENT_AGENT_CONFIG = None
-
-
-def reset_to_default_agent():
-    """Reset the current agent to the default (code-puppy) for this terminal session.
-
-    This is useful for testing or when you want to start fresh.
-    """
-    global _CURRENT_AGENT_CONFIG
-    _ensure_session_cache_loaded()
-    session_id = get_terminal_session_id()
-    if session_id in _SESSION_AGENTS_CACHE:
-        del _SESSION_AGENTS_CACHE[session_id]
-        _save_session_data(_SESSION_AGENTS_CACHE)
-    _CURRENT_AGENT_CONFIG = None
-
-
 def refresh_agents():
     """Refresh the agent discovery to pick up newly created agents.
 
@@ -408,115 +467,3 @@ def refresh_agents():
     # Generate a message group ID for agent refreshing
     message_group_id = str(uuid.uuid4())
     _discover_agents(message_group_id=message_group_id)
-
-
-def clear_all_agent_histories():
-    """Clear all agent message histories from persistent storage.
-
-    This is useful for debugging or when you want a fresh start.
-    """
-    global _AGENT_HISTORIES
-    _AGENT_HISTORIES.clear()
-    # Also clear the current agent's history
-    if _CURRENT_AGENT_CONFIG is not None:
-        _CURRENT_AGENT_CONFIG.messages = []
-
-
-def cleanup_dead_terminal_sessions() -> int:
-    """Clean up terminal sessions for processes that no longer exist.
-
-    Returns:
-        int: Number of dead sessions removed
-    """
-    _ensure_session_cache_loaded()
-    original_count = len(_SESSION_AGENTS_CACHE)
-    cleaned_cache = _cleanup_dead_sessions(_SESSION_AGENTS_CACHE)
-
-    if len(cleaned_cache) != original_count:
-        _SESSION_AGENTS_CACHE.clear()
-        _SESSION_AGENTS_CACHE.update(cleaned_cache)
-        _save_session_data(_SESSION_AGENTS_CACHE)
-
-    return original_count - len(cleaned_cache)
-
-
-# Agent-aware message history functions
-def get_current_agent_message_history():
-    """Get the message history for the currently active agent.
-
-    Returns:
-        List of messages from the current agent's conversation history.
-    """
-    current_agent = get_current_agent_config()
-    return current_agent.get_message_history()
-
-
-def set_current_agent_message_history(history):
-    """Set the message history for the currently active agent.
-
-    Args:
-        history: List of messages to set as the current agent's conversation history.
-    """
-    current_agent = get_current_agent_config()
-    current_agent.set_message_history(history)
-    # Also update persistent storage
-    _save_agent_history(current_agent.name, current_agent)
-
-
-def clear_current_agent_message_history():
-    """Clear the message history for the currently active agent."""
-    current_agent = get_current_agent_config()
-    current_agent.clear_message_history()
-    # Also clear from persistent storage
-    global _AGENT_HISTORIES
-    if current_agent.name in _AGENT_HISTORIES:
-        _AGENT_HISTORIES[current_agent.name] = {
-            "message_history": [],
-            "compacted_hashes": set(),
-        }
-
-
-def append_to_current_agent_message_history(message):
-    """Append a message to the currently active agent's history.
-
-    Args:
-        message: Message to append to the current agent's conversation history.
-    """
-    current_agent = get_current_agent_config()
-    current_agent.append_to_message_history(message)
-    # Also update persistent storage
-    _save_agent_history(current_agent.name, current_agent)
-
-
-def extend_current_agent_message_history(history):
-    """Extend the currently active agent's message history with multiple messages.
-
-    Args:
-        history: List of messages to append to the current agent's conversation history.
-    """
-    current_agent = get_current_agent_config()
-    current_agent.extend_message_history(history)
-    # Also update persistent storage
-    _save_agent_history(current_agent.name, current_agent)
-
-
-def get_current_agent_compacted_message_hashes():
-    """Get the set of compacted message hashes for the currently active agent.
-
-    Returns:
-        Set of hashes for messages that have been compacted/summarized.
-    """
-    current_agent = get_current_agent_config()
-    return current_agent.get_compacted_message_hashes()
-
-
-def add_current_agent_compacted_message_hash(message_hash: str):
-    """Add a message hash to the current agent's set of compacted message hashes.
-
-    Args:
-        message_hash: Hash of a message that has been compacted/summarized.
-    """
-    current_agent = get_current_agent_config()
-    current_agent.add_compacted_message_hash(message_hash)
-    # Also update persistent storage
-    _save_agent_history(current_agent.name, current_agent)