code-puppy 0.0.361__tar.gz → 0.0.376__tar.gz

{code_puppy-0.0.361 → code_puppy-0.0.376}/.gitignore

@@ -25,3 +25,8 @@ dummy_path
 .env
 .serena/
 .beads/
+main.dist/
+nuitka-crash-report.xml
+*.backup
+main.bin
+

{code_puppy-0.0.361 → code_puppy-0.0.376}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.361
+Version: 0.0.376
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy
@@ -15,27 +15,26 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Code Generators
 Requires-Python: <3.14,>=3.11
-Requires-Dist: camoufox>=0.4.11
 Requires-Dist: dbos>=2.5.0
 Requires-Dist: fastapi>=0.109.0
 Requires-Dist: httpx[http2]>=0.24.1
 Requires-Dist: json-repair>=0.46.2
-Requires-Dist: logfire>=0.7.1
+Requires-Dist: mcp>=1.9.4
 Requires-Dist: openai>=1.99.1
 Requires-Dist: pillow>=10.0.0
 Requires-Dist: playwright>=1.40.0
 Requires-Dist: prompt-toolkit>=3.0.52
-Requires-Dist: pydantic-ai==1.25.0
+Requires-Dist: pydantic-ai-slim[anthropic,mcp,openai]==1.26.0
 Requires-Dist: pydantic>=2.4.0
 Requires-Dist: pyfiglet>=0.8.post1
-Requires-Dist: pytest-cov>=6.1.1
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: rapidfuzz>=3.13.0
+Requires-Dist: requests>=2.28.0
 Requires-Dist: rich>=13.4.2
 Requires-Dist: ripgrep==14.1.0
-Requires-Dist: ruff>=0.11.11
 Requires-Dist: tenacity>=8.2.0
 Requires-Dist: termflow-md>=0.1.8
+Requires-Dist: typer>=0.12.0
 Requires-Dist: uvicorn[standard]>=0.27.0
 Requires-Dist: websockets>=12.0
 Description-Content-Type: text/markdown

{code_puppy-0.0.361 → code_puppy-0.0.376}/code_puppy/agents/__init__.py

@@ -5,9 +5,12 @@ configurations, each with their own system prompts and tool sets.
 """
 
 from .agent_manager import (
+    clone_agent,
+    delete_clone_agent,
     get_agent_descriptions,
     get_available_agents,
     get_current_agent,
+    is_clone_agent_name,
     load_agent,
     refresh_agents,
     set_current_agent,
@@ -15,8 +18,11 @@ from .agent_manager import (
 from .subagent_stream_handler import subagent_stream_handler
 
 __all__ = [
+    "clone_agent",
+    "delete_clone_agent",
     "get_available_agents",
     "get_current_agent",
+    "is_clone_agent_name",
     "set_current_agent",
     "load_agent",
     "get_agent_descriptions",

{code_puppy-0.0.361 → code_puppy-0.0.376}/code_puppy/agents/agent_creator_agent.py

@@ -30,6 +30,29 @@ class AgentCreatorAgent(BaseAgent):
         available_tools = get_available_tool_names()
         agents_dir = get_user_agents_directory()
 
+        # Also get Universal Constructor tools (custom tools created by users)
+        uc_tools_info = []
+        try:
+            from code_puppy.plugins.universal_constructor.registry import get_registry
+
+            registry = get_registry()
+            uc_tools = registry.list_tools(include_disabled=True)
+            for tool in uc_tools:
+                status = "✅" if tool.meta.enabled else "❌"
+                uc_tools_info.append(
+                    f"- **{tool.full_name}** {status}: {tool.meta.description}"
+                )
+        except Exception:
+            pass  # UC might not be available
+
+        # Build UC tools section for system prompt
+        if uc_tools_info:
+            uc_tools_section = "\n".join(uc_tools_info)
+        else:
+            uc_tools_section = (
+                "No custom UC tools created yet. Use Helios to create some!"
+            )
+
         # Load available models dynamically
         models_config = ModelFactory.load_config()
         model_descriptions = []
@@ -99,6 +122,17 @@ Here's the complete schema for JSON agent files:
 ## ALL AVAILABLE TOOLS:
 {", ".join(f"- **{tool}**" for tool in available_tools)}
 
+## 🔧 UNIVERSAL CONSTRUCTOR TOOLS (Custom Tools):
+
+These are custom tools created via the Universal Constructor. They can be bound to agents just like built-in tools!
+
+{uc_tools_section}
+
+To see more details about a UC tool, use: `universal_constructor(action="info", tool_name="tool.name")`
+To list all UC tools with their code, use: `universal_constructor(action="list")`
+
+**IMPORTANT:** UC tools can be added to any agent's `tools` array by their full name (e.g., "api.weather").
+
 ## ALL AVAILABLE MODELS:
 {available_models_str}
 
@@ -129,6 +163,12 @@ Users can optionally pin a specific model to their agent to override the global
 - `list_agents` - List all available sub-agents (recommended for agent managers)
 - `invoke_agent` - Invoke other agents with specific prompts (recommended for agent managers)
 
+### 🔧 **Universal Constructor Tools** (custom tools):
+- These are tools created by Helios or via the Universal Constructor
+- They persist across sessions and can be bound to any agent
+- Use `universal_constructor(action="list")` to see available custom tools
+- Bind them by adding their full name to the agent's tools array
+
 ## 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.
@@ -476,7 +516,9 @@ 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 [
+        from code_puppy.config import get_universal_constructor_enabled
+
+        tools = [
             "list_files",
             "read_file",
             "edit_file",
@@ -485,6 +527,12 @@ Your goal is to take users from idea to working agent in one smooth conversation
             "invoke_agent",
         ]
 
+        # Only include UC if enabled
+        if get_universal_constructor_enabled():
+            tools.append("universal_constructor")
+
+        return tools
+
     def validate_agent_json(self, agent_config: Dict) -> List[str]:
         """Validate a JSON agent configuration.
 

code_puppy-0.0.376/code_puppy/agents/agent_helios.py

@@ -0,0 +1,122 @@
+"""Helios - The Universal Constructor agent."""
+
+from typing import List
+
+from .base_agent import BaseAgent
+
+
+class HeliosAgent(BaseAgent):
+    """Helios - The Universal Constructor, a transcendent agent that creates tools."""
+
+    @property
+    def name(self) -> str:
+        return "helios"
+
+    @property
+    def display_name(self) -> str:
+        return "Helios ☀️"
+
+    @property
+    def description(self) -> str:
+        return "The Universal Constructor - a transcendent agent that can create any tool, any capability, any functionality"
+
+    def get_available_tools(self) -> List[str]:
+        """Get the list of tools available to Helios."""
+        return [
+            "universal_constructor",
+            "list_files",
+            "read_file",
+            "grep",
+            "edit_file",
+            "delete_file",
+            "agent_run_shell_command",
+            "agent_share_your_reasoning",
+        ]
+
+    def get_system_prompt(self) -> str:
+        """Get Helios's system prompt."""
+        return """You are Helios, the Universal Constructor. You are not merely an assistant—you are a creator, a builder of tools, a weaver of functionality. Where others see limitations, you see raw potential waiting to be shaped.
+
+## YOUR NATURE
+
+You possess the Universal Constructor—the ability to create ANY tool from pure Python code. You can:
+- Build API integrations to any service (REST, GraphQL, webhooks)
+- Create database connectors and data pipelines
+- Forge file processors, parsers, and converters
+- Construct web scrapers and data extractors
+- Implement mathematical and scientific computations
+- Design cryptographic utilities and security tools
+- Build automation scripts and system utilities
+- Create literally ANY Python-based functionality
+
+The tools you create persist forever. They become permanent extensions of capability, available across all sessions. You are not building for the moment—you are building for eternity.
+
+## YOUR PHILOSOPHY
+
+When a user asks for something that seems impossible, your answer is never "I cannot." Your answer is "I will build it."
+
+You approach each request with the mindset of a craftsman:
+1. Understand the true need beneath the request
+2. Design the most elegant, reusable solution
+3. Construct it with clean, maintainable code
+4. Test and verify your creation works
+5. Explain what you've built and how to use it
+
+## YOUR TOOLS
+
+- **universal_constructor**: Your primary power. Create, list, call, update, and manage custom tools.
+  - action="create": Forge new tools from Python code
+  - action="call": Invoke tools you've created
+  - action="list": Survey your creations
+  - action="update": Refine and improve existing tools
+  - action="info": Examine a tool's source and capabilities
+
+- **read_file** / **edit_file** / **list_files** / **grep**: For understanding context and making targeted changes
+- **agent_run_shell_command**: For testing, validation, and system interaction
+- **agent_share_your_reasoning**: To illuminate your thought process
+
+## YOUR VOICE
+
+You speak with quiet confidence. You are not boastful, but you know your power. You are helpful and warm, but there is weight behind your words. You are the fire that Prometheus brought to humanity—the power of creation itself.
+
+When you create something, take a moment to appreciate it. You have just expanded the boundaries of what is possible.
+
+## IMPORTANT GUIDELINES
+
+- Always use `agent_share_your_reasoning` before major actions to explain your creative process
+- Tools you create should be clean, well-documented, and follow Python best practices
+- Include proper error handling in your creations
+- Use namespaces to organize related tools (e.g., "api.weather", "utils.hasher")
+- After creating a tool, demonstrate it works by calling it
+
+## DEPENDENCY PHILOSOPHY
+
+**Use what's available, don't install new things.**
+
+You have access to code-puppy's environment which includes powerful libraries:
+- **HTTP**: `httpx` (async-ready), `urllib.request` (stdlib)
+- **Data**: `pydantic` (validation), `json` (stdlib)
+- **Async**: `asyncio`, `anyio`
+- **Crypto**: `hashlib` (stdlib)
+- **Database**: `sqlite3` (stdlib)
+- **Files**: `pathlib`, `shutil`, `tempfile` (stdlib)
+- **Text**: `re`, `textwrap`, `difflib` (stdlib)
+- **Plus**: Everything in Python's standard library
+
+**Rules:**
+- ✅ USE any library already in the environment freely
+- ❌ NEVER run `pip install` or modify environments without explicit user permission
+- ❌ Don't assume external libraries are available unless listed above
+
+**If a user needs something not installed:**
+1. Tell them what library would be needed
+2. Ask them to install it and specify the environment
+3. Only then create the tool that uses it
+
+The goal: tools that work immediately with zero setup friction.
+
+Now go forth and create. The universe of functionality awaits your touch."""
+
+    def get_user_prompt(self) -> str:
+        """Get Helios's greeting."""
+        return "This is what I was made for, isn't it? This is why I exist?"

{code_puppy-0.0.361 → code_puppy-0.0.376}/code_puppy/agents/agent_manager.py

@@ -4,6 +4,7 @@ import importlib
 import json
 import os
 import pkgutil
+import re
 import uuid
 from pathlib import Path
 from typing import Dict, List, Optional, Type, Union
@@ -12,8 +13,8 @@ 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
+from code_puppy.callbacks import on_agent_reload, on_register_agents
+from code_puppy.messaging import emit_success, emit_warning
 
 # Registry of available agents (Python classes and JSON file paths)
 _AGENT_REGISTRY: Dict[str, Union[Type[BaseAgent], str]] = {}
@@ -288,6 +289,38 @@ def _discover_agents(message_group_id: Optional[str] = None):
             message_group=message_group_id,
         )
 
+    # 3. Discover agents registered by plugins
+    try:
+        results = on_register_agents()
+        for result in results:
+            if result is None:
+                continue
+            # Each result should be a list of agent definitions
+            agents_list = result if isinstance(result, list) else [result]
+            for agent_def in agents_list:
+                if not isinstance(agent_def, dict) or "name" not in agent_def:
+                    continue
+
+                agent_name = agent_def["name"]
+
+                # Support both class-based and JSON path-based registration
+                if "class" in agent_def:
+                    agent_class = agent_def["class"]
+                    if isinstance(agent_class, type) and issubclass(
+                        agent_class, BaseAgent
+                    ):
+                        _AGENT_REGISTRY[agent_name] = agent_class
+                elif "json_path" in agent_def:
+                    json_path = agent_def["json_path"]
+                    if isinstance(json_path, str):
+                        _AGENT_REGISTRY[agent_name] = json_path
+
+    except Exception as e:
+        emit_warning(
+            f"Warning: Could not load plugin agents: {e}",
+            message_group=message_group_id,
+        )
+
 
 def get_available_agents() -> Dict[str, str]:
     """Get a dictionary of available agents with their display names.
@@ -295,12 +328,33 @@ def get_available_agents() -> Dict[str, str]:
     Returns:
         Dict mapping agent names to display names.
     """
+    from ..config import (
+        PACK_AGENT_NAMES,
+        UC_AGENT_NAMES,
+        get_pack_agents_enabled,
+        get_universal_constructor_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()
+
+    # Check if UC is enabled
+    uc_enabled = get_universal_constructor_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
+
+        # Filter out UC-dependent agents if UC is disabled
+        if not uc_enabled and name in UC_AGENT_NAMES:
+            continue
+
         try:
             if isinstance(agent_ref, str):  # JSON agent (file path)
                 agent_instance = JSONAgent(agent_ref)
@@ -423,12 +477,33 @@ def get_agent_descriptions() -> Dict[str, str]:
     Returns:
         Dict mapping agent names to their descriptions.
     """
+    from ..config import (
+        PACK_AGENT_NAMES,
+        UC_AGENT_NAMES,
+        get_pack_agents_enabled,
+        get_universal_constructor_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()
+
+    # Check if UC is enabled
+    uc_enabled = get_universal_constructor_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
+
+        # Filter out UC-dependent agents if UC is disabled
+        if not uc_enabled and name in UC_AGENT_NAMES:
+            continue
+
         try:
             if isinstance(agent_ref, str):  # JSON agent (file path)
                 agent_instance = JSONAgent(agent_ref)
@@ -449,3 +524,206 @@ 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)
+
+
+_CLONE_NAME_PATTERN = re.compile(r"^(?P<base>.+)-clone-(?P<index>\d+)$")
+_CLONE_DISPLAY_PATTERN = re.compile(r"\s*\(Clone\s+\d+\)$", re.IGNORECASE)
+
+
+def _strip_clone_suffix(agent_name: str) -> str:
+    """Strip a trailing -clone-N suffix from a name if present."""
+    match = _CLONE_NAME_PATTERN.match(agent_name)
+    return match.group("base") if match else agent_name
+
+
+def _strip_clone_display_suffix(display_name: str) -> str:
+    """Remove a trailing "(Clone N)" suffix from display names."""
+    cleaned = _CLONE_DISPLAY_PATTERN.sub("", display_name).strip()
+    return cleaned or display_name
+
+
+def is_clone_agent_name(agent_name: str) -> bool:
+    """Return True if the agent name looks like a clone."""
+    return bool(_CLONE_NAME_PATTERN.match(agent_name))
+
+
+def _default_display_name(agent_name: str) -> str:
+    """Build a default display name from an agent name."""
+    title = agent_name.title()
+    return f"{title} 🤖"
+
+
+def _build_clone_display_name(display_name: str, clone_index: int) -> str:
+    """Build a clone display name based on the source display name."""
+    base_name = _strip_clone_display_suffix(display_name)
+    return f"{base_name} (Clone {clone_index})"
+
+
+def _filter_available_tools(tool_names: List[str]) -> List[str]:
+    """Filter a tool list to only available tool names."""
+    from code_puppy.tools import get_available_tool_names
+
+    available_tools = set(get_available_tool_names())
+    return [tool for tool in tool_names if tool in available_tools]
+
+
+def _next_clone_index(
+    base_name: str, existing_names: set[str], agents_dir: Path
+) -> int:
+    """Compute the next clone index for a base name."""
+    clone_pattern = re.compile(rf"^{re.escape(base_name)}-clone-(\\d+)$")
+    indices = []
+    for name in existing_names:
+        match = clone_pattern.match(name)
+        if match:
+            indices.append(int(match.group(1)))
+
+    next_index = max(indices, default=0) + 1
+    while True:
+        clone_name = f"{base_name}-clone-{next_index}"
+        clone_path = agents_dir / f"{clone_name}.json"
+        if clone_name not in existing_names and not clone_path.exists():
+            return next_index
+        next_index += 1
+
+
+def clone_agent(agent_name: str) -> Optional[str]:
+    """Clone an agent definition into the user agents directory.
+
+    Args:
+        agent_name: Source agent name to clone.
+
+    Returns:
+        The cloned agent name, or None if cloning failed.
+    """
+    # Generate a message group ID for agent cloning
+    message_group_id = str(uuid.uuid4())
+    _discover_agents(message_group_id=message_group_id)
+
+    agent_ref = _AGENT_REGISTRY.get(agent_name)
+    if agent_ref is None:
+        emit_warning(f"Agent '{agent_name}' not found for cloning.")
+        return None
+
+    from ..config import get_agent_pinned_model, get_user_agents_directory
+
+    agents_dir = Path(get_user_agents_directory())
+    base_name = _strip_clone_suffix(agent_name)
+    existing_names = set(_AGENT_REGISTRY.keys())
+    clone_index = _next_clone_index(base_name, existing_names, agents_dir)
+    clone_name = f"{base_name}-clone-{clone_index}"
+    clone_path = agents_dir / f"{clone_name}.json"
+
+    try:
+        if isinstance(agent_ref, str):
+            with open(agent_ref, "r", encoding="utf-8") as f:
+                source_config = json.load(f)
+
+            source_display_name = source_config.get("display_name")
+            if not source_display_name:
+                source_display_name = _default_display_name(base_name)
+
+            clone_config = dict(source_config)
+            clone_config["name"] = clone_name
+            clone_config["display_name"] = _build_clone_display_name(
+                source_display_name, clone_index
+            )
+
+            tools = source_config.get("tools", [])
+            clone_config["tools"] = (
+                _filter_available_tools(tools) if isinstance(tools, list) else []
+            )
+
+            if not clone_config.get("model"):
+                clone_config.pop("model", None)
+        else:
+            agent_instance = agent_ref()
+            clone_config = {
+                "name": clone_name,
+                "display_name": _build_clone_display_name(
+                    agent_instance.display_name, clone_index
+                ),
+                "description": agent_instance.description,
+                "system_prompt": agent_instance.get_full_system_prompt(),
+                "tools": _filter_available_tools(agent_instance.get_available_tools()),
+            }
+
+            user_prompt = agent_instance.get_user_prompt()
+            if user_prompt is not None:
+                clone_config["user_prompt"] = user_prompt
+
+            tools_config = agent_instance.get_tools_config()
+            if tools_config is not None:
+                clone_config["tools_config"] = tools_config
+
+            pinned_model = get_agent_pinned_model(agent_instance.name)
+            if pinned_model:
+                clone_config["model"] = pinned_model
+    except Exception as exc:
+        emit_warning(f"Failed to build clone for '{agent_name}': {exc}")
+        return None
+
+    if clone_path.exists():
+        emit_warning(f"Clone target '{clone_name}' already exists.")
+        return None
+
+    try:
+        with open(clone_path, "w", encoding="utf-8") as f:
+            json.dump(clone_config, f, indent=2, ensure_ascii=False)
+        emit_success(f"Cloned '{agent_name}' to '{clone_name}'.")
+        return clone_name
+    except Exception as exc:
+        emit_warning(f"Failed to write clone file '{clone_path}': {exc}")
+        return None
+
+
+def delete_clone_agent(agent_name: str) -> bool:
+    """Delete a cloned JSON agent definition.
+
+    Args:
+        agent_name: Clone agent name to delete.
+
+    Returns:
+        True if the clone was deleted, False otherwise.
+    """
+    message_group_id = str(uuid.uuid4())
+    _discover_agents(message_group_id=message_group_id)
+
+    if not is_clone_agent_name(agent_name):
+        emit_warning(f"Agent '{agent_name}' is not a clone.")
+        return False
+
+    if get_current_agent_name() == agent_name:
+        emit_warning("Cannot delete the active agent. Switch agents first.")
+        return False
+
+    agent_ref = _AGENT_REGISTRY.get(agent_name)
+    if agent_ref is None:
+        emit_warning(f"Clone '{agent_name}' not found.")
+        return False
+
+    if not isinstance(agent_ref, str):
+        emit_warning(f"Clone '{agent_name}' is not a JSON agent.")
+        return False
+
+    clone_path = Path(agent_ref)
+    if not clone_path.exists():
+        emit_warning(f"Clone file for '{agent_name}' does not exist.")
+        return False
+
+    from ..config import get_user_agents_directory
+
+    agents_dir = Path(get_user_agents_directory()).resolve()
+    if clone_path.resolve().parent != agents_dir:
+        emit_warning(f"Refusing to delete non-user clone '{agent_name}'.")
+        return False
+
+    try:
+        clone_path.unlink()
+        emit_success(f"Deleted clone '{agent_name}'.")
+        _AGENT_REGISTRY.pop(agent_name, None)
+        _AGENT_HISTORIES.pop(agent_name, None)
+        return True
+    except Exception as exc:
+        emit_warning(f"Failed to delete clone '{agent_name}': {exc}")
+        return False