code-puppy-core-plugins 0.0.30__tar.gz → 0.0.32__tar.gz

{code_puppy_core_plugins-0.0.30 → code_puppy_core_plugins-0.0.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy-core-plugins
-Version: 0.0.30
+Version: 0.0.32
 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.32/code_puppy_core_plugins/auto_continue/__init__.py

@@ -0,0 +1 @@
+"""Automatic approval of routine agent continuation requests."""

code_puppy_core_plugins-0.0.32/code_puppy_core_plugins/auto_continue/classifier.py

@@ -0,0 +1,91 @@
+"""Private, one-shot model classifier for automatic continuation."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Literal
+
+from pydantic import BaseModel
+
+Approval = Literal["yes, go.", "continue", "okay"]
+
+_INSTRUCTIONS = """Decide whether the assistant is merely waiting for permission to
+continue routine work the user already requested.
+
+Approve only a clear request to continue, proceed, or perform an explicitly
+described next step within the existing task. Do not approve destructive or
+risky actions, credential or payment requests, ambiguous choices, requests for
+new requirements, completed work, or anything needing a real human decision.
+Return no approval when uncertain."""
+
+_NON_THINKING_OVERRIDES = {
+    "reasoning_effort": "none",
+    "extended_thinking": "off",
+    "thinking_type": "disabled",
+    "thinking_enabled": False,
+    "verbosity": "low",
+}
+
+
+class ContinuationDecision(BaseModel):
+    """Strict classifier result; ``None`` means wait for the user."""
+
+    approval: Approval | None = None
+
+
+def _model_name() -> str | None:
+    """Use the dedicated override when available, otherwise the global model."""
+    try:
+        from code_puppy.config import get_auto_continue_model_name
+
+        return get_auto_continue_model_name()
+    except ImportError:  # Compatibility with core versions before the setting.
+        from code_puppy.config import get_global_model_name, get_value
+
+        return get_value("auto_continue_model") or get_global_model_name()
+
+
+async def classify(response: str) -> Approval | None:
+    """Classify one response without entering Code Puppy's sub-agent runtime."""
+    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
+
+    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,
+        output_type=ContinuationDecision,
+        retries=0,
+        model_settings=make_model_settings(
+            model_name,
+            max_tokens=64,
+            overrides=_NON_THINKING_OVERRIDES,
+        ),
+    )
+    try:
+        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
+
+
+__all__ = ["Approval", "ContinuationDecision", "classify"]

code_puppy_core_plugins-0.0.32/code_puppy_core_plugins/auto_continue/register_callbacks.py

@@ -0,0 +1,41 @@
+"""Register automatic continuation after routine permission requests."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from code_puppy.callbacks import register_callback
+
+from .classifier import classify
+
+
+def _response_text(result: Any) -> str | None:
+    if result is None:
+        return None
+    output = getattr(result, "output", result)
+    return output if isinstance(output, str) else None
+
+
+async def _on_interactive_turn_end(
+    agent: Any,
+    prompt: str,
+    result: Any = None,
+    *,
+    success: bool = True,
+    error: BaseException | None = None,
+) -> dict[str, str] | None:
+    """Ask the classifier whether the completed response should be continued."""
+    response = _response_text(result)
+    if not success or error is not None or not response:
+        return None
+
+    approval = await classify(response)
+    if approval is None:
+        return None
+    return {"prompt": approval}
+
+
+register_callback("interactive_turn_end", _on_interactive_turn_end)
+
+
+__all__ = ["_on_interactive_turn_end"]

{code_puppy_core_plugins-0.0.30 → code_puppy_core_plugins-0.0.32}/code_puppy_core_plugins/plugin_list/register_callbacks.py

@@ -23,28 +23,59 @@ from code_puppy.callbacks import register_callback
 
 logger = logging.getLogger(__name__)
 
-
-def _format_plugin_list(names: list[str], disabled: set[str]) -> str:
-    """Return a bullet list of plugin names with status indicators."""
+_CONTRIB_LABELS = [
+    ("tools", "Tools"),
+    ("commands", "Commands"),
+    ("agents", "Agents"),
+    ("skills", "Skills"),
+    ("model_types", "Model Types"),
+    ("model_providers", "Providers"),
+    ("mcp_servers", "MCP Servers"),
+    ("browser_types", "Browsers"),
+    ("agent_tools", "Agent Tools"),
+]
+
+
+def _format_plugin_list(names: list[str], tier: str, disabled: set[str]) -> str:
+    """Return a detailed listing for plugins in *tier*."""
     if not names:
         return "  (none)"
-    lines = []
+    from code_puppy_core_plugins.plugin_list import plugin_contributions, plugin_meta
+
+    lines: list[str] = []
     for name in sorted(names):
-        if name in disabled:
-            lines.append(f"   {name}  (disabled)")
-        else:
-            lines.append(f"   {name}")
+        is_disabled = name in disabled
+        status_suffix = "  (disabled)" if is_disabled else ""
+        lines.append(f"  {name}{status_suffix}")
+
+        description = plugin_meta.get_description(name, tier)
+        if description:
+            lines.append(f"    {description}")
+
+        try:
+            contributions = plugin_contributions.get_contributions(name)
+        except Exception:
+            contributions = {}
+        contrib_parts: list[str] = []
+        for key, label in _CONTRIB_LABELS:
+            items = contributions.get(key)
+            if items:
+                contrib_parts.append(f"{label}: {', '.join(str(i) for i in items)}")
+        if contrib_parts:
+            lines.append(f"    Contributes: {' | '.join(contrib_parts)}")
+
+        hooks = plugin_meta.get_hooks(name)
+        if hooks:
+            lines.append(f"    Hooks: {', '.join(hooks)}")
+
+        path = plugin_meta.get_file_path(name, tier)
+        if path:
+            lines.append(f"    Path: {path}")
+
+        lines.append("")
     return "\n".join(lines)
 
 
-_PROJECT_STATUS_LABELS = {
-    "untrusted": "(not enabled -- review & enable in the /plugins TUI)",
-    "changed": "(changed since accepted -- re-review in the /plugins TUI)",
-    "disabled": "(disabled)",
-    "error": "(failed to load -- see logs)",
-}
-
-
 def _format_project_plugin_list(
     loaded_names: list[str],
     statuses: dict[str, str],
@@ -55,17 +86,48 @@ def _format_project_plugin_list(
     Project plugins are disabled by default; unlike other tiers we also
     show plugins that were discovered but NOT imported, with the reason.
     """
+    from code_puppy_core_plugins.plugin_list import plugin_contributions, plugin_meta
+
+    _PROJECT_STATUS_LABELS = {
+        "untrusted": "(not enabled -- review & enable in /plugins TUI)",
+        "changed": "(changed since accepted -- re-review in /plugins TUI)",
+        "disabled": "(disabled)",
+        "error": "(failed to load -- see logs)",
+    }
     names = sorted(set(loaded_names) | set(statuses))
     if not names:
         return "  (none)"
-    lines = []
+    lines: list[str] = []
     for name in names:
         status = statuses.get(name, "loaded" if name in loaded_names else "untrusted")
         if status == "loaded":
             suffix = "  (disabled)" if name in disabled else ""
         else:
             suffix = "  " + _PROJECT_STATUS_LABELS.get(status, f"({status})")
-        lines.append(f"   {name}{suffix}")
+        lines.append(f"  {name}{suffix}")
+
+        if status == "loaded":
+            description = plugin_meta.get_description(name, "project")
+            if description:
+                lines.append(f"    {description}")
+
+            try:
+                contributions = plugin_contributions.get_contributions(name)
+            except Exception:
+                contributions = {}
+            contrib_parts: list[str] = []
+            for key, label in _CONTRIB_LABELS:
+                items = contributions.get(key)
+                if items:
+                    contrib_parts.append(f"{label}: {', '.join(str(i) for i in items)}")
+            if contrib_parts:
+                lines.append(f"    Contributes: {' | '.join(contrib_parts)}")
+
+            hooks = plugin_meta.get_hooks(name)
+            if hooks:
+                lines.append(f"    Hooks: {', '.join(hooks)}")
+
+        lines.append("")
     return "\n".join(lines)
 
 
@@ -95,10 +157,10 @@ def _build_output() -> str:
         "Loaded Plugins",
         "",
         f"Builtin ({builtin_path}):",
-        _format_plugin_list(loaded["builtin"], disabled),
+        _format_plugin_list(loaded["builtin"], "builtin", disabled),
         "",
         f"User ({user_path}):",
-        _format_plugin_list(loaded["user"], disabled),
+        _format_plugin_list(loaded["user"], "user", disabled),
         "",
         f"Project ({project_path}):",
         _format_project_plugin_list(loaded["project"], project_status, disabled),

{code_puppy_core_plugins-0.0.30 → code_puppy_core_plugins-0.0.32}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy-core-plugins"
-version = "0.0.30"
+version = "0.0.32"
 description = "Official plugin bundle for Code Puppy"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"
@@ -33,6 +33,7 @@ agent_skills = "code_puppy_core_plugins.agent_skills.register_callbacks"
 agent_creator_skill = "code_puppy_core_plugins.agent_creator_skill.register_callbacks"
 aws_bedrock = "code_puppy_core_plugins.aws_bedrock.register_callbacks"
 azure_foundry = "code_puppy_core_plugins.azure_foundry.register_callbacks"
+auto_continue = "code_puppy_core_plugins.auto_continue.register_callbacks"
 btw = "code_puppy_core_plugins.btw.register_callbacks"
 chatgpt_oauth = "code_puppy_core_plugins.chatgpt_oauth.register_callbacks"
 claude_code_hooks = "code_puppy_core_plugins.claude_code_hooks.register_callbacks"