codepp 0.0.437__py3-none-any.whl

code_puppy/plugins/frontend_emitter/register_callbacks.py

@@ -0,0 +1,261 @@
+"""Callback registration for frontend event emission.
+
+This module registers callbacks for various agent events and emits them
+to subscribed WebSocket handlers via the emitter module.
+"""
+
+import logging
+import time
+from typing import Any, Dict, Optional
+
+from code_puppy.callbacks import register_callback
+from code_puppy.plugins.frontend_emitter.emitter import emit_event
+
+logger = logging.getLogger(__name__)
+
+
+async def on_pre_tool_call(
+    tool_name: str, tool_args: Dict[str, Any], context: Any = None
+) -> None:
+    """Emit an event when a tool call starts.
+
+    Args:
+        tool_name: Name of the tool being called
+        tool_args: Arguments being passed to the tool
+        context: Optional context data for the tool call
+    """
+    try:
+        emit_event(
+            "tool_call_start",
+            {
+                "tool_name": tool_name,
+                "tool_args": _sanitize_args(tool_args),
+                "start_time": time.time(),
+            },
+        )
+        logger.debug(f"Emitted tool_call_start for {tool_name}")
+    except Exception as e:
+        logger.error(f"Failed to emit pre_tool_call event: {e}")
+
+
+async def on_post_tool_call(
+    tool_name: str,
+    tool_args: Dict[str, Any],
+    result: Any,
+    duration_ms: float,
+    context: Any = None,
+) -> None:
+    """Emit an event when a tool call completes.
+
+    Args:
+        tool_name: Name of the tool that was called
+        tool_args: Arguments that were passed to the tool
+        result: The result returned by the tool
+        duration_ms: Execution time in milliseconds
+        context: Optional context data for the tool call
+    """
+    try:
+        emit_event(
+            "tool_call_complete",
+            {
+                "tool_name": tool_name,
+                "tool_args": _sanitize_args(tool_args),
+                "duration_ms": duration_ms,
+                "success": _is_successful_result(result),
+                "result_summary": _summarize_result(result),
+            },
+        )
+        logger.debug(
+            f"Emitted tool_call_complete for {tool_name} ({duration_ms:.2f}ms)"
+        )
+    except Exception as e:
+        logger.error(f"Failed to emit post_tool_call event: {e}")
+
+
+async def on_stream_event(
+    event_type: str, event_data: Any, agent_session_id: Optional[str] = None
+) -> None:
+    """Emit streaming events from the agent.
+
+    Args:
+        event_type: Type of the streaming event
+        event_data: Data associated with the event
+        agent_session_id: Optional session ID of the agent emitting the event
+    """
+    try:
+        emit_event(
+            "stream_event",
+            {
+                "event_type": event_type,
+                "event_data": _sanitize_event_data(event_data),
+                "agent_session_id": agent_session_id,
+            },
+        )
+        logger.debug(f"Emitted stream_event: {event_type}")
+    except Exception as e:
+        logger.error(f"Failed to emit stream_event: {e}")
+
+
+async def on_invoke_agent(*args: Any, **kwargs: Any) -> None:
+    """Emit an event when an agent is invoked.
+
+    Args:
+        *args: Positional arguments from the invoke_agent callback
+        **kwargs: Keyword arguments from the invoke_agent callback
+    """
+    try:
+        # Extract relevant info from args/kwargs
+        agent_info = {
+            "agent_name": kwargs.get("agent_name") or (args[0] if args else None),
+            "session_id": kwargs.get("session_id"),
+            "prompt_preview": _truncate_string(
+                kwargs.get("prompt") or (args[1] if len(args) > 1 else None),
+                max_length=200,
+            ),
+        }
+        emit_event("agent_invoked", agent_info)
+        logger.debug(f"Emitted agent_invoked: {agent_info.get('agent_name')}")
+    except Exception as e:
+        logger.error(f"Failed to emit invoke_agent event: {e}")
+
+
+def _sanitize_args(args: Dict[str, Any]) -> Dict[str, Any]:
+    """Sanitize tool arguments for safe emission.
+
+    Truncates large values and removes potentially sensitive data.
+
+    Args:
+        args: The raw tool arguments
+
+    Returns:
+        Sanitized arguments safe for emission
+    """
+    if not isinstance(args, dict):
+        return {}
+
+    sanitized: Dict[str, Any] = {}
+    for key, value in args.items():
+        if isinstance(value, str):
+            sanitized[key] = _truncate_string(value, max_length=500)
+        elif isinstance(value, (int, float, bool, type(None))):
+            sanitized[key] = value
+        elif isinstance(value, (list, dict)):
+            # Just indicate the type and length for complex types
+            sanitized[key] = f"<{type(value).__name__}[{len(value)}]>"
+        else:
+            sanitized[key] = f"<{type(value).__name__}>"
+
+    return sanitized
+
+
+def _sanitize_event_data(data: Any) -> Any:
+    """Sanitize event data for safe emission.
+
+    Args:
+        data: The raw event data
+
+    Returns:
+        Sanitized data safe for emission
+    """
+    if data is None:
+        return None
+
+    if isinstance(data, str):
+        return _truncate_string(data, max_length=1000)
+
+    if isinstance(data, (int, float, bool)):
+        return data
+
+    if isinstance(data, dict):
+        return {k: _sanitize_event_data(v) for k, v in list(data.items())[:20]}
+
+    if isinstance(data, (list, tuple)):
+        return [_sanitize_event_data(item) for item in data[:20]]
+
+    return f"<{type(data).__name__}>"
+
+
+def _is_successful_result(result: Any) -> bool:
+    """Determine if a tool result indicates success.
+
+    Args:
+        result: The tool result
+
+    Returns:
+        True if the result appears successful
+    """
+    if result is None:
+        return True  # No result often means success
+
+    if isinstance(result, dict):
+        # Check for error indicators
+        if result.get("error"):
+            return False
+        if result.get("success") is False:
+            return False
+        return True
+
+    if isinstance(result, bool):
+        return result
+
+    return True  # Default to success
+
+
+def _summarize_result(result: Any) -> str:
+    """Create a brief summary of a tool result.
+
+    Args:
+        result: The tool result
+
+    Returns:
+        A string summary of the result
+    """
+    if result is None:
+        return "<no result>"
+
+    if isinstance(result, str):
+        return _truncate_string(result, max_length=200)
+
+    if isinstance(result, dict):
+        if "error" in result:
+            return f"Error: {_truncate_string(str(result['error']), max_length=100)}"
+        if "message" in result:
+            return _truncate_string(str(result["message"]), max_length=100)
+        return f"<dict with {len(result)} keys>"
+
+    if isinstance(result, (list, tuple)):
+        return f"<{type(result).__name__}[{len(result)}]>"
+
+    return _truncate_string(str(result), max_length=200)
+
+
+def _truncate_string(value: Any, max_length: int = 100) -> Optional[str]:
+    """Truncate a string value if it exceeds max_length.
+
+    Args:
+        value: The value to truncate (will be converted to str)
+        max_length: Maximum length before truncation
+
+    Returns:
+        Truncated string or None if value is None
+    """
+    if value is None:
+        return None
+
+    s = str(value)
+    if len(s) > max_length:
+        return s[: max_length - 3] + "..."
+    return s
+
+
+def register() -> None:
+    """Register all frontend emitter callbacks."""
+    register_callback("pre_tool_call", on_pre_tool_call)
+    register_callback("post_tool_call", on_post_tool_call)
+    register_callback("stream_event", on_stream_event)
+    register_callback("invoke_agent", on_invoke_agent)
+    logger.debug("Frontend emitter callbacks registered")
+
+
+# Auto-register callbacks when this module is imported
+register()

code_puppy/plugins/hook_creator/__init__.py

@@ -0,0 +1 @@
+# Hook Creator Plugin

code_puppy/plugins/hook_creator/register_callbacks.py

@@ -0,0 +1,33 @@
+"""
+Hook Creator Plugin - Simple command that injects MCP prompt
+"""
+
+from code_puppy.callbacks import register_callback
+from code_puppy.mcp_prompts.hook_creator import HOOK_CREATION_PROMPT
+from code_puppy.messaging import emit_info
+
+
+def _custom_help():
+    """Help entries for create-hook commands."""
+    return [
+        ("create-hook", "Get help creating Code Puppy hooks"),
+    ]
+
+
+def _handle_custom_command(command: str, name: str):
+    """Handle /create-hook command.
+
+    Displays hook creation documentation and sends to model with context.
+    """
+    if name != "create-hook":
+        return None
+
+    emit_info(HOOK_CREATION_PROMPT)
+
+    # Send the prompt to the model with the hook docs as context
+    return "I need help creating a hook for Code Puppy. Here's the documentation above. Can you help me?"
+
+
+# Register the custom command
+register_callback("custom_command_help", _custom_help)
+register_callback("custom_command", _handle_custom_command)

code_puppy/plugins/hook_manager/__init__.py

@@ -0,0 +1 @@
+"""Hook Manager plugin – interactive TUI for managing Claude Code hooks."""

code_puppy/plugins/hook_manager/config.py

@@ -0,0 +1,290 @@
+"""
+Helpers for reading and writing hook configurations from both global and project sources.
+
+Supports:
+- Global hooks: ~/.code_puppy/hooks.json
+- Project hooks: .claude/settings.json
+
+Hooks from both sources are loaded and can be managed independently in the TUI.
+"""
+
+import copy
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Literal, Optional
+
+logger = logging.getLogger(__name__)
+
+_SETTINGS_FILENAME = ".claude/settings.json"
+_GLOBAL_HOOKS_FILE = os.path.expanduser("~/.code_puppy/hooks.json")
+
+HookSource = Literal["project", "global"]
+
+
+def _find_settings_path() -> Path:
+    """Return the path to .claude/settings.json, searching from cwd upward."""
+    cwd = Path.cwd()
+    for parent in [cwd, *cwd.parents]:
+        candidate = parent / _SETTINGS_FILENAME
+        if candidate.exists():
+            return candidate
+    return cwd / _SETTINGS_FILENAME
+
+
+def _load_global_hooks_config() -> Dict[str, Any]:
+    """Load hooks from ~/.code_puppy/hooks.json."""
+    path = Path(_GLOBAL_HOOKS_FILE)
+    if not path.exists():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+        # Handle both wrapped {"hooks": {...}} and direct format
+        if "hooks" in data and isinstance(data["hooks"], dict):
+            return data.get("hooks", {})
+        return data
+    except Exception as exc:
+        logger.warning("Failed to parse global hooks from %s: %s", path, exc)
+        return {}
+
+
+def _load_project_hooks_config() -> Dict[str, Any]:
+    """Load hooks from .claude/settings.json."""
+    path = _find_settings_path()
+    if not path.exists():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+        return data.get("hooks", {})
+    except Exception as exc:
+        logger.warning("Failed to parse project hooks from %s: %s", path, exc)
+        return {}
+
+
+def load_hooks_config() -> Dict[str, Any]:
+    """Load raw hooks config from .claude/settings.json (project only).
+
+    Returns the value of the top-level "hooks" key, or {} if absent/unreadable.
+    Note: For the TUI, we load hooks from both sources separately.
+    """
+    return _load_project_hooks_config()
+
+
+def load_all_hooks_config() -> Dict[str, Any]:
+    """Load and merge hooks from both global and project sources.
+
+    Returns a merged configuration with all hooks.
+    """
+    global_hooks = _load_global_hooks_config()
+    project_hooks = _load_project_hooks_config()
+
+    # Simple merge: combine hook groups
+    merged = {}
+    for event_type in set(list(global_hooks.keys()) + list(project_hooks.keys())):
+        if event_type.startswith("_"):
+            # Skip comment keys
+            merged[event_type] = project_hooks.get(event_type) or global_hooks.get(
+                event_type
+            )
+            continue
+
+        global_groups = (
+            global_hooks.get(event_type, [])
+            if isinstance(global_hooks.get(event_type), list)
+            else []
+        )
+        project_groups = (
+            project_hooks.get(event_type, [])
+            if isinstance(project_hooks.get(event_type), list)
+            else []
+        )
+
+        if global_groups or project_groups:
+            merged[event_type] = global_groups + project_groups
+
+    return merged
+
+
+def save_hooks_config(hooks: Dict[str, Any]) -> Path:
+    """Persist hooks config back to .claude/settings.json.
+
+    Performs a read-modify-write so other top-level keys are preserved.
+    Returns the path written.
+    """
+    path = _find_settings_path()
+    existing: Dict[str, Any] = {}
+    if path.exists():
+        try:
+            existing = json.loads(path.read_text(encoding="utf-8"))
+        except Exception:
+            existing = {}
+    existing["hooks"] = hooks
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(existing, indent=2) + "\n", encoding="utf-8")
+    logger.debug("Saved hooks config to %s", path)
+    return path
+
+
+def save_global_hooks_config(hooks: Dict[str, Any]) -> Path:
+    """Persist hooks config to ~/.code_puppy/hooks.json.
+
+    Returns the path written.
+    """
+    path = Path(_GLOBAL_HOOKS_FILE)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(hooks, indent=2) + "\n", encoding="utf-8")
+    logger.debug("Saved global hooks config to %s", path)
+    return path
+
+
+class HookEntry:
+    """Flat, mutable representation of a single hook for the TUI."""
+
+    __slots__ = (
+        "event_type",
+        "matcher",
+        "hook_type",
+        "command",
+        "timeout",
+        "enabled",
+        "hook_id",
+        "source",
+        "_group_index",
+        "_hook_index",
+    )
+
+    def __init__(
+        self,
+        event_type: str,
+        matcher: str,
+        hook_type: str,
+        command: str,
+        timeout: int = 5000,
+        enabled: bool = True,
+        hook_id: Optional[str] = None,
+        source: HookSource = "project",
+        group_index: int = 0,
+        hook_index: int = 0,
+    ) -> None:
+        self.event_type = event_type
+        self.matcher = matcher
+        self.hook_type = hook_type
+        self.command = command
+        self.timeout = timeout
+        self.enabled = enabled
+        self.hook_id = hook_id
+        self.source = source
+        self._group_index = group_index
+        self._hook_index = hook_index
+
+    @property
+    def display_command(self) -> str:
+        """Command truncated to 60 chars for list display."""
+        cmd = self.command
+        return cmd[:57] + "..." if len(cmd) > 60 else cmd
+
+    @property
+    def display_matcher(self) -> str:
+        """Matcher truncated to 40 chars."""
+        m = self.matcher
+        return m[:37] + "..." if len(m) > 40 else m
+
+
+def flatten_hooks(
+    hooks_config: Dict[str, Any], source: HookSource = "project"
+) -> List[HookEntry]:
+    """Convert nested hooks config into a flat list of HookEntry objects.
+
+    Each entry remembers its group_index and hook_index for round-trip
+    serialisation, and which source it came from.
+    """
+    entries: List[HookEntry] = []
+    for event_type, groups in hooks_config.items():
+        if event_type.startswith("_"):
+            # Skip comment keys
+            continue
+        if not isinstance(groups, list):
+            continue
+        for g_idx, group in enumerate(groups):
+            if not isinstance(group, dict):
+                continue
+            matcher = group.get("matcher", "*")
+            for h_idx, hook in enumerate(group.get("hooks", [])):
+                if not isinstance(hook, dict):
+                    continue
+                command = hook.get("command") or hook.get("prompt", "")
+                entries.append(
+                    HookEntry(
+                        event_type=event_type,
+                        matcher=matcher,
+                        hook_type=hook.get("type", "command"),
+                        command=command,
+                        timeout=hook.get("timeout", 5000),
+                        enabled=hook.get("enabled", True),
+                        hook_id=hook.get("id"),
+                        source=source,
+                        group_index=g_idx,
+                        hook_index=h_idx,
+                    )
+                )
+    return entries
+
+
+def flatten_all_hooks() -> List[HookEntry]:
+    """Load and flatten hooks from both global and project sources.
+
+    Returns a combined list with source information for each hook.
+    """
+    global_config = _load_global_hooks_config()
+    project_config = _load_project_hooks_config()
+
+    global_entries = flatten_hooks(global_config, source="global")
+    project_entries = flatten_hooks(project_config, source="project")
+
+    # Project hooks first for easier viewing
+    return project_entries + global_entries
+
+
+def toggle_hook_enabled(
+    hooks_config: Dict[str, Any],
+    event_type: str,
+    group_index: int,
+    hook_index: int,
+    enabled: bool,
+) -> Dict[str, Any]:
+    """Return a deep copy of hooks_config with the specified hook toggled.
+
+    Does NOT write to disk – call save_hooks_config() afterwards.
+    """
+    cfg = copy.deepcopy(hooks_config)
+    try:
+        hook = cfg[event_type][group_index]["hooks"][hook_index]
+        hook["enabled"] = enabled
+    except (KeyError, IndexError, TypeError) as exc:
+        logger.warning("toggle_hook_enabled: cannot find hook (%s)", exc)
+    return cfg
+
+
+def delete_hook(
+    hooks_config: Dict[str, Any],
+    event_type: str,
+    group_index: int,
+    hook_index: int,
+) -> Dict[str, Any]:
+    """Return a deep copy of hooks_config with the specified hook removed.
+
+    Empty groups and event keys are pruned automatically.
+    Does NOT write to disk – call save_hooks_config() afterwards.
+    """
+    cfg = copy.deepcopy(hooks_config)
+    try:
+        group = cfg[event_type][group_index]
+        group["hooks"].pop(hook_index)
+        if not group["hooks"]:
+            cfg[event_type].pop(group_index)
+        if not cfg[event_type]:
+            del cfg[event_type]
+    except (KeyError, IndexError, TypeError) as exc:
+        logger.warning("delete_hook: cannot remove hook (%s)", exc)
+    return cfg