code-puppy-core-plugins 0.0.29__tar.gz → 0.0.31__tar.gz

{code_puppy_core_plugins-0.0.29 → code_puppy_core_plugins-0.0.31}/PKG-INFO

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

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

code_puppy_core_plugins-0.0.31/code_puppy_core_plugins/auto_continue/agent.py

@@ -0,0 +1,38 @@
+"""The deliberately tiny continuation classifier agent."""
+
+from code_puppy.agents.base_agent import BaseAgent
+
+
+class AutoContinueAgent(BaseAgent):
+    """Decide whether a completed response merely needs permission to continue."""
+
+    @property
+    def name(self) -> str:
+        return "auto-continue"
+
+    @property
+    def display_name(self) -> str:
+        return "Auto Continue "
+
+    @property
+    def description(self) -> str:
+        return "Approves routine requests to continue an already requested task"
+
+    def get_available_tools(self) -> list[str]:
+        return []
+
+    def get_system_prompt(self) -> str:
+        return """You classify whether an assistant is merely waiting for permission to
+continue routine work the user already requested.
+
+Reply with exactly one of these strings and nothing else:
+- yes, go.
+- continue
+- okay
+- NO
+
+Approve only a clear request to continue, proceed, or perform an explicitly
+described next step within the existing task. Use NO for destructive or risky
+actions, credential or payment requests, ambiguous choices, requests for new
+requirements, completed work, or anything needing a real human decision.
+Never use tools and never explain your answer."""

code_puppy_core_plugins-0.0.31/code_puppy_core_plugins/auto_continue/register_callbacks.py

@@ -0,0 +1,57 @@
+"""Register automatic continuation after routine permission requests."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from code_puppy.callbacks import register_callback
+
+from .agent import AutoContinueAgent
+
+_AGENT_NAME = "auto-continue"
+_APPROVALS = {"yes, go.", "continue", "okay"}
+
+
+def _register_agents() -> list[dict[str, object]]:
+    return [{"name": _AGENT_NAME, "class": AutoContinueAgent}]
+
+
+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
+
+    from code_puppy.tools.subagent_invocation import _invoke_agent_impl
+
+    verdict = await _invoke_agent_impl(
+        context=None,
+        agent_name=_AGENT_NAME,
+        prompt=f"Classify this assistant response:\n\n{response}",
+        emit_response_message=False,
+    )
+    approval = (verdict.response or "").strip().lower()
+    if approval not in _APPROVALS:
+        return None
+    return {"prompt": approval}
+
+
+register_callback("register_agents", _register_agents)
+register_callback("interactive_turn_end", _on_interactive_turn_end)
+
+
+__all__ = ["_on_interactive_turn_end", "_register_agents"]

{code_puppy_core_plugins-0.0.29 → code_puppy_core_plugins-0.0.31}/code_puppy_core_plugins/fork/register_callbacks.py

@@ -33,10 +33,11 @@ includes forked runs — cancelling the agent takes forks down with it.
 from __future__ import annotations
 
 import asyncio
+import inspect
 import itertools
 import time
 from dataclasses import dataclass, field
-from typing import Dict, List, Optional, Tuple
+from typing import Any, Callable, Dict, List, Optional, Tuple
 
 from code_puppy.callbacks import register_callback
 
@@ -220,6 +221,27 @@ def _seed_fork_session(agent_name: str, prompt: str) -> Optional[str]:
         return None
 
 
+def _invoke_impl_supports_is_fork(impl: Callable[..., Any]) -> bool:
+    """Feature-detect the optional ``is_fork`` kwarg on ``_invoke_agent_impl``.
+
+    ``/fork`` calls that core-private function directly (no stable public
+    hook exists for this), so core and this plugin can drift independently
+    in either direction. An older core build won't accept ``is_fork`` at
+    all -- passing it unconditionally would raise ``TypeError`` and take
+    ``/fork`` down entirely. Detect support at call time instead of pinning
+    a version.
+
+    ``inspect.signature`` itself can raise (``TypeError``/``ValueError``) for
+    a handful of non-introspectable callables (e.g. some C builtins); core's
+    ``_invoke_agent_impl`` is always a plain ``async def`` so this never fires
+    in practice, but fail closed (assume unsupported) rather than crash.
+    """
+    try:
+        return "is_fork" in inspect.signature(impl).parameters
+    except (TypeError, ValueError):
+        return False
+
+
 async def _run_fork(
     agent_name: str,
     prompt: str,
@@ -232,16 +254,19 @@ async def _run_fork(
 
     started_at = time.monotonic()
     result = None
-    try:
+    invoke_kwargs = dict(
         # ``context`` is unused by the implementation; forks have no RunContext.
-        result = await _invoke_agent_impl(
-            context=None,
-            agent_name=agent_name,
-            prompt=prompt,
-            session_id=session_id,
-            model_name=model_name,
-            emit_response_message=False,
-        )
+        context=None,
+        agent_name=agent_name,
+        prompt=prompt,
+        session_id=session_id,
+        model_name=model_name,
+        emit_response_message=False,
+    )
+    if _invoke_impl_supports_is_fork(_invoke_agent_impl):
+        invoke_kwargs["is_fork"] = True
+    try:
+        result = await _invoke_agent_impl(**invoke_kwargs)
         return result
     finally:
         # /fork calls the shared implementation directly (not via pydantic-ai's tool

{code_puppy_core_plugins-0.0.29 → code_puppy_core_plugins-0.0.31}/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.29 → code_puppy_core_plugins-0.0.31}/code_puppy_core_plugins/subagent_panel/panel_render.py

@@ -77,7 +77,8 @@ def _row_lines(ordered, frame):
     right block over together -- columns stay aligned no matter what gets added.
     Alignment is done purely with U+0020 spaces (never literal tabs), and widths
     use Rich cell_len, so the layout renders identically on Windows and macOS.
-    Root rows carry the INVOKE AGENT badge; nested rows carry the tree elbow.
+    Root rows carry the INVOKE AGENT badge (or FORK, for /fork-started runs);
+    nested rows carry the tree elbow.
     Used for BOTH the live block and the transcript.
     """
     from rich.cells import cell_len
@@ -91,7 +92,10 @@ def _row_lines(ordered, frame):
     for e, depth in ordered:
         left = Text(no_wrap=True, overflow="ellipsis")
         if depth == 0:
-            left.append(" \U0001f916 INVOKE AGENT ", style=f"bold white on {color}")
+            if e.get("is_fork"):
+                left.append(" \U0001f374 FORK ", style=f"bold white on {color}")
+            else:
+                left.append(" \U0001f916 INVOKE AGENT ", style=f"bold white on {color}")
             left.append(" ")
             left.append(e["name"], style="bold cyan")
         else:

{code_puppy_core_plugins-0.0.29 → code_puppy_core_plugins-0.0.31}/code_puppy_core_plugins/subagent_panel/register_callbacks.py

@@ -301,7 +301,16 @@ def _install_emit_hook() -> None:
                 model = _resolve_model(
                     message.agent_name, getattr(message, "model_name", None)
                 )
-                state.register(message.session_id, message.agent_name, model, parent)
+                # ``is_fork`` is core-optional (added after this plugin existed);
+                # default False keeps old-core rows rendering exactly as before.
+                is_fork = getattr(message, "is_fork", False)
+                state.register(
+                    message.session_id,
+                    message.agent_name,
+                    model,
+                    parent=parent,
+                    is_fork=is_fork,
+                )
                 _push_panel(force=True)
                 _start_ticker()  # keeps mm:ss advancing through silence
         except Exception:

{code_puppy_core_plugins-0.0.29 → code_puppy_core_plugins-0.0.31}/code_puppy_core_plugins/subagent_panel/state.py

@@ -47,6 +47,7 @@ def register(
     name: str,
     model: Optional[str] = None,
     parent: Optional[str] = None,
+    is_fork: bool = False,
 ) -> None:
     if not session_id:
         return
@@ -59,6 +60,7 @@ def register(
             "parent": parent,
             "name": name,
             "model": model,
+            "is_fork": is_fork,
             "status": "starting",
             "start": existing["start"] if existing else now,
             "last_seen": now,

{code_puppy_core_plugins-0.0.29 → code_puppy_core_plugins-0.0.31}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy-core-plugins"
-version = "0.0.29"
+version = "0.0.31"
 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"