newcode 0.1.1__py3-none-any.whl

code_puppy/plugins/shell_safety/register_callbacks.py

@@ -0,0 +1,202 @@
+"""Callback registration for shell command safety checking.
+
+This module registers a callback that intercepts shell commands in yolo_mode
+and assesses their safety risk before execution.
+"""
+
+from typing import Any, Dict, Optional
+
+from code_puppy.callbacks import register_callback
+from code_puppy.config import (
+    get_global_model_name,
+    get_safety_permission_level,
+    get_yolo_mode,
+)
+from code_puppy.messaging import emit_info
+from code_puppy.plugins.shell_safety.command_cache import (
+    cache_assessment,
+    get_cached_assessment,
+)
+from code_puppy.tools.command_runner import ShellSafetyAssessment
+
+# OAuth model prefixes - these models have their own safety mechanisms
+OAUTH_MODEL_PREFIXES = (
+    "claude-code-",  # Anthropic OAuth
+    "chatgpt-",  # OpenAI OAuth
+    "gemini-oauth",  # Google OAuth
+)
+
+
+def is_oauth_model(model_name: str | None) -> bool:
+    """Check if the model is an OAuth model that should skip safety checks.
+
+    OAuth models have their own built-in safety mechanisms, so we skip
+    the shell safety callback to avoid redundant checks and potential bugs.
+
+    Args:
+        model_name: The name of the current model
+
+    Returns:
+        True if the model is an OAuth model, False otherwise
+    """
+    if not model_name:
+        return False
+    return model_name.startswith(OAUTH_MODEL_PREFIXES)
+
+
+# Risk level hierarchy for numeric comparison
+# Lower numbers = safer commands, higher numbers = more dangerous
+# This mapping allows us to compare risk levels as integers
+RISK_LEVELS: Dict[str, int] = {
+    "none": 0,
+    "low": 1,
+    "medium": 2,
+    "high": 3,
+    "critical": 4,
+}
+
+
+def compare_risk_levels(assessed_risk: Optional[str], threshold: str) -> bool:
+    """Compare assessed risk against threshold.
+
+    Args:
+        assessed_risk: The risk level from the agent (can be None)
+        threshold: The configured risk threshold
+
+    Returns:
+        True if the command should be blocked (risk exceeds threshold)
+        False if the command is acceptable
+    """
+    # If assessment failed (None), treat as high risk (fail-safe behavior)
+    if assessed_risk is None:
+        assessed_risk = "high"
+
+    # Convert risk levels to numeric values for comparison
+    assessed_level = RISK_LEVELS.get(assessed_risk, 4)  # Default to critical if unknown
+    threshold_level = RISK_LEVELS.get(threshold, 2)  # Default to medium if unknown
+
+    # Block if assessed risk is GREATER than threshold
+    # Note: Commands AT the threshold level are allowed (>, not >=)
+    return assessed_level > threshold_level
+
+
+async def shell_safety_callback(
+    context: Any, command: str, cwd: Optional[str] = None, timeout: int = 60
+) -> Optional[Dict[str, Any]]:
+    """Callback to assess shell command safety before execution.
+
+    This callback is only active when yolo_mode is True. When yolo_mode is False,
+    the user manually reviews every command, so we don't need the agent.
+
+    Args:
+        context: The execution context
+        command: The shell command to execute
+        cwd: Optional working directory
+        timeout: Command timeout (unused here)
+
+    Returns:
+        None if command is safe to proceed
+        Dict with rejection info if command should be blocked
+    """
+    # Skip safety checks for OAuth models - they have their own safety mechanisms
+    current_model = get_global_model_name()
+    if is_oauth_model(current_model):
+        return None
+
+    # Only check safety in yolo_mode - otherwise user is reviewing manually
+    yolo_mode = get_yolo_mode()
+    if not yolo_mode:
+        return None
+
+    # Get configured risk threshold
+    threshold = get_safety_permission_level()
+
+    try:
+        # Check cache first (fast path - no LLM call)
+        cached = get_cached_assessment(command, cwd)
+
+        if cached:
+            # Got a cached result - check against threshold
+            if compare_risk_levels(cached.risk, threshold):
+                # Cached result says it's too risky
+                risk_display = cached.risk or "unknown"
+                concise_reason = cached.reasoning or "No reasoning provided"
+                error_msg = (
+                    f"🛑 Command blocked (risk {risk_display.upper()} > permission {threshold.upper()}).\n"
+                    f"Reason: {concise_reason}\n"
+                    f"Override: /set yolo_mode true or /set safety_permission_level {risk_display}"
+                )
+                emit_info(error_msg)
+                return {
+                    "blocked": True,
+                    "risk": cached.risk,
+                    "reasoning": cached.reasoning,
+                    "error_message": error_msg,
+                }
+            # Cached result is within threshold - allow silently
+            return None
+
+        # Cache miss - need LLM assessment
+        # Import here to avoid circular imports
+        from code_puppy.plugins.shell_safety.agent_shell_safety import ShellSafetyAgent
+
+        # Create agent and assess command
+        agent = ShellSafetyAgent()
+
+        # Build the assessment prompt with optional cwd context
+        prompt = f"Assess this shell command:\n\nCommand: {command}"
+        if cwd:
+            prompt += f"\nWorking directory: {cwd}"
+
+        # Run async assessment with structured output type
+        result = await agent.run_with_mcp(prompt, output_type=ShellSafetyAssessment)
+        assessment = result.output
+
+        # Cache the result for future use, but only if it's not a fallback assessment
+        if not getattr(assessment, "is_fallback", False):
+            cache_assessment(command, cwd, assessment.risk, assessment.reasoning)
+
+        # Check if risk exceeds threshold (commands at threshold are allowed)
+        if compare_risk_levels(assessment.risk, threshold):
+            risk_display = assessment.risk or "unknown"
+            concise_reason = assessment.reasoning or "No reasoning provided"
+            error_msg = (
+                f"🛑 Command blocked (risk {risk_display.upper()} > permission {threshold.upper()}).\n"
+                f"Reason: {concise_reason}\n"
+                f"Override: /set yolo_mode true or /set safety_permission_level {risk_display}"
+            )
+            emit_info(error_msg)
+
+            # Return rejection info for the command runner
+            return {
+                "blocked": True,
+                "risk": assessment.risk,
+                "reasoning": assessment.reasoning,
+                "error_message": error_msg,
+            }
+
+        # Command is within acceptable risk threshold - remain silent
+        return None  # Allow command to proceed
+
+    except Exception as e:
+        # On any error, fail safe by blocking the command
+        error_msg = (
+            f"🛑 Command blocked (risk HIGH > permission {threshold.upper()}).\n"
+            f"Reason: Safety assessment error: {str(e)}\n"
+            f"Override: /set yolo_mode true or /set safety_permission_level high"
+        )
+        return {
+            "blocked": True,
+            "risk": "high",
+            "reasoning": f"Safety assessment error: {str(e)}",
+            "error_message": error_msg,
+        }
+
+
+def register():
+    """Register the shell safety callback."""
+    register_callback("run_shell_command", shell_safety_callback)
+
+
+# Auto-register the callback when this module is imported
+register()

code_puppy/plugins/synthetic_status/__init__.py

@@ -0,0 +1 @@
+"""Synthetic provider status plugin."""

code_puppy/plugins/synthetic_status/register_callbacks.py

@@ -0,0 +1,132 @@
+"""Slash commands for Synthetic provider subscription status."""
+
+from __future__ import annotations
+
+from typing import List, Optional, Tuple
+
+from rich.panel import Panel
+
+from code_puppy.callbacks import register_callback
+from code_puppy.messaging import emit_error, emit_info, emit_warning
+from code_puppy.model_factory import get_api_key
+
+from .status_api import fetch_synthetic_quota, resolve_syn_api_key
+
+_PROVIDER_ENV_KEYS = {
+    "synthetic": "SYN_API_KEY",
+    "openai": "OPENAI_API_KEY",
+    "anthropic": "ANTHROPIC_API_KEY",
+    "gemini": "GEMINI_API_KEY",
+    "cerebras": "CEREBRAS_API_KEY",
+    "openrouter": "OPENROUTER_API_KEY",
+    "zai": "ZAI_API_KEY",
+    "azure_openai": "AZURE_OPENAI_API_KEY",
+}
+
+
+def _custom_help() -> List[Tuple[str, str]]:
+    return [
+        ("synthetic-status", "Check Synthetic subscription quota and renewal time"),
+        ("provider", "Provider utilities (usage: /provider synthetic status)"),
+        (
+            "status",
+            "Show provider status when only Synthetic appears configured",
+        ),
+    ]
+
+
+def _format_amount(value: float) -> str:
+    rounded = round(value)
+    if abs(value - rounded) < 1e-9:
+        return str(int(rounded))
+    return f"{value:.2f}".rstrip("0").rstrip(".")
+
+
+def _render_synthetic_status_panel(
+    limit: float,
+    used: float,
+    renews_at_utc: str,
+) -> Panel:
+    remaining = max(limit - used, 0.0)
+    body = "\n".join(
+        [
+            "Provider      : Synthetic",
+            f"Requests used : {_format_amount(used)} / {_format_amount(limit)}",
+            f"Requests left : {_format_amount(remaining)}",
+            f"Renews at     : {renews_at_utc}",
+        ]
+    )
+    return Panel(body, border_style="cyan")
+
+
+def _handle_synthetic_status() -> None:
+    api_key = resolve_syn_api_key()
+    if not api_key:
+        emit_error("SYN_API_KEY is not configured. Set it with /set syn_api_key <key>.")
+        return
+
+    result = fetch_synthetic_quota(api_key=api_key)
+    if not result.ok or not result.quota:
+        emit_warning(result.error or "Failed to fetch Synthetic quota status.")
+        return
+
+    renews_at_str = result.quota.renews_at_utc.strftime("%Y-%m-%d %H:%M UTC")
+    panel = _render_synthetic_status_panel(
+        limit=result.quota.limit,
+        used=result.quota.requests_used,
+        renews_at_utc=renews_at_str,
+    )
+    emit_info(panel)
+
+
+def _is_synthetic_only_provider_configured() -> bool:
+    configured = {
+        provider
+        for provider, env_name in _PROVIDER_ENV_KEYS.items()
+        if get_api_key(env_name)
+    }
+    return configured == {"synthetic"}
+
+
+def _handle_provider_command(command: str) -> Optional[bool]:
+    tokens = command.strip().split()
+    if len(tokens) < 2:
+        return None
+
+    provider = tokens[1].lower()
+    if provider != "synthetic":
+        return None
+
+    if len(tokens) == 3 and tokens[2].lower() == "status":
+        _handle_synthetic_status()
+        return True
+
+    emit_info("Usage: /provider synthetic status")
+    return True
+
+
+def _handle_custom_command(command: str, name: str) -> Optional[bool]:
+    if not name:
+        return None
+
+    if name == "synthetic-status":
+        _handle_synthetic_status()
+        return True
+
+    if name == "provider":
+        return _handle_provider_command(command)
+
+    if name == "status":
+        if _is_synthetic_only_provider_configured():
+            _handle_synthetic_status()
+        else:
+            emit_warning(
+                "Multiple providers appear configured. Use /provider synthetic status."
+            )
+        return True
+
+    return None
+
+
+register_callback("custom_command_help", _custom_help)
+register_callback("custom_command", _handle_custom_command)

code_puppy/plugins/synthetic_status/status_api.py

@@ -0,0 +1,147 @@
+"""HTTP helpers for Synthetic quota status."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+
+import requests
+
+from code_puppy.model_factory import get_api_key
+
+SYNTHETIC_QUOTAS_URL = "https://api.synthetic.new/v2/quotas"
+
+
+@dataclass
+class SyntheticQuota:
+    """Parsed Synthetic subscription quota values."""
+
+    limit: float
+    requests_used: float
+    renews_at_utc: datetime
+
+
+@dataclass
+class SyntheticQuotaResult:
+    """Result wrapper for Synthetic quota fetches."""
+
+    quota: SyntheticQuota | None = None
+    error: str | None = None
+
+    @property
+    def ok(self) -> bool:
+        return self.quota is not None and self.error is None
+
+
+def resolve_syn_api_key() -> str | None:
+    """Resolve SYN_API_KEY from config/environment."""
+    value = get_api_key("SYN_API_KEY")
+    if not value:
+        return None
+    value = value.strip()
+    return value or None
+
+
+def _parse_renews_at(value: object) -> datetime | None:
+    if not isinstance(value, str) or not value.strip():
+        return None
+
+    normalized = value.strip().replace("Z", "+00:00")
+    try:
+        parsed = datetime.fromisoformat(normalized)
+    except ValueError:
+        return None
+
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=timezone.utc)
+    return parsed.astimezone(timezone.utc)
+
+
+def fetch_synthetic_quota(
+    api_key: str,
+    timeout_seconds: float = 15.0,
+) -> SyntheticQuotaResult:
+    """Fetch and validate Synthetic subscription quota status."""
+    if not api_key:
+        return SyntheticQuotaResult(error="SYN_API_KEY is not configured.")
+
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Accept": "application/json",
+    }
+
+    try:
+        response = requests.get(
+            SYNTHETIC_QUOTAS_URL,
+            headers=headers,
+            timeout=timeout_seconds,
+        )
+    except requests.Timeout:
+        return SyntheticQuotaResult(error="Synthetic API request timed out.")
+    except requests.ConnectionError:
+        return SyntheticQuotaResult(
+            error="Could not connect to the Synthetic API endpoint."
+        )
+    except requests.RequestException as exc:
+        return SyntheticQuotaResult(error=f"Synthetic API request failed: {exc}")
+
+    if response.status_code in (401, 403):
+        return SyntheticQuotaResult(
+            error="Synthetic API authentication failed. Check SYN_API_KEY."
+        )
+    if response.status_code == 429:
+        return SyntheticQuotaResult(
+            error="Synthetic API rate limited this request (HTTP 429)."
+        )
+    if response.status_code >= 500:
+        return SyntheticQuotaResult(
+            error=f"Synthetic API server error (HTTP {response.status_code})."
+        )
+    if response.status_code != 200:
+        detail = response.text.strip()
+        if len(detail) > 200:
+            detail = f"{detail[:200]}..."
+        suffix = f": {detail}" if detail else ""
+        return SyntheticQuotaResult(
+            error=f"Synthetic API returned HTTP {response.status_code}{suffix}"
+        )
+
+    try:
+        payload = response.json()
+    except ValueError:
+        return SyntheticQuotaResult(
+            error="Synthetic API returned invalid JSON for /v2/quotas."
+        )
+
+    if not isinstance(payload, dict):
+        return SyntheticQuotaResult(
+            error="Synthetic API response payload is not an object."
+        )
+
+    subscription = payload.get("subscription")
+    if not isinstance(subscription, dict):
+        return SyntheticQuotaResult(
+            error="Synthetic API response is missing 'subscription'."
+        )
+
+    try:
+        limit = float(subscription.get("limit"))
+        requests_used = float(subscription.get("requests"))
+    except (TypeError, ValueError):
+        return SyntheticQuotaResult(
+            error="Synthetic API response has invalid numeric quota values."
+        )
+
+    renews_at = _parse_renews_at(subscription.get("renewsAt"))
+    if renews_at is None:
+        return SyntheticQuotaResult(
+            error="Synthetic API response has an invalid 'renewsAt' timestamp."
+        )
+
+    return SyntheticQuotaResult(
+        quota=SyntheticQuota(
+            limit=limit,
+            requests_used=requests_used,
+            renews_at_utc=renews_at,
+        )
+    )

code_puppy/plugins/universal_constructor/__init__.py

@@ -0,0 +1,13 @@
+"""Universal Constructor - Dynamic tool creation and management plugin.
+
+This plugin enables users to create, manage, and deploy custom tools
+that extend the agent's capabilities. Tools are stored in the user's
+config directory and can be organized into namespaces via subdirectories.
+"""
+
+from pathlib import Path
+
+# User tools directory - where user-created UC tools live
+USER_UC_DIR = Path.home() / ".code_puppy" / "plugins" / "universal_constructor"
+
+__all__ = ["USER_UC_DIR"]

code_puppy/plugins/universal_constructor/models.py

@@ -0,0 +1,138 @@
+"""Pydantic models for Universal Constructor tools and responses.
+
+This module defines the data structures used throughout the UC plugin
+for representing tool metadata, tool information, and operation responses.
+"""
+
+from typing import Any, List, Optional
+
+from pydantic import BaseModel, Field
+
+
+class ToolMeta(BaseModel):
+    """Metadata for a UC tool.
+
+    This is the structure expected in the TOOL_META dictionary
+    at the top of each tool file.
+    """
+
+    name: str = Field(..., description="Human-readable tool name")
+    namespace: str = Field(
+        default="", description="Namespace for the tool (from subdirectory path)"
+    )
+    description: str = Field(..., description="What the tool does")
+    enabled: bool = Field(default=True, description="Whether the tool is active")
+    version: str = Field(default="1.0.0", description="Semantic version of the tool")
+    author: str = Field(default="", description="Tool author or creator")
+    created_at: Optional[str] = Field(
+        default=None, description="When the tool was created (ISO format string)"
+    )
+
+    model_config = {"extra": "allow"}  # Allow additional metadata fields
+
+
+class UCToolInfo(BaseModel):
+    """Full information about a UC tool.
+
+    Combines metadata with runtime information like function signature
+    and source file location.
+    """
+
+    meta: ToolMeta = Field(..., description="Tool metadata")
+    signature: str = Field(..., description="Function signature string")
+    source_path: str = Field(..., description="Path to the tool source file")
+    function_name: str = Field(default="", description="Name of the callable function")
+    docstring: Optional[str] = Field(default=None, description="Function docstring")
+
+    model_config = {"arbitrary_types_allowed": True}
+
+    @property
+    def full_name(self) -> str:
+        """Get the fully qualified tool name including namespace."""
+        if self.meta.namespace:
+            return f"{self.meta.namespace}.{self.meta.name}"
+        return self.meta.name
+
+
+# Response models for UC operations
+
+
+class UCListOutput(BaseModel):
+    """Response model for listing UC tools."""
+
+    tools: List[UCToolInfo] = Field(
+        default_factory=list, description="List of available tools"
+    )
+    total_count: int = Field(default=0, description="Total number of tools")
+    enabled_count: int = Field(default=0, description="Number of enabled tools")
+    error: Optional[str] = Field(default=None, description="Error message if any")
+
+    model_config = {"arbitrary_types_allowed": True}
+
+
+class UCCallOutput(BaseModel):
+    """Response model for calling a UC tool."""
+
+    success: bool = Field(..., description="Whether the call succeeded")
+    tool_name: str = Field(..., description="Name of the tool that was called")
+    result: Any = Field(default=None, description="Return value from the tool")
+    error: Optional[str] = Field(default=None, description="Error message if failed")
+    execution_time: Optional[float] = Field(
+        default=None, description="Execution time in seconds"
+    )
+    source_preview: Optional[str] = Field(
+        default=None, description="Preview of the tool's source code that was executed"
+    )
+
+
+class UCCreateOutput(BaseModel):
+    """Response model for creating a UC tool."""
+
+    success: bool = Field(..., description="Whether creation succeeded")
+    tool_name: str = Field(default="", description="Name of the created tool")
+    source_path: Optional[str] = Field(
+        default=None, description="Path where tool was saved"
+    )
+    preview: Optional[str] = Field(
+        default=None, description="Preview of the first 10 lines of source code"
+    )
+    error: Optional[str] = Field(default=None, description="Error message if failed")
+    validation_warnings: List[str] = Field(
+        default_factory=list, description="Non-fatal validation warnings"
+    )
+
+    model_config = {"arbitrary_types_allowed": True}
+
+
+class UCUpdateOutput(BaseModel):
+    """Response model for updating a UC tool."""
+
+    success: bool = Field(..., description="Whether update succeeded")
+    tool_name: str = Field(default="", description="Name of the updated tool")
+    source_path: Optional[str] = Field(
+        default=None, description="Path to the updated tool"
+    )
+    preview: Optional[str] = Field(
+        default=None, description="Preview of the first 10 lines of updated source code"
+    )
+    error: Optional[str] = Field(default=None, description="Error message if failed")
+    changes_applied: List[str] = Field(
+        default_factory=list, description="List of changes that were applied"
+    )
+
+    model_config = {"arbitrary_types_allowed": True}
+
+
+class UCInfoOutput(BaseModel):
+    """Response model for getting info about a specific UC tool."""
+
+    success: bool = Field(..., description="Whether lookup succeeded")
+    tool: Optional[UCToolInfo] = Field(
+        default=None, description="Tool information if found"
+    )
+    source_code: Optional[str] = Field(
+        default=None, description="Source code of the tool"
+    )
+    error: Optional[str] = Field(default=None, description="Error message if failed")
+
+    model_config = {"arbitrary_types_allowed": True}

code_puppy/plugins/universal_constructor/register_callbacks.py

@@ -0,0 +1,47 @@
+"""Callback registration for the Universal Constructor plugin.
+
+This module registers callbacks to integrate UC with the rest of
+the application. It ensures the plugin is properly loaded and initialized.
+"""
+
+import logging
+
+from code_puppy.callbacks import register_callback
+
+from . import USER_UC_DIR
+from .registry import get_registry
+
+logger = logging.getLogger(__name__)
+
+
+def _on_startup() -> None:
+    """Initialize UC plugin on application startup."""
+    from code_puppy.config import get_universal_constructor_enabled
+
+    # Skip initialization if UC is disabled
+    if not get_universal_constructor_enabled():
+        logger.debug("Universal Constructor is disabled, skipping initialization")
+        return
+
+    logger.debug("Universal Constructor plugin initializing...")
+
+    # Ensure the user tools directory exists
+    USER_UC_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Do an initial scan of tools (lazy - will happen on first access)
+    registry = get_registry()
+    logger.debug(f"UC registry initialized, tools dir: {registry._tools_dir}")
+
+    # Log plugin info at startup
+    tools = registry.list_tools(include_disabled=True)
+    enabled = [t for t in tools if t.meta.enabled]
+    logger.debug(
+        f"UC plugin loaded: {len(enabled)}/{len(tools)} tools enabled "
+        f"from {USER_UC_DIR}"
+    )
+
+
+# Register startup callback
+register_callback("startup", _on_startup)
+
+logger.debug("Universal Constructor plugin callbacks registered")