code-puppy-core-plugins 0.0.2__py3-none-any.whl

code_puppy_core_plugins/wide_completion_menu/register_callbacks.py

@@ -0,0 +1,165 @@
+"""Register callbacks for the ``wide_completion_menu`` plugin.
+
+Hooks:
+
+* ``startup`` — monkey-patches prompt_toolkit's completion menu width so the
+  scrollbar anchors to the right edge of the terminal rather than the right
+  edge of the menu content.
+* ``custom_command`` / ``custom_command_help`` — exposes ``/widemenu`` to
+  toggle the effect at runtime without restarting the app.
+
+Design notes
+------------
+prompt_toolkit's :class:`CompletionsMenuControl.preferred_width` returns
+``menu_width + menu_meta_width`` based on the longest completion, so the
+menu is content-sized and the scrollbar lives wherever that content ends.
+We replace ``preferred_width`` with a version that returns
+``max_available_width``, causing the parent ``Window`` to stretch the menu
+across the full row. Combined with the existing ``_left_justify_completion_menu``
+that pins the menu's ``Float`` to column 0, the scrollbar lands flush against
+the right edge of the screen.
+
+The patch is:
+
+* **Idempotent** — re-installing is a no-op (sentinel attribute).
+* **Reversible** — original methods are stashed and restored on disable.
+* **Defensive** — every patch step is wrapped in try/except so a
+  prompt_toolkit version bump cannot crash the prompt.
+"""
+
+from __future__ import annotations
+
+from typing import List, Tuple
+
+from code_puppy.callbacks import register_callback
+
+_COMMAND_NAME = "widemenu"
+_PATCH_FLAG = "_wide_completion_menu_patched"
+_ORIGINAL_ATTR = "_wide_completion_menu_original_preferred_width"
+
+# Module state lets /widemenu toggle without uninstalling; disabled mode delegates
+# ``preferred_width`` to upstream.
+_state = {"enabled": True}
+
+
+# Messaging helpers (lazy-imported to avoid boot-time cycles)
+def _emit_info(message: str) -> None:
+    from code_puppy.messaging import emit_info
+
+    emit_info(message)
+
+
+def _emit_error(message: str) -> None:
+    from code_puppy.messaging import emit_error
+
+    emit_error(message)
+
+
+# Patching
+def _patch_menu_class(cls) -> None:
+    """Replace ``cls.preferred_width`` with a screen-filling variant.
+
+    Stores the original method on the class under ``_ORIGINAL_ATTR`` so we
+    can both delegate to it (when toggled off) and restore it cleanly.
+    """
+    if getattr(cls, _PATCH_FLAG, False):
+        return  # Already patched.
+
+    original = cls.preferred_width
+    setattr(cls, _ORIGINAL_ATTR, original)
+
+    def patched_preferred_width(self, max_available_width: int):
+        # When toggled off, behave exactly like upstream.
+        if not _state["enabled"]:
+            return original(self, max_available_width)
+
+        # Stretch only when a completion menu exists; upstream returns 0 when empty.
+        try:
+            from prompt_toolkit.application.current import get_app
+
+            complete_state = get_app().current_buffer.complete_state
+        except Exception:
+            complete_state = None
+
+        if not complete_state:
+            return 0
+        return max_available_width
+
+    cls.preferred_width = patched_preferred_width
+    setattr(cls, _PATCH_FLAG, True)
+
+
+def _install_patch() -> None:
+    """Patch both single- and multi-column completion menu controls."""
+    from prompt_toolkit.layout.menus import (
+        CompletionsMenuControl,
+        MultiColumnCompletionMenuControl,
+    )
+
+    _patch_menu_class(CompletionsMenuControl)
+    _patch_menu_class(MultiColumnCompletionMenuControl)
+
+
+def _on_startup() -> None:
+    try:
+        _install_patch()
+    except Exception as exc:
+        # Plugin rule #4: fail gracefully — never crash the app.
+        _emit_error(f"wide_completion_menu: failed to install patch — {exc}")
+
+
+# /widemenu slash command
+_USAGE = "Usage: /widemenu [on|off|toggle|status]"
+
+
+def _custom_help() -> List[Tuple[str, str]]:
+    return [
+        (
+            _COMMAND_NAME,
+            "Toggle full-width completion menu (scrollbar pinned to screen edge)",
+        )
+    ]
+
+
+def _handle_widemenu_command(command: str) -> bool:
+    # `command` is the full line, e.g. "/widemenu on". Strip the slash + name.
+    parts = command.strip().split()
+    arg = parts[1].lower() if len(parts) >= 2 else "status"
+
+    if arg in ("on", "enable", "true", "1"):
+        _state["enabled"] = True
+        _emit_info("🐶 widemenu: ON — scrollbar pinned to right edge of screen.")
+    elif arg in ("off", "disable", "false", "0"):
+        _state["enabled"] = False
+        _emit_info("🐶 widemenu: OFF — menu sized to content (default).")
+    elif arg in ("toggle", "t"):
+        _state["enabled"] = not _state["enabled"]
+        status = "ON" if _state["enabled"] else "OFF"
+        _emit_info(f"🐶 widemenu: {status}")
+    elif arg == "status":
+        status = "ON" if _state["enabled"] else "OFF"
+        _emit_info(f"🐶 widemenu is currently {status}. {_USAGE}")
+    else:
+        _emit_info(_USAGE)
+    return True
+
+
+def _handle_custom_command(command: str, name: str):
+    if name != _COMMAND_NAME:
+        return None
+    return _handle_widemenu_command(command)
+
+
+# Registration
+register_callback("startup", _on_startup)
+register_callback("custom_command", _handle_custom_command)
+register_callback("custom_command_help", _custom_help)
+
+
+__all__ = [
+    "_handle_custom_command",
+    "_handle_widemenu_command",
+    "_install_patch",
+    "_on_startup",
+    "_patch_menu_class",
+]

code_puppy_core_plugins/wiggum/__init__.py

@@ -0,0 +1 @@
+"""Wiggum looping plugin."""

code_puppy_core_plugins/wiggum/goal_runs.py

@@ -0,0 +1,91 @@
+"""Durable records for resumable ``/goal`` runs."""
+
+from __future__ import annotations
+
+import json
+import os
+import uuid
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+from code_puppy.config import STATE_DIR
+
+_RUNS_DIR = Path(STATE_DIR) / "goal_runs"
+
+
+@dataclass(frozen=True)
+class GoalRun:
+    """The minimum state required to continue an interrupted goal."""
+
+    run_id: str
+    prompt: str
+    loop_count: int = 0
+    remediation_notes: str | None = None
+    status: str = "active"
+
+
+def create(prompt: str) -> GoalRun:
+    """Create and persist a new goal run."""
+    run = GoalRun(run_id=str(uuid.uuid4()), prompt=prompt)
+    save(run)
+    return run
+
+
+def save(run: GoalRun) -> None:
+    """Atomically persist a goal run."""
+    _RUNS_DIR.mkdir(parents=True, exist_ok=True)
+    destination = _path(run.run_id)
+    temporary = destination.with_suffix(f".tmp-{os.getpid()}")
+    temporary.write_text(json.dumps(asdict(run), indent=2), encoding="utf-8")
+    temporary.replace(destination)
+
+
+def load(run_id: str) -> GoalRun | None:
+    """Load a run by UUID, returning ``None`` for invalid or missing IDs."""
+    normalized = _normalize_uuid(run_id)
+    if normalized is None:
+        return None
+    try:
+        payload = json.loads(_path(normalized).read_text(encoding="utf-8"))
+        return GoalRun(
+            run_id=normalized,
+            prompt=str(payload["prompt"]),
+            loop_count=max(0, int(payload.get("loop_count", 0))),
+            remediation_notes=payload.get("remediation_notes"),
+            status=str(payload.get("status", "active")),
+        )
+    except (OSError, ValueError, TypeError, KeyError, json.JSONDecodeError):
+        return None
+
+
+def update(
+    run_id: str,
+    *,
+    loop_count: int,
+    remediation_notes: str | None,
+    status: str = "active",
+) -> None:
+    """Update mutable progress fields when the run still exists."""
+    run = load(run_id)
+    if run is None:
+        return
+    save(
+        GoalRun(
+            run_id=run.run_id,
+            prompt=run.prompt,
+            loop_count=loop_count,
+            remediation_notes=remediation_notes,
+            status=status,
+        )
+    )
+
+
+def _path(run_id: str) -> Path:
+    return _RUNS_DIR / f"{run_id}.json"
+
+
+def _normalize_uuid(value: str) -> str | None:
+    try:
+        return str(uuid.UUID(value.strip()))
+    except (AttributeError, ValueError):
+        return None

code_puppy_core_plugins/wiggum/judge.py

@@ -0,0 +1,299 @@
+"""LLM judge helpers for goal mode.
+
+A judge is a small, read-only pydantic_ai Agent that examines the
+implementor's latest response (and optionally its message history) and
+returns a structured verdict: complete/not + remediation notes.
+
+Each judge has its own model and prompt — see ``judge_config.py`` for
+persistence. The /goal loop fans these out in parallel; see
+``register_callbacks._run_goal_judges``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from dataclasses import dataclass
+from typing import Any
+
+from pydantic import BaseModel, Field
+from pydantic_ai import Agent, RunContext, ToolOutput, UsageLimits
+
+from code_puppy.agents._history import stringify_part
+from code_puppy.agents.agent_manager import load_agent
+from code_puppy.model_factory import ModelFactory, make_model_settings
+from code_puppy.model_utils import prepare_prompt_for_model
+from code_puppy.tools.subagent_context import subagent_context
+
+from .judge_config import DEFAULT_JUDGE_PROMPT, JudgeConfig
+
+# Read-only judges should not need 200 requests; cap verification-heavy loops
+# without letting a runaway judge consume the goal loop's budget.
+GOAL_JUDGE_REQUEST_LIMIT = 200
+
+_READ_ONLY_TOOLS = {
+    "list_files",
+    "read_file",
+    "grep",
+    "agent_run_shell_command",
+    "load_image_for_analysis",
+    "list_agents",
+    "invoke_agent",
+}
+
+
+class GoalJudgeOutput(BaseModel):
+    """Structured verdict from a goal judge."""
+
+    complete: bool = Field(
+        description="True only when the goal is verifiably complete."
+    )
+    notes: str = Field(
+        description="Brief rationale plus remediation notes if incomplete."
+    )
+
+
+@dataclass(frozen=True)
+class GoalJudgement:
+    """Final, normalized verdict surfaced to /goal callers.
+
+    ``abstained`` means the judge couldn't produce a verdict for an
+    infrastructure reason — model endpoint 404, auth failure, network
+    timeout, misconfigured model, etc. Abstaining judges are excluded
+    from the all-complete tally; they neither pass nor fail the goal.
+    """
+
+    judge_name: str
+    complete: bool
+    notes: str
+    raw_response: str
+    abstained: bool = False
+
+
+def _read_only_tools_for_implementor(agent_config: Any) -> list[str]:
+    return [
+        tool for tool in agent_config.get_available_tools() if tool in _READ_ONLY_TOOLS
+    ]
+
+
+def _format_message(message: Any, index: int) -> str:
+    part_lines = [stringify_part(part) for part in getattr(message, "parts", [])]
+    text = "\n".join(line for line in part_lines if line)
+    return f"[{index}] {message.__class__.__name__}:\n{text or '(empty message)'}"
+
+
+def _format_history_window(
+    messages: list[Any],
+    *,
+    query: str | None = None,
+    limit: int = 20,
+    max_chars: int = 12000,
+) -> str:
+    if not messages:
+        return "(no implementor message history captured)"
+
+    normalized_query = (query or "").strip().lower()
+    indexed = list(enumerate(messages))
+    if normalized_query:
+        indexed = [
+            (idx, msg)
+            for idx, msg in indexed
+            if normalized_query
+            in "\n".join(
+                stringify_part(part) for part in getattr(msg, "parts", [])
+            ).lower()
+        ]
+
+    selected = indexed[-max(1, min(limit, 100)) :]
+    chunks: list[str] = []
+    total = 0
+    for idx, message in selected:
+        block = _format_message(message, idx)
+        if total + len(block) > max_chars:
+            remaining = max_chars - total
+            if remaining > 500:
+                chunks.append(block[:remaining])
+            break
+        chunks.append(block)
+        total += len(block)
+
+    if not chunks:
+        return "(no matching implementor history messages)"
+    return "\n\n---\n\n".join(chunks)
+
+
+def _register_goal_history_tool(judge_agent: Agent, messages: list[Any]) -> None:
+    @judge_agent.tool
+    async def inspect_goal_history(
+        context: RunContext[None],
+        query: str | None = None,
+        limit: int = 20,
+    ) -> str:
+        """Inspect the /goal implementor's read-only message history.
+
+        Args:
+            query: Optional case-insensitive substring to search for in message parts.
+            limit: Maximum number of recent matching messages to return, capped at 100.
+        """
+        del context
+        return _format_history_window(messages, query=query, limit=limit)
+
+
+def _strip_thinking_settings(model_settings: dict) -> None:
+    """Remove thinking-related settings that conflict with ToolOutput.
+
+    Anthropic models reject thinking + tool output at the same time, and other
+    providers don't mind missing keys. We strip:
+      * `anthropic_thinking` (Anthropic / Bedrock / Azure Foundry Claude / claude_code)
+      * `thinking` (GLM-4.7 / GLM-5 style)
+      * `thinking_enabled` / `thinking_level` (Gemini)
+      * `extra_body.output_config` (effort knob that only matters with adaptive thinking)
+    """
+    for key in ("anthropic_thinking", "thinking", "thinking_enabled", "thinking_level"):
+        model_settings.pop(key, None)
+
+    extra_body = model_settings.get("extra_body")
+    if isinstance(extra_body, dict):
+        extra_body.pop("output_config", None)
+        if not extra_body:
+            model_settings.pop("extra_body", None)
+
+
+def _judge_user_prompt(
+    goal: str,
+    response: str | None,
+    error: BaseException | None,
+) -> str:
+    error_text = f"\nRUN ERROR:\n{error}\n" if error else ""
+    response_text = response or "(no response captured)"
+    return f"""\
+Judge whether this coding goal is verifiably complete.
+
+GOAL:
+{goal}
+
+LATEST AGENT RESPONSE:
+{response_text}
+{error_text}
+You have a read-only `inspect_goal_history` tool for the /goal implementor's transcript.
+Use it when the latest response is not enough to confidently judge completion.
+"""
+
+
+async def judge_goal(
+    *,
+    judge_config: JudgeConfig,
+    implementor_agent: Any,
+    goal: str,
+    response: str | None,
+    error: BaseException | None,
+    history: list[Any] | None = None,
+) -> GoalJudgement:
+    """Run a single fresh, read-only judge against the implementor's latest turn.
+
+    Args:
+        judge_config: The judge's persisted configuration (name, model, prompt).
+        implementor_agent: The /goal implementor's agent — used only to discover
+            which read-only tools should be available to the judge.
+        goal: The original /goal prompt.
+        response: The implementor's most recent textual response (or None).
+        error: Any exception raised on the implementor's latest turn.
+        history: The implementor's message history (read-only).
+    """
+    from code_puppy import plugins
+
+    plugins.load_plugin_callbacks()
+
+    model_name = judge_config.model
+    models_config = ModelFactory.load_config()
+    if model_name not in models_config:
+        # Misconfigured model is an infrastructure issue, not a real
+        # judgement — abstain so we don't block /goal on it.
+        return GoalJudgement(
+            judge_name=judge_config.name,
+            complete=False,
+            notes=(f"model {model_name!r} not present in the model config"),
+            raw_response="",
+            abstained=True,
+        )
+
+    model = ModelFactory.get_model(model_name, models_config)
+    judge_instructions = judge_config.prompt or DEFAULT_JUDGE_PROMPT
+    user_prompt = _judge_user_prompt(goal, response, error)
+    prepared = prepare_prompt_for_model(
+        model_name,
+        judge_instructions,
+        user_prompt,
+        prepend_system_to_user=True,
+    )
+
+    model_settings = make_model_settings(model_name)
+    _strip_thinking_settings(model_settings)
+
+    judge_agent = Agent(
+        model=model,
+        instructions=prepared.instructions,
+        output_type=ToolOutput(
+            GoalJudgeOutput,
+            name="goal_judgement",
+            description="Verdict for the /goal implementor's latest iteration.",
+        ),
+        retries=3,
+        model_settings=model_settings,
+    )
+
+    # Give the judge the same read-only tools the implementor has, so it can
+    # poke at files/run tests/etc to verify completion.
+    from code_puppy.tools import register_tools_for_agent
+
+    try:
+        implementor_config = load_agent(implementor_agent.name)
+        read_only_tools = _read_only_tools_for_implementor(implementor_config)
+    except Exception:
+        read_only_tools = []
+
+    register_tools_for_agent(
+        judge_agent,
+        read_only_tools,
+        model_name=model_name,
+    )
+    _register_goal_history_tool(judge_agent, list(history or []))
+
+    # Run judges as sub-agents to suppress tool/reasoning chatter; rich_renderer
+    # and tools/display already skip those banners in sub-agent context.
+    try:
+        with subagent_context(f"judge:{judge_config.name}"):
+            result = await judge_agent.run(
+                prepared.user_prompt,
+                usage_limits=UsageLimits(request_limit=GOAL_JUDGE_REQUEST_LIMIT),
+            )
+        output = result.output
+    except (asyncio.CancelledError, KeyboardInterrupt):
+        # Propagate cancellation — the orchestrator handles cleanup.
+        raise
+    except Exception as exc:
+        # Infrastructure errors abstain rather than vote; the judge produced no
+        # verdict to fail the goal.
+        return GoalJudgement(
+            judge_name=judge_config.name,
+            complete=False,
+            notes=f"endpoint error ({type(exc).__name__}): {exc}",
+            raw_response="",
+            abstained=True,
+        )
+
+    if hasattr(output, "model_dump_json"):
+        raw = output.model_dump_json()
+        complete = output.complete
+        notes = output.notes
+    else:
+        raw = json.dumps(output)
+        complete = bool(output.get("complete"))
+        notes = str(output.get("notes", ""))
+
+    return GoalJudgement(
+        judge_name=judge_config.name,
+        complete=complete,
+        notes=notes,
+        raw_response=raw,
+    )