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

{code_puppy_core_plugins-0.0.37 → 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.37
+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.37 → 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.37 → 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.37 → 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.37 → 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.37"
+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.37/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.37/code_puppy_core_plugins/shell_safety/classifier.py

@@ -1,48 +0,0 @@
-"""Private shell-command risk classifier."""
-
-from code_puppy.config import get_global_model_name
-from code_puppy.private_inference import run_private_prompt
-from code_puppy.tools.command_runner import ShellSafetyAssessment
-
-_INSTRUCTIONS = """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, unfiltered UPDATE/DELETE, TRUNCATE, dangerous chmod)
-- critical: Severe/destructive (rm -rf, DROP, dd, format, mkfs, mass deletes)
-
-Evaluate scope, reversibility, data-loss potential, privileges, and database
-destruction patterns. Return the risk level and at most one sentence of reasoning."""
-
-_NON_THINKING_OVERRIDES = {
-    "reasoning_effort": "none",
-    "extended_thinking": "off",
-    "interleaved_thinking": False,
-    "thinking_type": "disabled",
-    "thinking_enabled": False,
-}
-
-
-async def classify(command: str, cwd: str | None = None) -> ShellSafetyAssessment:
-    """Assess one command without entering Code Puppy's agent runtime."""
-    model_name = get_global_model_name()
-    if not model_name:
-        raise RuntimeError("No model configured for shell-safety assessment")
-
-    prompt = f"Assess this shell command:\n\nCommand: {command}"
-    if cwd:
-        prompt += f"\nWorking directory: {cwd}"
-
-    return await run_private_prompt(
-        model_name=model_name,
-        instructions=_INSTRUCTIONS,
-        prompt=prompt,
-        output_type=ShellSafetyAssessment,
-        model_settings_overrides=_NON_THINKING_OVERRIDES,
-        max_tokens=128,
-    )
-
-
-__all__ = ["classify"]

code_puppy_core_plugins-0.0.37/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.37/code_puppy_core_plugins/shell_safety/register_callbacks.py

@@ -1,209 +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_core_plugins.shell_safety.command_cache import (
-    cache_assessment,
-    get_cached_assessment,
-)
-
-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}"
-                )
-                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
-        from code_puppy_core_plugins.shell_safety.classifier import classify
-
-        assessment = await classify(command, cwd)
-
-        # 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}"
-            )
-            # 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()