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

{code_puppy_core_plugins-0.0.35 → code_puppy_core_plugins-0.0.37}/.gitignore

@@ -6,3 +6,9 @@ __pycache__/
 htmlcov/
 dist/
 *.egg-info/
+
+# macOS metadata
+.DS_Store
+
+# Local git worktrees
+.worktrees/

{code_puppy_core_plugins-0.0.35 → code_puppy_core_plugins-0.0.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy-core-plugins
-Version: 0.0.35
+Version: 0.0.37
 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.35 → code_puppy_core_plugins-0.0.37}/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.37/code_puppy_core_plugins/shell_safety/classifier.py

@@ -0,0 +1,48 @@
+"""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.35 → code_puppy_core_plugins-0.0.37}/code_puppy_core_plugins/shell_safety/register_callbacks.py

@@ -14,12 +14,10 @@ from code_puppy.config import (
     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__)
 
@@ -128,7 +126,6 @@ async def shell_safety_callback(
                     f"Reason: {concise_reason}\n"
                     f"Override: /set safety_permission_level {risk_display}"
                 )
-                emit_info(error_msg)
                 return {
                     "blocked": True,
                     "risk": cached.risk,
@@ -139,22 +136,9 @@ async def shell_safety_callback(
             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()
+        from code_puppy_core_plugins.shell_safety.classifier import classify
 
-        # 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
+        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):
@@ -169,8 +153,6 @@ async def shell_safety_callback(
                 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,

{code_puppy_core_plugins-0.0.35 → code_puppy_core_plugins-0.0.37}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy-core-plugins"
-version = "0.0.35"
+version = "0.0.37"
 description = "Official plugin bundle for Code Puppy"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"

code_puppy_core_plugins-0.0.35/code_puppy_core_plugins/shell_safety/agent_shell_safety.py

@@ -1,69 +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
-
-
-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 - pure reasoning only."""
-        return []