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

code_puppy_core_plugins/wiggum/register_callbacks.py

@@ -0,0 +1,569 @@
+"""Register the Wiggum looping slash commands and goal continuation policy."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+from code_puppy.callbacks import register_callback
+from code_puppy.command_line.command_registry import register_command
+from code_puppy.config import get_value
+from code_puppy.messaging import (
+    emit_info,
+    emit_success,
+    emit_system_message,
+    emit_warning,
+)
+
+from . import goal_runs, state
+from .judge import GoalJudgement, judge_goal
+from .judge_config import JudgeConfig, get_enabled_judges_or_default, load_judges
+
+# /goal iterations default to 10; /set goal_max_iterations overrides, clamped to
+# [1, 1000].
+GOAL_MAX_ITERATIONS_DEFAULT = 10
+GOAL_MAX_ITERATIONS_FLOOR = 1
+GOAL_MAX_ITERATIONS_CEILING = 1000
+
+
+def _get_goal_max_iterations() -> int:
+    """Read the configured /goal iteration cap, with sane fallbacks."""
+    val = get_value("goal_max_iterations")
+    try:
+        n = int(val) if val else GOAL_MAX_ITERATIONS_DEFAULT
+    except (ValueError, TypeError):
+        n = GOAL_MAX_ITERATIONS_DEFAULT
+    return max(GOAL_MAX_ITERATIONS_FLOOR, min(n, GOAL_MAX_ITERATIONS_CEILING))
+
+
+# Slash commands
+
+
+@register_command(
+    name="wiggum",
+    description="Loop mode: re-run the same prompt when agent finishes 🍩",
+    usage="/wiggum <prompt>",
+    category="plugin",
+)
+def handle_wiggum_command(command: str) -> str | bool:
+    """Start Wiggum loop mode and execute the prompt immediately."""
+    prompt = _extract_prompt(command)
+    if not prompt:
+        emit_warning("Usage: /wiggum <prompt>")
+        emit_info("Example: /wiggum say hello world")
+        emit_info("Press Ctrl+C or run /wiggum_stop to stop the loop.")
+        return True
+
+    state.start(prompt, mode="wiggum")
+    emit_success("🍩 WIGGUM MODE ACTIVATED!")
+    emit_info(f"Prompt: {prompt}")
+    emit_info("The agent will re-loop this prompt after each completion.")
+    emit_info("Press Ctrl+C or run /wiggum_stop to stop the loop.")
+    return prompt
+
+
+@register_command(
+    name="goal",
+    description="Retry a task until all LLM judges say it is complete 🎯",
+    usage="/goal <prompt> | /goal resume <UUID>",
+    # /kibble and /chow are puppy-themed aliases for /goal — same behavior,
+    # just more on-brand for a code puppy.
+    aliases=["kibble", "chow"],
+    category="plugin",
+)
+def handle_goal_command(command: str) -> str | bool:
+    """Start goal mode and execute the prompt immediately."""
+    prompt = _extract_prompt(command)
+    if not prompt:
+        emit_warning(
+            "Usage: /goal <prompt> | /goal resume <UUID>  (aliases: /kibble, /chow)"
+        )
+        emit_info("Example: /goal make tests pass for the auth flow")
+        emit_info("Press Ctrl+C or run /goal_stop to stop the loop.")
+        return True
+
+    if prompt.lower().startswith("resume"):
+        return _resume_goal(prompt)
+
+    run = goal_runs.create(prompt)
+    state.start(prompt, mode="goal", run_id=run.run_id)
+    _display_banner_message(
+        "GOAL MODE", "\U0001f3af ACTIVATED!", banner_name="llm_judge"
+    )
+    emit_info(f"Goal: {prompt}")
+    emit_info(f"Goal UUID: {run.run_id}")
+    emit_info(
+        "After each iteration, every enabled LLM judge will verify completion in parallel."
+    )
+    emit_info(
+        f"Max iterations: {_get_goal_max_iterations()} "
+        f"(change with /set goal_max_iterations=<int>)"
+    )
+    _emit_configured_judges_summary()
+    return prompt
+
+
+@register_command(
+    name="wiggum_stop",
+    description="Stop Wiggum/goal loop mode",
+    usage="/wiggum_stop",
+    aliases=["stopwiggum", "ws", "goal_stop"],
+    category="plugin",
+)
+def handle_wiggum_stop_command(command: str) -> bool:
+    """Stop Wiggum/goal loop mode."""
+    del command
+    if state.is_active():
+        run_id = state.get_state().run_id
+        _persist_goal_progress(status="interrupted")
+        state.stop()
+        emit_success("\U0001f369 Wiggum/goal mode stopped!")
+        if run_id:
+            emit_info(f"Resume it with: /goal resume {run_id}")
+    else:
+        emit_info("Wiggum/goal mode is not active.")
+    return True
+
+
+@register_command(
+    name="judges",
+    description="Configure goal-mode LLM judges (TUI) ⚖️",
+    usage="/judges",
+    category="plugin",
+)
+def handle_judges_command(command: str) -> bool:
+    """Open the goal-judges TUI."""
+    del command
+    import concurrent.futures
+
+    from .judges_menu import interactive_judges_menu
+
+    # The menu is async; run it in a fresh event loop on a worker thread so
+    # we don't collide with whatever loop the CLI is using.
+    try:
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            future = executor.submit(lambda: asyncio.run(interactive_judges_menu()))
+            future.result(timeout=600)
+    except concurrent.futures.TimeoutError:
+        emit_warning("Judges menu timed out.")
+    except Exception as exc:
+        emit_warning(f"Judges menu error: {exc}")
+
+    return True
+
+
+# Helpers
+
+
+def _emit_configured_judges_summary() -> None:
+    """Show the user exactly which judges /goal will fan out to.
+
+    Previously we just told users to run /judges, which left people
+    wondering if they'd configured anything at all. Now we list the
+    enabled judges (and warn about disabled ones) so the state of the
+    world is obvious before the loop kicks off.
+    """
+    registry = load_judges()
+    enabled = registry.enabled()
+    disabled = [j for j in registry.judges if not j.enabled]
+
+    if enabled:
+        emit_info(f"Configured judges ({len(enabled)} enabled):")
+        for judge in enabled:
+            emit_info(f"  • {judge.name} ({judge.model})")
+        if disabled:
+            disabled_names = ", ".join(j.name for j in disabled)
+            emit_info(f"  (disabled: {disabled_names})")
+    else:
+        emit_info(
+            "No judges configured — falling back to a single default judge "
+            "using the implementor's model."
+        )
+    emit_info("Run /judges to add, edit, enable, or disable judges.")
+
+
+def _resume_goal(arguments: str) -> str | bool:
+    """Restore a durable goal run and dispatch its next iteration."""
+    parts = arguments.split()
+    if len(parts) != 2 or parts[0].lower() != "resume":
+        emit_warning("Usage: /goal resume <UUID>")
+        return True
+
+    run = goal_runs.load(parts[1])
+    if run is None:
+        emit_warning(f"Goal run not found: {parts[1]}")
+        return True
+    if run.status in {"completed", "stopped"}:
+        emit_warning(f"Goal run {run.run_id} is already {run.status}.")
+        return True
+
+    state.start(
+        run.prompt,
+        mode="goal",
+        run_id=run.run_id,
+        loop_count=run.loop_count,
+        remediation_notes=run.remediation_notes,
+    )
+    goal_runs.update(
+        run.run_id,
+        loop_count=run.loop_count,
+        remediation_notes=run.remediation_notes,
+    )
+    _display_banner_message("GOAL MODE", "\U0001f3af RESUMED!", banner_name="llm_judge")
+    emit_info(f"Goal UUID: {run.run_id}")
+    emit_info(f"Resuming after {run.loop_count} completed iteration(s).")
+    if run.remediation_notes:
+        return f"{run.prompt}\n\nJudge remediation notes:\n{run.remediation_notes}"
+    return run.prompt
+
+
+def _extract_prompt(command: str) -> str:
+    parts = command.split(maxsplit=1)
+    if len(parts) < 2:
+        return ""
+    return parts[1].strip()
+
+
+def _response_text(result: Any) -> str | None:
+    return str(getattr(result, "output", "")) if result is not None else None
+
+
+def _display_banner_message(
+    label: str,
+    message: str,
+    *,
+    banner_name: str,
+    details: str | None = None,
+    final: bool = False,
+) -> None:
+    """Display an inline banner followed by a message.
+
+    Plain sequential output — it scrolls inside the bottom bar's region,
+    so no terminal-ownership dance is needed.
+    """
+    from rich.console import Console
+    from rich.text import Text
+
+    from code_puppy.config import get_banner_color
+    from code_puppy.tools.display import erase_progress_line
+
+    console = Console()
+
+    erase_progress_line(console)
+    console.print()
+    color = get_banner_color(banner_name)
+    banner = Text.from_markup(
+        f"[bold white on {color}] {label} [/bold white on {color}] "
+    )
+    console.print(banner, end="")
+    # markup=False so brackets in the message (e.g. "[joe-brown]") aren't
+    # eaten by Rich's markup parser. Same for `details`.
+    console.print(message, markup=False, highlight=False)
+
+    if details:
+        console.print(details, markup=False, highlight=False)
+    if final:
+        console.print()
+
+
+def _display_llm_judge(
+    message: str, details: str | None = None, *, final: bool = False
+) -> None:
+    """Display goal-judge output with an inline banner."""
+    _display_banner_message(
+        "LLM JUDGE",
+        message,
+        banner_name="llm_judge",
+        details=details,
+        final=final,
+    )
+
+
+def _resolve_judges(implementor_agent: Any) -> list[JudgeConfig]:
+    """Pick the judge set for this /goal iteration.
+
+    If the user has configured judges via ``/judges`` we use those.
+    Otherwise we fall back to a single ``default`` judge that uses the
+    implementor agent's model and the standard goal-judge prompt.
+    """
+    fallback_model = getattr(
+        implementor_agent.get_pydantic_agent().model
+        if hasattr(implementor_agent, "get_pydantic_agent")
+        else None,
+        "model_name",
+        None,
+    )
+    if not fallback_model:
+        # The agent object exposes its model name via get_model_name() in most
+        # places; fall back to that if the pydantic_agent shape differs.
+        try:
+            fallback_model = implementor_agent.get_model_name()
+        except Exception:
+            fallback_model = "code-puppy"
+
+    return get_enabled_judges_or_default(str(fallback_model))
+
+
+def _format_remediation_block(verdicts: list[GoalJudgement]) -> str:
+    """Build the remediation-notes string that feeds the next iteration."""
+    lines: list[str] = []
+    for v in verdicts:
+        if v.abstained:
+            status = "⚠️  ABSTAIN"
+        else:
+            status = "✅ PASS" if v.complete else "❌ FAIL"
+        lines.append(f"[{v.judge_name}] {status}")
+        if v.notes:
+            for note_line in v.notes.strip().splitlines():
+                lines.append(f"  {note_line}")
+        lines.append("")
+    return "\n".join(lines).rstrip()
+
+
+# Judge orchestration (parallel)
+
+
+async def _run_single_judge(
+    judge_config: JudgeConfig,
+    *,
+    implementor_agent: Any,
+    goal: str,
+    response: str | None,
+    error: BaseException | None,
+    history: list[Any],
+) -> GoalJudgement:
+    """Run a single judge. No I/O — callers handle display before/after.
+
+    We intentionally do NOT print here: ``_run_goal_judges`` runs many of
+    these in parallel via ``asyncio.gather``, and concurrent calls into the
+    rich Console (which does \\r line-clearing tricks) interleave and
+    overwrite each other. Display is serialized at the orchestrator level.
+    """
+    try:
+        return await judge_goal(
+            judge_config=judge_config,
+            implementor_agent=implementor_agent,
+            goal=goal,
+            response=response,
+            error=error,
+            history=history,
+        )
+    except (asyncio.CancelledError, KeyboardInterrupt):
+        raise
+    except Exception as exc:
+        # judge_goal handles model errors; unexpected plumbing errors still abstain
+        # so one broken judge cannot block /goal.
+        from code_puppy.error_logging import log_error
+
+        log_error(exc, context=f"Goal judge failed ({judge_config.name})")
+        return GoalJudgement(
+            judge_name=judge_config.name,
+            complete=False,
+            notes=f"judge crashed: {type(exc).__name__}: {exc}",
+            raw_response="",
+            abstained=True,
+        )
+
+
+def _judge_roster_line(judges: list[JudgeConfig]) -> str:
+    """e.g. 'judy (gpt-5.4), joe-brown (claude-sonnet-4.5)'."""
+    return ", ".join(f"{j.name} ({j.model})" for j in judges)
+
+
+async def _run_goal_judges(
+    *,
+    agent: Any,
+    goal: str,
+    result: Any,
+    error: BaseException | None,
+) -> tuple[bool, str, list[GoalJudgement]]:
+    """Run every enabled judge in parallel.
+
+    Returns ``(all_complete, formatted_notes, verdicts)``.
+
+    ``all_complete`` is True when every judge reports ``complete=True``.
+    The judge's own ``complete=True`` IS the "no remediation needed"
+    signal — any rationale notes alongside it are just for visibility and
+    don't block completion.
+    """
+    judges = _resolve_judges(agent)
+    if not judges:
+        return False, "No judge agents configured.", []
+
+    history = list(agent.get_message_history())
+    response_text = _response_text(result)
+
+    # Announce up front so the user knows we're firing N judges in parallel.
+    if len(judges) == 1:
+        _display_llm_judge(
+            f"Asking judge {_judge_roster_line(judges)} if the goal is complete..."
+        )
+    else:
+        _display_llm_judge(
+            f"Running {len(judges)} judges in parallel: {_judge_roster_line(judges)}"
+        )
+
+    try:
+        verdicts: list[GoalJudgement] = await asyncio.gather(
+            *(
+                _run_single_judge(
+                    judge,
+                    implementor_agent=agent,
+                    goal=goal,
+                    response=response_text,
+                    error=error,
+                    history=history,
+                )
+                for judge in judges
+            )
+        )
+    except (asyncio.CancelledError, KeyboardInterrupt):
+        # Show why judges bailed, then re-raise so the caller keeps the REPL alive
+        # and stops the loop; a sentinel would trigger another retry.
+        _display_llm_judge("⛔ Judges cancelled (Ctrl+C). Stopping goal loop.")
+        raise
+
+    # Now serialize the per-judge verdicts so all banners actually show up.
+    for v in verdicts:
+        if v.abstained:
+            glyph = "⚠️  ABSTAIN"
+        else:
+            glyph = "✅ PASS" if v.complete else "❌ FAIL"
+        summary = v.notes.strip().splitlines()[0] if v.notes.strip() else "(no notes)"
+        _display_llm_judge(f"  [{v.judge_name}] {glyph} — {summary}")
+
+    # Abstentions do not vote; completion requires every non-abstaining judge to
+    # pass. If all abstain, report incomplete because completion is undecidable.
+    voting = [v for v in verdicts if not v.abstained]
+    if not voting:
+        all_complete = False
+        if verdicts:
+            _display_llm_judge("⚠️  All judges abstained — cannot determine completion.")
+    else:
+        all_complete = all(v.complete for v in voting)
+
+    notes = _format_remediation_block(verdicts)
+    return all_complete, notes, verdicts
+
+
+# Turn-end hook (drives /goal and /wiggum loops)
+
+
+async def _on_interactive_turn_end(
+    agent: Any,
+    prompt: str,
+    result: Any = None,
+    *,
+    success: bool = True,
+    error: BaseException | None = None,
+) -> dict[str, Any] | None:
+    """Ask the CLI to continue while Wiggum/goal mode is active."""
+    del prompt, success
+    goal_prompt = state.get_prompt()
+    if not goal_prompt:
+        state.stop()
+        return None
+
+    loop_num = state.increment()
+    if state.is_goal_mode():
+        try:
+            complete, notes, _verdicts = await _run_goal_judges(
+                agent=agent,
+                goal=goal_prompt,
+                result=result,
+                error=error,
+            )
+        except (asyncio.CancelledError, KeyboardInterrupt):
+            # Keep enough durable state for an explicit UUID resume.
+            run_id = state.get_state().run_id
+            _persist_goal_progress(status="interrupted")
+            _display_llm_judge("\u26d4 Goal loop cancelled (Ctrl+C).")
+            state.stop()
+            if run_id:
+                emit_info(f"Resume it with: /goal resume {run_id}")
+            return None
+        if complete:
+            _persist_goal_progress(status="completed")
+            # Per-judge verdicts were already shown by _run_goal_judges —
+            # no need to re-dump the notes block here.
+            _display_llm_judge("✅ GOAL COMPLETE!", final=True)
+            state.stop()
+            return None
+
+        max_iters = _get_goal_max_iterations()
+        if loop_num >= max_iters:
+            _persist_goal_progress(status="stopped")
+            _display_llm_judge(
+                f"🛑 GOAL STOPPED — Hit max iterations ({max_iters}). "
+                f"Raise the cap with /set goal_max_iterations=<int>.",
+                final=True,
+            )
+            state.stop()
+            return None
+
+        state.get_state().remediation_notes = notes
+        _persist_goal_progress()
+        _display_llm_judge(
+            f"❌ GOAL INCOMPLETE — Retrying! (Loop #{loop_num}/{max_iters})",
+            final=True,
+        )
+        return {
+            "prompt": f"{goal_prompt}\n\nJudge remediation notes:\n{notes}",
+            "clear_context": True,
+            "delay": 0.5,
+            "reason": "goal",
+        }
+
+    if error is not None:
+        emit_warning(f"\n🍩 WIGGUM RETRYING AFTER ERROR! (Loop #{loop_num})")
+        emit_system_message(f"Previous run failed: {error}")
+    else:
+        emit_warning(f"\n🍩 WIGGUM RELOOPING! (Loop #{loop_num})")
+
+    emit_system_message(f"Re-running prompt: {goal_prompt}")
+    return {
+        "prompt": goal_prompt,
+        "clear_context": True,
+        "delay": 0.5,
+        "reason": "wiggum",
+    }
+
+
+def _persist_goal_progress(*, status: str = "active") -> None:
+    current = state.get_state()
+    if current.mode != "goal" or current.run_id is None:
+        return
+    goal_runs.update(
+        current.run_id,
+        loop_count=current.loop_count,
+        remediation_notes=current.remediation_notes,
+        status=status,
+    )
+
+
+def _on_interactive_turn_cancel(prompt: str, *, reason: str = "cancelled") -> None:
+    del prompt
+    if state.is_active():
+        current = state.get_state()
+        run_id = current.run_id
+        _persist_goal_progress(status="interrupted")
+        state.stop()
+        emit_warning(f"\U0001f369 Wiggum/goal loop stopped due to {reason}")
+        if run_id:
+            emit_info(f"Resume it with: /goal resume {run_id}")
+
+
+def _autonomous_loop_capability(name: str) -> bool | None:
+    """Advertise the autonomous-loop state through ``feature_capability``.
+
+    Core (e.g. ask_user_question) checks ``autonomous_loop`` to decide
+    whether interactive tools should be blocked, without importing wiggum.
+    """
+    if name != "autonomous_loop":
+        return None
+    return state.is_active()
+
+
+register_callback("interactive_turn_end", _on_interactive_turn_end)
+register_callback("interactive_turn_cancel", _on_interactive_turn_cancel)
+register_callback("feature_capability", _autonomous_loop_capability)

code_puppy_core_plugins/wiggum/state.py

@@ -0,0 +1,89 @@
+"""State for the Wiggum/goal continuation plugin."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class WiggumState:
+    """Tiny state container. No behavior soup, please and thank you."""
+
+    active: bool = False
+    prompt: str | None = None
+    loop_count: int = 0
+    mode: str = "wiggum"
+    remediation_notes: str | None = None
+    run_id: str | None = None
+
+    def start(
+        self,
+        prompt: str,
+        *,
+        mode: str = "wiggum",
+        run_id: str | None = None,
+        loop_count: int = 0,
+        remediation_notes: str | None = None,
+    ) -> None:
+        self.active = True
+        self.prompt = prompt
+        self.loop_count = loop_count
+        self.mode = mode
+        self.remediation_notes = remediation_notes
+        self.run_id = run_id
+
+    def stop(self) -> None:
+        self.active = False
+        self.prompt = None
+        self.loop_count = 0
+        self.mode = "wiggum"
+        self.remediation_notes = None
+        self.run_id = None
+
+    def increment(self) -> int:
+        self.loop_count += 1
+        return self.loop_count
+
+
+_STATE = WiggumState()
+
+
+def get_state() -> WiggumState:
+    return _STATE
+
+
+def is_active() -> bool:
+    return _STATE.active
+
+
+def is_goal_mode() -> bool:
+    return _STATE.active and _STATE.mode == "goal"
+
+
+def get_prompt() -> str | None:
+    return _STATE.prompt if _STATE.active else None
+
+
+def start(
+    prompt: str,
+    *,
+    mode: str = "wiggum",
+    run_id: str | None = None,
+    loop_count: int = 0,
+    remediation_notes: str | None = None,
+) -> None:
+    _STATE.start(
+        prompt,
+        mode=mode,
+        run_id=run_id,
+        loop_count=loop_count,
+        remediation_notes=remediation_notes,
+    )
+
+
+def stop() -> None:
+    _STATE.stop()
+
+
+def increment() -> int:
+    return _STATE.increment()

code_puppy_core_plugins/yolo_cli/__init__.py

@@ -0,0 +1 @@
+"""Runtime-only CLI and session controls for YOLO mode."""

code_puppy_core_plugins/yolo_cli/register_callbacks.py

@@ -0,0 +1,41 @@
+"""Expose a runtime-only YOLO override through the CLI."""
+
+from __future__ import annotations
+
+import argparse
+from typing import Any, Optional
+
+from code_puppy.callbacks import register_callback
+from code_puppy.config import set_cli_yolo_override
+
+
+def _parse_bool(value: str) -> bool:
+    """Parse the explicit boolean syntax used by ``--yolo``."""
+    normalized = value.strip().lower()
+    if normalized == "true":
+        return True
+    if normalized == "false":
+        return False
+    raise argparse.ArgumentTypeError("expected 'true' or 'false'")
+
+
+def _register_cli_args(parser: Any) -> None:
+    parser.add_argument(
+        "--yolo",
+        type=_parse_bool,
+        default=None,
+        metavar="{true,false}",
+        help=(
+            "Override YOLO mode for this run without changing puppy.cfg "
+            "(/set yolo_mode takes precedence)"
+        ),
+    )
+
+
+def _handle_cli_args(args: Any) -> Optional[dict]:
+    set_cli_yolo_override(getattr(args, "yolo", None))
+    return None
+
+
+register_callback("register_cli_args", _register_cli_args)
+register_callback("handle_cli_args", _handle_cli_args)