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

code_puppy_core_plugins/emoji_filter/register_callbacks.py

@@ -0,0 +1,238 @@
+"""Wire emoji_filter into the runtime.
+
+Three points of contact, all gated by ``config.is_enabled()``:
+
+1. ``pre_tool_call`` callback — mutates the *args dict in-place* for file-write
+   and shell tools before the tool actually runs. We only touch text destined
+   for disk (new_str, content, payload) and the shell command string. Search
+   strings (old_str / snippet) are left alone so matching doesn't silently
+   break.
+
+2. ``startup`` callback — installs a one-time monkey-patch on
+   ``pydantic_ai.messages.TextPart`` / ``TextPartDelta`` to strip emojis from
+   streamed text content. ``ThinkingPart`` / ``ThinkingPartDelta`` are
+   deliberately untouched.
+
+3. ``custom_command`` / ``custom_command_help`` — a tiny ``/emoji-filter``
+   slash command so the user can flip the switch without editing puppy.cfg.
+
+Failures here must never crash the app: every patch site is wrapped.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from code_puppy.callbacks import register_callback
+
+from .config import is_enabled, set_enabled
+from .stripper import strip_emojis
+
+logger = logging.getLogger(__name__)
+
+# Tool name → handler. Keeps the dispatch table flat and inspectable (no
+# nested if/elif soup).  All handlers mutate ``args`` in place and return None.
+_FILE_WRITE_TOOLS = {"create_file", "edit_file", "replace_in_file"}
+_SHELL_TOOLS = {"agent_run_shell_command"}
+
+
+def _strip_field(container: dict, key: str) -> bool:
+    """Strip emojis from ``container[key]`` in place. Return True if it changed.
+
+    One helper, one job. Used by every other strip-site so the
+    "did anything actually change?" signal is honest and DRY.
+    """
+    val = container.get(key)
+    if not isinstance(val, str) or not val:
+        return False
+    stripped = strip_emojis(val)
+    if stripped == val:
+        return False
+    container[key] = stripped
+    return True
+
+
+def _filter_replacements(replacements: Any) -> int:
+    """Strip emojis from each ``new_str`` in a replacements list (in place).
+
+    Returns the number of items whose ``new_str`` was modified.
+    """
+    if not isinstance(replacements, list):
+        return 0
+    count = 0
+    for item in replacements:
+        if isinstance(item, dict) and _strip_field(item, "new_str"):
+            count += 1
+    return count
+
+
+def _filter_edit_payload(payload: Any) -> list[str]:
+    """Mutate an edit_file payload dict in place.
+
+    edit_file accepts three payload shapes:
+      * ContentPayload      → strip ``content``
+      * ReplacementsPayload → strip each ``new_str``
+      * DeleteSnippetPayload → leave alone (it's a search string)
+
+    Returns a list of human-readable labels describing what was stripped
+    (empty list = nothing changed).
+    """
+    if not isinstance(payload, dict):
+        return []
+    stripped: list[str] = []
+    if _strip_field(payload, "content"):
+        stripped.append("payload.content")
+    if "replacements" in payload:
+        n = _filter_replacements(payload["replacements"])
+        if n:
+            stripped.append(f"payload.replacements ({n} item{'s' if n != 1 else ''})")
+    return stripped
+
+
+# Notify the model when we tamper with its tool call so it stops emitting emojis.
+# The framework (pydantic_patches._patched_call_tool) prepends the ``context_message``
+# to the tool result as ``[hook context]\n{msg}``, which the model then reads.
+_CONTEXT_MESSAGE_TEMPLATE = (
+    "emoji_filter is ENABLED. Emojis were detected and stripped from "
+    "`{tool_name}` arg(s): {fields}. This project does not allow emojis "
+    "in file writes, shell commands, or assistant output \u2014 please "
+    "omit them in future tool calls and responses."
+)
+
+
+def _on_pre_tool_call(
+    tool_name: str, tool_args: dict, context: Any = None
+) -> dict | None:
+    """Strip emojis from file-write and shell tool args, and notify the model.
+
+    Returns ``{"context_message": ...}`` when any emojis were detected so the
+    framework can surface that fact to the model via the tool result. Returns
+    ``None`` otherwise (no-op for the framework).
+    """
+    if not is_enabled() or not isinstance(tool_args, dict):
+        return None
+
+    stripped_fields: list[str] = []
+    try:
+        if tool_name == "create_file":
+            if _strip_field(tool_args, "content"):
+                stripped_fields.append("content")
+
+        elif tool_name == "replace_in_file":
+            n = _filter_replacements(tool_args.get("replacements"))
+            if n:
+                stripped_fields.append(
+                    f"replacements ({n} item{'s' if n != 1 else ''})"
+                )
+
+        elif tool_name == "edit_file":
+            stripped_fields.extend(_filter_edit_payload(tool_args.get("payload")))
+
+        elif tool_name in _SHELL_TOOLS:
+            if _strip_field(tool_args, "command"):
+                stripped_fields.append("command")
+    except Exception as exc:  # never block tool execution
+        logger.debug("emoji_filter pre_tool_call failed: %s", exc)
+        return None
+
+    if not stripped_fields:
+        return None
+
+    return {
+        "context_message": _CONTEXT_MESSAGE_TEMPLATE.format(
+            tool_name=tool_name, fields=", ".join(stripped_fields)
+        )
+    }
+
+
+# Streaming patch: patch TextPart/TextPartDelta __init__ exactly once; the patched
+# init checks ``is_enabled()`` at call time so the user can toggle without restart.
+
+_STREAM_PATCH_FLAG = "_emoji_filter_patched"
+
+
+def _install_streaming_patch() -> None:
+    try:
+        from pydantic_ai.messages import TextPart, TextPartDelta
+    except Exception as exc:
+        logger.debug("emoji_filter: pydantic_ai.messages unavailable: %s", exc)
+        return
+
+    for cls, attr in ((TextPartDelta, "content_delta"), (TextPart, "content")):
+        if getattr(cls, _STREAM_PATCH_FLAG, False):
+            continue
+        _wrap_init(cls, attr)
+
+
+def _wrap_init(cls: type, content_attr: str) -> None:
+    original_init = cls.__init__
+
+    def patched_init(self, *args, **kwargs):  # noqa: ANN001 - dataclass-y
+        original_init(self, *args, **kwargs)
+        if not is_enabled():
+            return
+        try:
+            current = getattr(self, content_attr, None)
+            if isinstance(current, str) and current:
+                stripped = strip_emojis(current)
+                if stripped != current:
+                    setattr(self, content_attr, stripped)
+        except Exception as exc:  # defensive: never break message construction
+            logger.debug(
+                "emoji_filter stream patch failed on %s: %s", cls.__name__, exc
+            )
+
+    cls.__init__ = patched_init  # type: ignore[method-assign]
+    setattr(cls, _STREAM_PATCH_FLAG, True)
+
+
+def _on_startup() -> None:
+    _install_streaming_patch()
+
+
+# --- /emoji-filter slash command --------------------------------------------
+
+_COMMAND_NAMES = {"emoji-filter", "emojifilter"}
+
+
+def _custom_help():
+    return [
+        ("emoji-filter", "Show / toggle the emoji filter (on|off|status)"),
+    ]
+
+
+def _handle_command(command: str, name: str):
+    if name not in _COMMAND_NAMES:
+        return None
+
+    from code_puppy.messaging import emit_info
+
+    parts = command.split(maxsplit=1)
+    arg = parts[1].strip().lower() if len(parts) == 2 else "status"
+
+    if arg in ("on", "enable", "enabled", "true", "1"):
+        set_enabled(True)
+        emit_info(
+            "emoji_filter: ON (emojis will be stripped from outputs/file writes/shell)"
+        )
+        return True
+    if arg in ("off", "disable", "disabled", "false", "0"):
+        set_enabled(False)
+        emit_info("emoji_filter: OFF (emojis pass through untouched)")
+        return True
+    if arg in ("status", ""):
+        state = "ON" if is_enabled() else "OFF"
+        emit_info(f"emoji_filter: {state}")
+        return True
+
+    emit_info("Usage: /emoji-filter [on|off|status]")
+    return True
+
+
+# --- Registration ------------------------------------------------------------
+
+register_callback("startup", _on_startup)
+register_callback("pre_tool_call", _on_pre_tool_call)
+register_callback("custom_command_help", _custom_help)
+register_callback("custom_command", _handle_command)

code_puppy_core_plugins/emoji_filter/stripper.py

@@ -0,0 +1,45 @@
+"""Emoji stripping utilities.
+
+One regex, one entrypoint. Beautiful is better than ugly.
+"""
+
+from __future__ import annotations
+
+import re
+
+# Common pictographic/emoji ranges + zero-width joiner & variation selector-16
+# (multi-codepoint composition). Conservative: no punctuation/math/arrows/letters.
+_EMOJI_RE = re.compile(
+    "["
+    "\U0001f300-\U0001f5ff"  # misc symbols & pictographs
+    "\U0001f600-\U0001f64f"  # emoticons
+    "\U0001f680-\U0001f6ff"  # transport & map
+    "\U0001f700-\U0001f77f"  # alchemical
+    "\U0001f780-\U0001f7ff"  # geometric shapes extended
+    "\U0001f800-\U0001f8ff"  # supplemental arrows-C
+    "\U0001f900-\U0001f9ff"  # supplemental symbols and pictographs
+    "\U0001fa00-\U0001fa6f"  # chess symbols
+    "\U0001fa70-\U0001faff"  # symbols & pictographs extended-A
+    "\U0001fb00-\U0001fbff"  # symbols for legacy computing
+    "\U00002600-\U000026ff"  # misc symbols (includes ☂ ☀ ♻ etc.)
+    "\U00002700-\U000027bf"  # dingbats (✂ ✈ ✅ ❌ ❤ etc.)
+    "\U0001f1e6-\U0001f1ff"  # regional indicator symbols (flags)
+    "\U0000fe0f"  # variation selector-16
+    "\U0000200d"  # zero width joiner
+    "]+",
+    flags=re.UNICODE,
+)
+
+
+def strip_emojis(text: str) -> str:
+    """Return ``text`` with emoji codepoints removed. None-safe on non-strings."""
+    if not isinstance(text, str) or not text:
+        return text
+    return _EMOJI_RE.sub("", text)
+
+
+def contains_emoji(text: str) -> bool:
+    """Quick check used mostly by tests."""
+    if not isinstance(text, str) or not text:
+        return False
+    return _EMOJI_RE.search(text) is not None

code_puppy_core_plugins/empty_html_comment_filter/register_callbacks.py

@@ -0,0 +1,116 @@
+"""Hide whitespace-only HTML comments from streamed thinking display.
+
+The filter is stateful because model deltas may split ``<!-- -->`` at any
+character boundary. It changes presentation only; model history and response
+content remain untouched.
+"""
+
+from __future__ import annotations
+
+from threading import Lock
+
+from code_puppy.callbacks import register_callback
+
+_OPEN = "<!--"
+_CLOSE = "-->"
+_pending: dict[tuple[object, int], str] = {}
+_lock = Lock()
+
+
+def _prefix_suffix_length(text: str, marker: str) -> int:
+    """Return the longest suffix of ``text`` that prefixes ``marker``."""
+    limit = min(len(text), len(marker) - 1)
+    for length in range(limit, 0, -1):
+        if text.endswith(marker[:length]):
+            return length
+    return 0
+
+
+def _could_complete_empty_comment(body: str) -> bool:
+    """Whether an unfinished body is whitespace plus a closing-prefix."""
+    return body.lstrip() in ("", "-", "--")
+
+
+def _pop_trailing_newline(parts: list[str]) -> str:
+    """Remove and return one trailing newline from accumulated output."""
+    for index in range(len(parts) - 1, -1, -1):
+        part = parts[index]
+        if not part:
+            continue
+        if part.endswith("\r\n"):
+            parts[index] = part[:-2]
+            return "\r\n"
+        if part.endswith("\n"):
+            parts[index] = part[:-1]
+            return "\n"
+        break
+    return ""
+
+
+def _held_suffix_length(text: str) -> int:
+    """Retain a possible opener and its immediately preceding newline."""
+    length = _prefix_suffix_length(text, _OPEN)
+    start = len(text) - length
+    if start > 0 and text[start - 1] == "\n":
+        length += 1
+        if start > 1 and text[start - 2] == "\r":
+            length += 1
+    return length
+
+
+def _filter_chunk(buffered: str, text: str, *, final: bool) -> tuple[str, str]:
+    """Return display-safe output and an incomplete candidate to retain."""
+    data = buffered + text
+    output: list[str] = []
+    position = 0
+
+    while position < len(data):
+        opening = data.find(_OPEN, position)
+        if opening < 0:
+            remainder = data[position:]
+            held_length = 0 if final else _held_suffix_length(remainder)
+            if held_length:
+                output.append(remainder[:-held_length])
+                return "".join(output), remainder[-held_length:]
+            output.append(remainder)
+            break
+
+        output.append(data[position:opening])
+        closing = data.find(_CLOSE, opening + len(_OPEN))
+        if closing < 0:
+            candidate = data[opening:]
+            body = candidate[len(_OPEN) :]
+            if not final and _could_complete_empty_comment(body):
+                newline = _pop_trailing_newline(output)
+                return "".join(output), newline + candidate
+            output.append(candidate)
+            return "".join(output), ""
+
+        body = data[opening + len(_OPEN) : closing]
+        if body.strip():
+            output.append(data[opening : closing + len(_CLOSE)])
+        else:
+            _pop_trailing_newline(output)
+        position = closing + len(_CLOSE)
+
+    return "".join(output), ""
+
+
+def _filter_thinking_display(
+    text: str,
+    *,
+    stream_id: object,
+    part_index: int,
+    final: bool = False,
+) -> str:
+    """Remove empty comments while retaining incomplete markers across deltas."""
+    key = (stream_id, part_index)
+    with _lock:
+        buffered = _pending.pop(key, "")
+        output, remainder = _filter_chunk(buffered, text, final=final)
+        if remainder and not final:
+            _pending[key] = remainder
+        return output
+
+
+register_callback("thinking_display_filter", _filter_thinking_display)