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

code_puppy_core_plugins/plugin_list/register_callbacks.py

@@ -0,0 +1,281 @@
+"""``/plugins`` slash command -- manage plugins interactively or via subcommands.
+
+Usage::
+
+    /plugins                   -- open interactive TUI
+    /plugins list              -- print loaded plugins with status
+    /plugins disable <name>    -- disable a plugin (callbacks are skipped)
+    /plugins enable <name>     -- enable a plugin; untrusted project plugins
+                                  open the TUI trust ceremony directly
+    /plugins revoke <name>     -- revoke trust for a project plugin
+
+Dogfoods the plugin system by implementing itself as a builtin plugin that
+hooks into ``custom_command`` and ``custom_command_help``.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Optional
+
+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."""
+    if not names:
+        return "  (none)"
+    lines = []
+    for name in sorted(names):
+        if name in disabled:
+            lines.append(f"   {name}  (disabled)")
+        else:
+            lines.append(f"   {name}")
+    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],
+    disabled: set[str],
+) -> str:
+    """Project tier listing: loaded plugins plus skipped-by-trust ones.
+
+    Project plugins are disabled by default; unlike other tiers we also
+    show plugins that were discovered but NOT imported, with the reason.
+    """
+    names = sorted(set(loaded_names) | set(statuses))
+    if not names:
+        return "  (none)"
+    lines = []
+    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}")
+    return "\n".join(lines)
+
+
+def _build_output() -> str:
+    """Build the full /plugins list display string."""
+    from code_puppy.plugins import (
+        get_loaded_plugins,
+        get_project_plugins_directory,
+        get_project_plugin_status,
+    )
+    from code_puppy.plugins.config import get_disabled_plugins
+
+    loaded = get_loaded_plugins()
+    disabled = get_disabled_plugins()
+    project_status = get_project_plugin_status()
+
+    # Display paths with forward slashes regardless of OS so the output is
+    # consistent across Windows / POSIX (and easier to copy-paste).
+    builtin_path = Path(__file__).parent.parent.as_posix() + "/"
+    user_path = "~/.code_puppy/plugins/"
+    project_dir = get_project_plugins_directory()
+    project_path = (
+        project_dir.as_posix() + "/" if project_dir else "<CWD>/.code_puppy/plugins/"
+    )
+
+    lines = [
+        "Loaded Plugins",
+        "",
+        f"Builtin ({builtin_path}):",
+        _format_plugin_list(loaded["builtin"], disabled),
+        "",
+        f"User ({user_path}):",
+        _format_plugin_list(loaded["user"], disabled),
+        "",
+        f"Project ({project_path}):",
+        _format_project_plugin_list(loaded["project"], project_status, disabled),
+    ]
+
+    if disabled:
+        lines.extend(
+            [
+                "",
+                f"Disabled: {', '.join(sorted(disabled))}",
+                "Re-enable it in the /plugins TUI.",
+            ]
+        )
+
+    return "\n".join(lines)
+
+
+def _all_loaded_plugin_names() -> set[str]:
+    """Return the set of all loaded plugin names across all tiers."""
+    from code_puppy.plugins import get_loaded_plugins
+
+    loaded = get_loaded_plugins()
+    names: set[str] = set()
+    for tier_names in loaded.values():
+        names.update(tier_names)
+    return names
+
+
+def _handle_toggle(plugin_name: str, *, disabled: bool) -> bool:
+    """Flip *plugin_name*'s disabled state to *disabled*.
+
+    One implementation handles both ``enable`` and ``disable`` — the only
+    difference is the target state and the success-message verb.
+    """
+    from code_puppy.messaging import emit_error, emit_info, emit_success, emit_warning
+    from code_puppy.plugins.config import set_plugin_disabled
+
+    if plugin_name not in _all_loaded_plugin_names():
+        emit_error(
+            f"Plugin '{plugin_name}' is not loaded. "
+            f"Use /plugins to see available plugins."
+        )
+        return True
+
+    verb = "disabled" if disabled else "re-enabled"
+    state = "disabled" if disabled else "enabled"
+    if set_plugin_disabled(plugin_name, disabled):
+        emit_success(f"Plugin '{plugin_name}' {verb}.")
+        emit_warning("Restart Code Puppy for this change to take effect.")
+    else:
+        emit_info(f"Plugin '{plugin_name}' is already {state}.")
+    return True
+
+
+# -- startup hook ----------------------------------------------------------
+
+
+def _on_startup() -> None:
+    """Surface project plugins held back by the trust gate.
+
+    Runs via the ``startup`` callback, which fires after the renderers are
+    live — so the orange banner lands inline with the other startup
+    messages instead of rotting in the legacy queue's startup buffer
+    (which SynchronousInteractiveRenderer never replays).
+    """
+    try:
+        from code_puppy.plugins import get_project_plugin_status
+        from code_puppy.plugins.trust_notice import emit_skipped_plugin_notice
+
+        emit_skipped_plugin_notice(get_project_plugin_status())
+    except Exception as exc:
+        logger.debug(f"Trust-notice startup hook failed: {exc}")
+
+
+# -- custom_command hooks --------------------------------------------------
+
+
+def _custom_help() -> list[tuple[str, str]]:
+    return [("plugins", "List, enable/disable, or trust project plugins")]
+
+
+def _run_interactive_menu() -> None:
+    """Open the TUI; fall back to a plain-text list if it blows up."""
+    from code_puppy.messaging import emit_info
+
+    try:
+        from code_puppy_core_plugins.plugin_list.plugins_menu import run_plugins_menu
+
+        run_plugins_menu()
+    except Exception as exc:
+        logger.warning(f"Plugins TUI failed, falling back to list: {exc}")
+        emit_info(_build_output())
+
+
+def _sub_list(_tokens: list[str]) -> bool:
+    from code_puppy.messaging import emit_info
+
+    emit_info(_build_output())
+    return True
+
+
+def _sub_disable(tokens: list[str]) -> bool:
+    return _sub_toggle(tokens, disabled=True)
+
+
+def _sub_enable(tokens: list[str]) -> bool:
+    from code_puppy.messaging import emit_error
+
+    if len(tokens) < 3:
+        emit_error("Usage: /plugins enable <plugin-name>")
+        return True
+
+    # Project plugins get the trust/risk-acceptance flow; anything else
+    # falls through to the regular enable toggle.
+    from code_puppy_core_plugins.plugin_list.project_trust_flow import (
+        try_enable_project_plugin,
+    )
+
+    if try_enable_project_plugin(tokens[2]):
+        return True
+    return _handle_toggle(tokens[2], disabled=False)
+
+
+def _sub_revoke(tokens: list[str]) -> bool:
+    from code_puppy.messaging import emit_error
+
+    if len(tokens) < 3:
+        emit_error("Usage: /plugins revoke <plugin-name>")
+        return True
+
+    from code_puppy_core_plugins.plugin_list.project_trust_flow import (
+        revoke_project_plugin,
+    )
+
+    return revoke_project_plugin(tokens[2])
+
+
+def _sub_toggle(tokens: list[str], *, disabled: bool) -> bool:
+    from code_puppy.messaging import emit_error
+
+    action = "disable" if disabled else "enable"
+    if len(tokens) < 3:
+        emit_error(f"Usage: /plugins {action} <plugin-name>")
+        return True
+    return _handle_toggle(tokens[2], disabled=disabled)
+
+
+_SUBCOMMANDS = {
+    "list": _sub_list,
+    "disable": _sub_disable,
+    "enable": _sub_enable,
+    "revoke": _sub_revoke,
+}
+
+
+def _handle_custom_command(command: str, name: str) -> Optional[bool]:
+    if name != "plugins":
+        return None
+
+    tokens = command.strip().split()
+
+    if len(tokens) <= 1:
+        _run_interactive_menu()
+        return True
+
+    handler = _SUBCOMMANDS.get(tokens[1].lower())
+    if handler is None:
+        from code_puppy.messaging import emit_error
+
+        emit_error(
+            f"Unknown subcommand: '{tokens[1]}'. "
+            "Usage: /plugins [list | enable <name> | disable <name> | revoke <name>]"
+        )
+        return True
+    return handler(tokens)
+
+
+register_callback("startup", _on_startup)
+register_callback("custom_command_help", _custom_help)
+register_callback("custom_command", _handle_custom_command)

code_puppy_core_plugins/pop_command/__init__.py

@@ -0,0 +1 @@
+"""/pop command plugin."""

code_puppy_core_plugins/pop_command/register_callbacks.py

@@ -0,0 +1,191 @@
+"""Plugin that adds /pop for trimming recent conversation history."""
+
+from __future__ import annotations
+
+from typing import Any, List, Optional, Tuple
+
+from code_puppy.callbacks import register_callback
+
+
+def emit_error(message: Any) -> None:
+    from code_puppy.messaging import emit_error as _emit_error
+
+    _emit_error(message)
+
+
+def emit_info(message: Any) -> None:
+    from code_puppy.messaging import emit_info as _emit_info
+
+    _emit_info(message)
+
+
+def emit_success(message: Any) -> None:
+    from code_puppy.messaging import emit_success as _emit_success
+
+    _emit_success(message)
+
+
+def emit_warning(message: Any) -> None:
+    from code_puppy.messaging import emit_warning as _emit_warning
+
+    _emit_warning(message)
+
+
+def _custom_help() -> List[Tuple[str, str]]:
+    return [
+        (
+            "pop",
+            "Delete the N most-recent messages and prune broken tool-call fragments",
+        )
+    ]
+
+
+def _has_only_tool_returns(message: Any) -> bool:
+    """Return True when a request message contains only tool-return parts."""
+    try:
+        from pydantic_ai.messages import ModelRequest, ToolReturnPart
+
+        if not isinstance(message, ModelRequest):
+            return False
+
+        parts = getattr(message, "parts", []) or []
+        return bool(parts) and all(isinstance(part, ToolReturnPart) for part in parts)
+    except Exception:
+        return False
+
+
+def _has_unresolved_tool_calls(message: Any) -> bool:
+    """Return True when a response message still contains unresolved tool calls."""
+    try:
+        from pydantic_ai.messages import ModelResponse, ToolCallPart
+
+        if not isinstance(message, ModelResponse):
+            return False
+
+        parts = getattr(message, "parts", []) or []
+        return any(isinstance(part, ToolCallPart) for part in parts)
+    except Exception:
+        return False
+
+
+def _prune_dangling_tool_fragments(history: List[Any]) -> tuple[List[Any], int]:
+    """Strip incomplete tool-call sequences from the tail of history."""
+    pruned = 0
+
+    while history:
+        tail = history[-1]
+        if _has_only_tool_returns(tail):
+            history.pop()
+            pruned += 1
+            continue
+
+        if _has_unresolved_tool_calls(tail):
+            history.pop()
+            pruned += 1
+            continue
+
+        break
+
+    return history, pruned
+
+
+def _parse_pop_count(command: str) -> Optional[int]:
+    tokens = command.split()
+    if len(tokens) < 2:
+        return 1
+
+    try:
+        count = int(tokens[1])
+    except ValueError:
+        emit_error(f"/pop: '{tokens[1]}' is not a valid integer – usage: /pop [N]")
+        return None
+
+    if count < 1:
+        emit_error("/pop: N must be a positive integer")
+        return None
+
+    return count
+
+
+def _handle_pop_command(command: str) -> bool:
+    from code_puppy.agents.agent_manager import get_current_agent
+
+    count = _parse_pop_count(command)
+    if count is None:
+        return True
+
+    try:
+        agent = get_current_agent()
+    except Exception as exc:
+        emit_error(f"/pop: could not get current agent – {exc}")
+        return True
+
+    history: List[Any] = list(agent.get_message_history())
+    if not history:
+        emit_warning("/pop: conversation history is empty – nothing to remove")
+        return True
+
+    poppable = len(history) - 1
+    if poppable <= 0:
+        emit_warning("/pop: only the system prompt is in history – nothing to remove")
+        return True
+
+    if count > poppable:
+        emit_warning(
+            f"/pop: requested {count} but only {poppable} message(s) can be removed "
+            f"(the system prompt is always preserved). Removing {poppable}."
+        )
+        count = poppable
+
+    before_count = len(history)
+    history = history[: before_count - count]
+    history, extra_pruned = _prune_dangling_tool_fragments(history)
+    after_count = len(history)
+    total_removed = before_count - after_count
+
+    try:
+        agent.set_message_history(history)
+    except Exception as exc:
+        emit_error(f"/pop: failed to update message history – {exc}")
+        return True
+
+    summary_parts = [f":scissors: Popped {count} message(s)"]
+    if extra_pruned:
+        summary_parts.append(
+            f"and pruned {extra_pruned} extra incomplete tool-call fragment(s)"
+        )
+
+    remaining = max(after_count - 1, 0)
+    emit_success(
+        " ".join(summary_parts)
+        + ".\n"
+        + f":scroll: History: {before_count - 1} → {remaining} message(s) "
+        + f"(excluding system prompt, removed {total_removed} total)"
+    )
+
+    if after_count <= 1:
+        emit_info(":bulb: History is now empty (system prompt only). Starting fresh!")
+
+    return True
+
+
+def _handle_custom_command(command: str, name: str) -> Optional[bool]:
+    if name != "pop":
+        return None
+
+    return _handle_pop_command(command)
+
+
+register_callback("custom_command_help", _custom_help)
+register_callback("custom_command", _handle_custom_command)
+
+
+__all__ = [
+    "_custom_help",
+    "_handle_custom_command",
+    "_handle_pop_command",
+    "_parse_pop_count",
+    "_prune_dangling_tool_fragments",
+    "_has_only_tool_returns",
+    "_has_unresolved_tool_calls",
+]

code_puppy_core_plugins/prompt_newline/__init__.py

@@ -0,0 +1,13 @@
+"""Plugin: drop user input onto a fresh line below the prompt chrome.
+
+When enabled, transforms
+
+    🐶 puppy [agent] [model] (~/very/long/cwd) >>> typed text
+
+into
+
+    🐶 puppy [agent] [model] (~/very/long/cwd) >>>
+    typed text
+
+Toggle at runtime with ``/prompt_newline [on|off]``. Persisted in puppy.cfg.
+"""

code_puppy_core_plugins/prompt_newline/config.py

@@ -0,0 +1,21 @@
+"""Plugin-local config for the prompt_newline plugin."""
+
+from __future__ import annotations
+
+from code_puppy.config import get_value, set_config_value
+
+_CONFIG_KEY = "prompt_newline"
+_TRUTHY = ("true", "1", "yes", "on")
+
+
+def is_enabled() -> bool:
+    """Return True if the prompt_newline hack is enabled. Default: False."""
+    cfg_val = get_value(_CONFIG_KEY)
+    if cfg_val is None:
+        return False
+    return str(cfg_val).strip().lower() in _TRUTHY
+
+
+def set_enabled(enabled: bool) -> None:
+    """Persist the on/off switch to puppy.cfg."""
+    set_config_value(_CONFIG_KEY, "true" if enabled else "false")

code_puppy_core_plugins/prompt_newline/register_callbacks.py

@@ -0,0 +1,163 @@
+"""Register callbacks for the prompt_newline plugin.
+
+This plugin is a tiny ergonomics hack: it places the user's input cursor on a
+*new line* below the puppy/agent/model/cwd chrome, so long working-directory
+paths don't squeeze the typing area.
+
+It hooks two things:
+
+* ``startup`` — wraps ``get_prompt_with_active_model`` so the FormattedText it
+  returns gets a trailing ``\\n`` appended **at call time** (so the slash
+  command toggle takes effect immediately, no restart needed).
+* ``custom_command`` / ``custom_command_help`` — exposes ``/prompt_newline``
+  for runtime on/off, persisted via ``puppy.cfg``.
+
+Default: OFF. Opt-in only.
+"""
+
+from __future__ import annotations
+
+from typing import List, Optional, Tuple
+
+from code_puppy.callbacks import register_callback
+from code_puppy_core_plugins.prompt_newline.config import is_enabled, set_enabled
+
+_COMMAND_NAME = "prompt_newline"
+_PATCH_ATTR = "_prompt_newline_original"
+
+
+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)
+
+
+def _emit_success(message: str) -> None:
+    from code_puppy.messaging import emit_success
+
+    emit_success(message)
+
+
+def _append_newline(formatted_text):
+    """Return a new FormattedText with a trailing newline tuple.
+
+    ``FormattedText`` is a ``list`` subclass of ``(style, text)`` tuples, so we
+    rebuild it rather than mutating in place — the upstream caller may cache
+    or reuse the returned object.
+    """
+    from prompt_toolkit.formatted_text import FormattedText
+
+    try:
+        return FormattedText(list(formatted_text) + [("", "\n")])
+    except Exception:
+        # Defensive: never break the prompt if the upstream shape changes.
+        return formatted_text
+
+
+def _install_prompt_patch() -> None:
+    """Monkey-patch ``get_prompt_with_active_model`` to honor ``is_enabled()``.
+
+    Idempotent: re-running won't double-wrap.
+    """
+    from code_puppy.command_line import prompt_toolkit_completion as ptc
+
+    if getattr(ptc, _PATCH_ATTR, None) is not None:
+        return  # Already patched
+
+    original = ptc.get_prompt_with_active_model
+    setattr(ptc, _PATCH_ATTR, original)
+
+    def patched(base: str = ">>> "):
+        result = original(base)
+        if is_enabled():
+            return _append_newline(result)
+        return result
+
+    ptc.get_prompt_with_active_model = patched
+
+
+def _on_startup() -> None:
+    try:
+        _install_prompt_patch()
+    except Exception as exc:
+        # Plugins must fail gracefully — never crash the app.
+        _emit_error(f"prompt_newline: failed to install prompt patch — {exc}")
+
+
+def _custom_help() -> List[Tuple[str, str]]:
+    return [
+        (
+            _COMMAND_NAME,
+            "Toggle placing user input on a new line below the prompt chrome",
+        )
+    ]
+
+
+def _parse_toggle_arg(command: str) -> Optional[bool]:
+    """Parse ``/prompt_newline [on|off|true|false|toggle]``.
+
+    Returns:
+        True/False for an explicit set, or ``None`` to mean "flip current".
+    """
+    tokens = command.strip().split()
+    if len(tokens) < 2:
+        return None  # bare /prompt_newline → flip
+    arg = tokens[1].lower()
+    if arg in ("on", "true", "1", "yes", "enable", "enabled"):
+        return True
+    if arg in ("off", "false", "0", "no", "disable", "disabled"):
+        return False
+    if arg in ("toggle",):
+        return None
+    raise ValueError(arg)
+
+
+def _handle_prompt_newline_command(command: str) -> bool:
+    try:
+        target = _parse_toggle_arg(command)
+    except ValueError as exc:
+        _emit_error(
+            f"/{_COMMAND_NAME}: unknown argument '{exc.args[0]}'. "
+            "Usage: /prompt_newline [on|off|toggle]"
+        )
+        return True
+
+    if target is None:
+        target = not is_enabled()
+
+    set_enabled(target)
+    state = "ON" if target else "OFF"
+    _emit_success(f"🐶 prompt_newline is now {state}")
+    if target:
+        _emit_info("Your input will appear on a fresh line below the prompt chrome.")
+    else:
+        _emit_info("Prompt is back to single-line mode.")
+    return True
+
+
+def _handle_custom_command(command: str, name: str):
+    if name != _COMMAND_NAME:
+        return None
+    return _handle_prompt_newline_command(command)
+
+
+register_callback("startup", _on_startup)
+register_callback("custom_command", _handle_custom_command)
+register_callback("custom_command_help", _custom_help)
+
+
+__all__ = [
+    "_append_newline",
+    "_custom_help",
+    "_handle_custom_command",
+    "_handle_prompt_newline_command",
+    "_install_prompt_patch",
+    "_on_startup",
+    "_parse_toggle_arg",
+]

code_puppy_core_plugins/prune/__init__.py

@@ -0,0 +1 @@
+"""/prune surgical history pruner plugin."""