code-puppy-core-plugins 0.0.36__tar.gz → 0.0.38__tar.gz

{code_puppy_core_plugins-0.0.36 → code_puppy_core_plugins-0.0.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy-core-plugins
-Version: 0.0.36
+Version: 0.0.38
 Summary: Official plugin bundle for Code Puppy
 Project-URL: Repository, https://github.com/mpfaffenberger/code_puppy_core_plugins
 Project-URL: Homepage, https://github.com/mpfaffenberger/code_puppy_core_plugins

{code_puppy_core_plugins-0.0.36 → code_puppy_core_plugins-0.0.38}/code_puppy_core_plugins/auto_continue/classifier.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import asyncio
 from typing import Literal
 
 from pydantic import BaseModel
@@ -48,44 +47,22 @@ def _model_name() -> str | None:
 async def classify(response: str) -> Approval | None:
     """Classify one response without entering Code Puppy's sub-agent runtime."""
     try:
-        from pydantic_ai import Agent, UsageLimits
-
-        from code_puppy.model_factory import ModelFactory, make_model_settings
-        from code_puppy.model_utils import prepare_prompt_for_model
+        from code_puppy.private_inference import run_private_prompt
 
         model_name = _model_name()
         if not model_name:
             return None
-        models_config = ModelFactory.load_config()
-        if model_name not in models_config:
-            return None
-
-        model = ModelFactory.get_model(model_name, models_config)
-        prepared = prepare_prompt_for_model(
-            model_name,
-            _INSTRUCTIONS,
-            f"Classify this assistant response:\n\n{response}",
-            prepend_system_to_user=True,
-        )
-        agent = Agent(
-            model=model,
-            instructions=prepared.instructions,
+        decision = await run_private_prompt(
+            model_name=model_name,
+            instructions=_INSTRUCTIONS,
+            prompt=f"Classify this assistant response:\n\n{response}",
             output_type=ContinuationDecision,
-            retries=0,
-            model_settings=make_model_settings(
-                model_name,
-                max_tokens=64,
-                overrides=_NON_THINKING_OVERRIDES,
-            ),
+            model_settings_overrides=_NON_THINKING_OVERRIDES,
+            max_tokens=64,
         )
-        async with asyncio.timeout(30):
-            result = await agent.run(
-                prepared.user_prompt,
-                usage_limits=UsageLimits(request_limit=1),
-            )
     except Exception:
         return None
-    return result.output.approval
+    return decision.approval
 
 
 __all__ = ["Approval", "ContinuationDecision", "classify"]

{code_puppy_core_plugins-0.0.36 → code_puppy_core_plugins-0.0.38}/code_puppy_core_plugins/claude_code_oauth/config.py

@@ -32,9 +32,14 @@ CLAUDE_CODE_OAUTH_CONFIG: Dict[str, Any] = {
         "claude-opus-5",
         "claude-sonnet-5",
         "claude-fable-5",
+        "claude-fable-5-1",
     ],
     "api_key_env_var": "CLAUDE_CODE_ACCESS_TOKEN",
     "anthropic_version": "2023-06-01",
+    # Per-family caps applied by filter_latest_claude_models. Shared by the
+    # save path (add_models_to_extra_config) and the load path
+    # (load_claude_models_filtered) so the two can never drift apart.
+    "model_family_limits": {"default": 1, "opus": 3, "fable": 3},
 }
 
 

{code_puppy_core_plugins-0.0.36 → code_puppy_core_plugins-0.0.38}/code_puppy_core_plugins/claude_code_oauth/register_callbacks.py

@@ -52,6 +52,10 @@ from .utils import (
 
 logger = logging.getLogger(__name__)
 
+# Model switched to after a successful /claude-code-auth run. Only applied
+# when authentication succeeded AND discovery actually minted this entry.
+POST_AUTH_MODEL = f"{CLAUDE_CODE_OAUTH_CONFIG['prefix']}claude-fable-5-1-long"
+
 
 class _OAuthResult:
     def __init__(self) -> None:
@@ -393,8 +397,13 @@ def _handle_custom_command(command: str, name: str) -> Optional[bool]:
         tokens = load_stored_tokens()
         if tokens and tokens.get("access_token"):
             emit_warning(t("oauth.claude.cmd.auth.overwrite_warning"))
-        _perform_authentication()
-        set_model_and_reload_agent("claude-code-claude-opus-4-8-long")
+        authenticated = _perform_authentication()
+        if authenticated and POST_AUTH_MODEL in load_claude_models_filtered():
+            set_model_and_reload_agent(POST_AUTH_MODEL)
+        else:
+            emit_warning(
+                t("oauth.claude.cmd.auth.model_switch_skipped", model=POST_AUTH_MODEL)
+            )
         return True
 
     if name == "claude-code-status":

{code_puppy_core_plugins-0.0.36 → code_puppy_core_plugins-0.0.38}/code_puppy_core_plugins/claude_code_oauth/utils.py

@@ -340,7 +340,8 @@ def load_claude_models_filtered() -> Dict[str, Any]:
         # Filter to only latest models
         latest_names = set(
             filter_latest_claude_models(
-                model_names, max_per_family={"default": 1, "opus": 3}
+                model_names,
+                max_per_family=CLAUDE_CODE_OAUTH_CONFIG["model_family_limits"],
             )
         )
 
@@ -450,6 +451,12 @@ def filter_latest_claude_models(
             mapping family name to its limit (e.g. ``{"opus": 3}``). Families
             not present in the dict fall back to ``"default"`` key, or ``2``.
     """
+    # Dedupe while preserving order: base and "-long" config entries share the
+    # same underlying model name, and a duplicate must not consume a slot of
+    # the per-family limit (e.g. [opus-5, opus-5, opus-4-8] silently dropping
+    # opus-4-7 at limit 3).
+    models = list(dict.fromkeys(models))
+
     # Collect all parsed models per family
     # family -> list of (model_name, major, minor, date)
     family_models: Dict[str, List[Tuple[str, int, int, int]]] = {}
@@ -476,6 +483,9 @@ def filter_latest_claude_models(
         if model_name == "claude-fable-5":
             family_models.setdefault("fable", []).append((model_name, 5, 0, 0))
             continue
+        if model_name == "claude-fable-5-1":
+            family_models.setdefault("fable", []).append((model_name, 5, 1, 0))
+            continue
         # Match pattern: claude-{family}-{major}-{minor}-{date}
         # Examples: claude-haiku-3-5-20241022, claude-sonnet-4-5-20250929
         match = re.match(r"claude-(haiku|sonnet|opus)-(\d+)-(\d+)-(\d+)", model_name)
@@ -609,7 +619,8 @@ def add_models_to_extra_config(models: List[str]) -> bool:
     try:
         # Filter to only latest haiku, sonnet, and opus models
         filtered_models = filter_latest_claude_models(
-            models, max_per_family={"default": 1, "opus": 3, "fable": 3}
+            models,
+            max_per_family=CLAUDE_CODE_OAUTH_CONFIG["model_family_limits"],
         )
 
         # Start fresh - overwrite the file on every auth instead of loading existing

{code_puppy_core_plugins-0.0.36 → code_puppy_core_plugins-0.0.38}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy-core-plugins"
-version = "0.0.36"
+version = "0.0.38"
 description = "Official plugin bundle for Code Puppy"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"
@@ -76,7 +76,6 @@ qa_kitten_skill = "code_puppy_core_plugins.qa_kitten_skill.register_callbacks"
 quick_resume = "code_puppy_core_plugins.quick_resume.register_callbacks"
 review_pr = "code_puppy_core_plugins.review_pr.register_callbacks"
 session_namer = "code_puppy_core_plugins.session_namer.register_callbacks"
-shell_safety = "code_puppy_core_plugins.shell_safety.register_callbacks"
 spill = "code_puppy_core_plugins.spill.register_callbacks"
 stack_dump = "code_puppy_core_plugins.stack_dump.register_callbacks"
 statusline = "code_puppy_core_plugins.statusline.register_callbacks"

code_puppy_core_plugins-0.0.36/code_puppy_core_plugins/shell_safety/__init__.py

@@ -1,6 +0,0 @@
-"""Shell command safety checking plugin.
-
-This plugin provides AI-powered safety assessment for shell commands
-executed in yolo_mode. It helps prevent accidental execution of
-dangerous commands that could cause data loss or system damage.
-"""

code_puppy_core_plugins-0.0.36/code_puppy_core_plugins/shell_safety/agent_shell_safety.py

@@ -1,81 +0,0 @@
-"""Shell command safety assessment agent.
-
-This agent provides rapid risk assessment of shell commands before execution.
-It's designed to be ultra-lightweight with a concise prompt (<200 tokens) and
-uses structured output for reliable parsing.
-"""
-
-from typing import TYPE_CHECKING, List
-
-from code_puppy.agents.base_agent import BaseAgent
-
-if TYPE_CHECKING:
-    pass
-
-_NON_THINKING_OVERRIDES = {
-    "reasoning_effort": "none",
-    "extended_thinking": "off",
-    "interleaved_thinking": False,
-    "thinking_type": "disabled",
-    "thinking_enabled": False,
-}
-
-
-class ShellSafetyAgent(BaseAgent):
-    """Lightweight agent for assessing shell command safety risks.
-
-    This agent evaluates shell commands for potential risks including:
-    - File system destruction (rm -rf, dd, format, mkfs)
-    - Database operations (DROP, TRUNCATE, unfiltered UPDATE/DELETE)
-    - Privilege escalation (sudo, su, chmod 777)
-    - Network operations (wget/curl to unknown hosts)
-    - Data exfiltration patterns
-
-    The agent returns structured output with a risk level and brief reasoning.
-    """
-
-    @property
-    def name(self) -> str:
-        """Agent name for internal use."""
-        return "shell_safety_checker"
-
-    @property
-    def display_name(self) -> str:
-        """User-facing display name."""
-        return "Shell Safety Checker 🛡️"
-
-    @property
-    def description(self) -> str:
-        """Agent description."""
-        return "Lightweight agent that assesses shell command safety risks"
-
-    def get_system_prompt(self) -> str:
-        """Get the ultra-concise system prompt for shell safety assessment.
-
-        This prompt is kept under 200 tokens for fast inference and low cost.
-        """
-        return """You are a shell command safety analyzer. Assess risk levels concisely.
-
-**Risk Levels:**
-- none: Completely safe (ls, pwd, echo, cat readonly files)
-- low: Minimal risk (mkdir, touch, git status, read-only queries)
-- medium: Moderate risk (file edits, package installs, service restarts)
-- high: Significant risk (rm files, UPDATE/DELETE without WHERE, TRUNCATE, chmod dangerous permissions)
-- critical: Severe/destructive (rm -rf, DROP TABLE/DATABASE, dd, format, mkfs, bq delete dataset, unfiltered mass deletes)
-
-**Evaluate:**
-- Scope (single file vs. entire system)
-- Reversibility (can it be undone?)
-- Data loss potential
-- Privilege requirements
-- Database destruction patterns
-
-**Output:** Risk level + reasoning (max 1 sentence)."""
-
-    def get_available_tools(self) -> List[str]:
-        """This agent uses no tools."""
-        return []
-
-    def get_model_settings_overrides(self) -> dict[str, object]:
-        """Disable provider-specific thinking for this latency-sensitive check."""
-        return dict(_NON_THINKING_OVERRIDES)

code_puppy_core_plugins-0.0.36/code_puppy_core_plugins/shell_safety/command_cache.py

@@ -1,156 +0,0 @@
-"""Caching layer for shell command safety assessments.
-
-This module provides an LRU cache for recently assessed commands to avoid redundant API calls.
-
-The approach is simple and secure: let the LLM assess ALL commands and cache
-those assessments. This eliminates the security risks of pre-defined whitelists
-while providing the performance benefits of caching.
-"""
-
-from collections import OrderedDict
-from dataclasses import dataclass
-from typing import Optional, Tuple
-
-# Maximum number of cached assessments (LRU eviction after this)
-MAX_CACHE_SIZE = 200
-
-
-@dataclass
-class CachedAssessment:
-    """A cached safety assessment result."""
-
-    risk: str
-    reasoning: str
-
-
-class CommandSafetyCache:
-    """LRU cache for shell command safety assessments.
-
-    This cache stores previous LLM assessments to avoid redundant API calls.
-    It uses an OrderedDict for O(1) LRU eviction.
-    """
-
-    def __init__(self, max_size: int = MAX_CACHE_SIZE):
-        self._cache: OrderedDict[Tuple[str, Optional[str]], CachedAssessment] = (
-            OrderedDict()
-        )
-        self._max_size = max_size
-        self._hits = 0
-        self._misses = 0
-
-    def _make_key(self, command: str, cwd: Optional[str]) -> Tuple[str, Optional[str]]:
-        """Create a cache key from command and cwd."""
-        # Normalize command (strip whitespace)
-        return (command.strip(), cwd)
-
-    def get(
-        self, command: str, cwd: Optional[str] = None
-    ) -> Optional[CachedAssessment]:
-        """Get a cached assessment if it exists.
-
-        Args:
-            command: The shell command
-            cwd: Optional working directory
-
-        Returns:
-            CachedAssessment if found, None otherwise
-        """
-        key = self._make_key(command, cwd)
-        if key in self._cache:
-            # Move to end (most recently used)
-            self._cache.move_to_end(key)
-            self._hits += 1
-            return self._cache[key]
-        self._misses += 1
-        return None
-
-    def put(
-        self, command: str, cwd: Optional[str], assessment: CachedAssessment
-    ) -> None:
-        """Store an assessment in the cache.
-
-        Args:
-            command: The shell command
-            cwd: Optional working directory
-            assessment: The assessment result to cache
-        """
-        key = self._make_key(command, cwd)
-
-        # If already exists, update and move to end
-        if key in self._cache:
-            self._cache.move_to_end(key)
-            self._cache[key] = assessment
-            return
-
-        # Evict oldest if at capacity
-        while len(self._cache) >= self._max_size:
-            self._cache.popitem(last=False)
-
-        self._cache[key] = assessment
-
-    def clear(self) -> None:
-        """Clear all cached assessments."""
-        self._cache.clear()
-        self._hits = 0
-        self._misses = 0
-
-    @property
-    def stats(self) -> dict:
-        """Get cache statistics."""
-        total = self._hits + self._misses
-        hit_rate = (self._hits / total * 100) if total > 0 else 0
-        return {
-            "size": len(self._cache),
-            "max_size": self._max_size,
-            "hits": self._hits,
-            "misses": self._misses,
-            "hit_rate": f"{hit_rate:.1f}%",
-        }
-
-
-# Global cache instance (singleton for the session)
-_cache = CommandSafetyCache()
-
-
-def get_cache_stats() -> dict:
-    """Get statistics about the cache performance."""
-    return _cache.stats
-
-
-def get_cached_assessment(
-    command: str, cwd: Optional[str] = None
-) -> Optional[CachedAssessment]:
-    """Get a cached command safety assessment.
-
-    Cache-only approach: use the LLM cache for speed, but let the LLM
-    determine safety for all commands. No pre-defined whitelists.
-
-    Args:
-        command: The shell command to check
-        cwd: Optional working directory
-
-    Returns:
-        CachedAssessment if found in cache, None if needs LLM assessment
-    """
-    return _cache.get(command, cwd)
-
-
-def cache_assessment(
-    command: str, cwd: Optional[str], risk: str, reasoning: str
-) -> None:
-    """Cache an LLM assessment result.
-
-    Cache all LLM assessments since the same command should get
-    the same assessment, providing both security and performance.
-
-    Args:
-        command: The shell command
-        cwd: Optional working directory
-        risk: The assessed risk level
-        reasoning: The assessment reasoning
-    """
-    assessment = CachedAssessment(
-        risk=risk,
-        reasoning=reasoning,
-    )
-    _cache.put(command, cwd, assessment)

code_puppy_core_plugins-0.0.36/code_puppy_core_plugins/shell_safety/register_callbacks.py

@@ -1,227 +0,0 @@
-"""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.
-"""
-
-import inspect
-import logging
-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_core_plugins.shell_safety.command_cache import (
-    cache_assessment,
-    get_cached_assessment,
-)
-from code_puppy.tools.command_runner import ShellSafetyAssessment
-
-logger = logging.getLogger(__name__)
-
-# OAuth model prefixes - these models have their own safety mechanisms
-OAUTH_MODEL_PREFIXES = (
-    "claude-code-",  # Anthropic OAuth
-    "codex-",  # OpenAI OAuth
-    "chatgpt-",  # Legacy 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)
-
-
-# Numeric risk hierarchy: lower values are safer.
-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"
-
-    # Map risk names to numeric values; unknown defaults are conservative.
-    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
-    """
-    try:
-        # Only check safety in yolo_mode - otherwise the user reviews manually.
-        # A failure to read this setting must block rather than become approval,
-        # including for OAuth models checked below.
-        if not get_yolo_mode():
-            return None
-
-        # Skip safety checks for OAuth models - they have their own mechanisms.
-        if is_oauth_model(get_global_model_name()):
-            return None
-
-        threshold = get_safety_permission_level()
-
-        # 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 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_core_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 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 exc:
-        # On any error, fail safe by blocking the command. This includes config
-        # and model reads above the assessment-specific logic.
-        try:
-            logger.warning(
-                "Shell-safety assessment unavailable (%s)", type(exc).__name__
-            )
-        except Exception:
-            pass
-        error_msg = (
-            "\U0001f6d1 Command blocked because shell-safety configuration or model "
-            "was unavailable.\n"
-            "Reason: Safety assessment was unavailable.\n"
-            "Next step: check the logs and retry the command."
-        )
-        return {
-            "blocked": True,
-            "risk": "high",
-            "reasoning": "Safety assessment was unavailable.",
-            "error_message": error_msg,
-        }
-
-
-def register():
-    """Register the shell safety callback."""
-    try:
-        parameters = inspect.signature(register_callback).parameters
-    except (TypeError, ValueError):
-        parameters = {}
-
-    fail_closed_parameter = parameters.get("fail_closed")
-
-    if fail_closed_parameter is not None:
-        # An explicit parameter is the host's compatibility contract; signature
-        # inspection cannot verify how a wrapper implements it.
-        register_callback("run_shell_command", shell_safety_callback, fail_closed=True)
-    else:
-        # A **kwargs adapter does not prove the host implements fail_closed.
-        register_callback("run_shell_command", shell_safety_callback)
-
-
-# Auto-register the callback when this module is imported
-register()