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

code_puppy_core_plugins/force_push_guard/detector.py

@@ -0,0 +1,96 @@
+"""Pattern detection for git force push commands.
+
+Detects force push patterns in shell commands, covering all the sneaky
+ways git lets you wreck a remote branch.
+"""
+
+import re
+from dataclasses import dataclass
+
+
+@dataclass
+class ForcePushMatch:
+    """Result of a force push pattern match."""
+
+    pattern_name: str
+    description: str
+
+
+# Matches shell operators that precede a new command in a pipeline/chain.
+# E.g. "cd foo && git push --force" or "true || git push -f"
+_SHELL_OPERATOR_RE = re.compile(r"(?:^|&&|\|\||;|\|)\s*git\s+push\b", re.MULTILINE)
+
+# Ordered by specificity — first match wins.
+# Each tuple: (compiled regex, human-readable name, what it catches)
+_FORCE_PUSH_PATTERNS: list[tuple[re.Pattern, str, str]] = [
+    (
+        re.compile(r"\bgit\s+push\b.*--force-with-lease"),
+        "--force-with-lease",
+        "force push with lease (safer, but still rewrites history)",
+    ),
+    (
+        re.compile(r"\bgit\s+push\b.*--force-if-includes"),
+        "--force-if-includes",
+        "force push with includes check (still rewrites history)",
+    ),
+    (
+        re.compile(r"\bgit\s+push\b.*--force"),
+        "--force",
+        "force push (rewrites remote history)",
+    ),
+    (
+        re.compile(r"\bgit\s+push\b.*\s-f\b"),
+        "-f",
+        "force push shorthand (rewrites remote history)",
+    ),
+    (
+        re.compile(r"\bgit\s+push\b.*\s-F\b"),
+        "-F",
+        "force push shorthand (rewrites remote history)",
+    ),
+    # The +refspec syntax: git push origin +main, git push origin +HEAD:main
+    (
+        re.compile(r"\bgit\s+push\b.*\s\+"),
+        "+refspec",
+        "force push via +refspec prefix (rewrites remote history)",
+    ),
+]
+
+
+def _is_git_push_a_command(command: str) -> bool:
+    """Check that 'git push' is an actual command, not a string argument.
+
+    Handles compound commands like "cd foo && git push --force" while
+    avoiding false positives like "echo 'git push --force'".
+
+    Args:
+        command: The shell command string to inspect.
+
+    Returns:
+        True if 'git push' appears as an actual command invocation.
+    """
+    return bool(_SHELL_OPERATOR_RE.search(command))
+
+
+def detect_force_push(command: str) -> ForcePushMatch | None:
+    """Check if a shell command contains a git force push.
+
+    Args:
+        command: The shell command string to inspect.
+
+    Returns:
+        ForcePushMatch if a force push pattern is found, None otherwise.
+    """
+    # Quick pre-filter: skip entirely if "push" isn't even in the command
+    if "push" not in command:
+        return None
+
+    # Ensure 'git push' is an actual command, not a string argument
+    if not _is_git_push_a_command(command):
+        return None
+
+    for pattern, name, description in _FORCE_PUSH_PATTERNS:
+        if pattern.search(command):
+            return ForcePushMatch(pattern_name=name, description=description)
+
+    return None

code_puppy_core_plugins/force_push_guard/register_callbacks.py

@@ -0,0 +1,161 @@
+"""Callback registration for the force push guard plugin.
+
+Hooks into the run_shell_command phase to intercept git force push
+commands and prompt the user for approval before allowing them through.
+Returns {"blocked": True} to deny, None to allow.
+"""
+
+import sys
+from typing import Any, Dict, Optional
+
+from rich.text import Text
+
+from code_puppy.callbacks import register_callback
+from code_puppy.config import (
+    get_disable_dangerous_command_guard,
+    is_dangerous_command_allowlisted,
+)
+from code_puppy.messaging import emit_info, emit_warning
+from code_puppy_core_plugins.force_push_guard.detector import detect_force_push
+
+
+def _is_interactive() -> bool:
+    """Check if we're in an interactive terminal that can show prompts."""
+    try:
+        return sys.stdin.isatty()
+    except (AttributeError, OSError):
+        return False
+
+
+async def force_push_guard_callback(
+    context: Any, command: str, cwd: Optional[str] = None, timeout: int = 60
+) -> Optional[Dict[str, Any]]:
+    """Intercept shell commands containing git force push operations.
+
+    When a force push is detected:
+    - Interactive TTY: prompt the user with approve/reject options.
+    - Non-interactive (CI, sub-agent, piped): hard-block with an error.
+
+    This runs on *every* shell command, but the heavy lifting (regex
+    matching) is gated behind a cheap "push" substring check inside
+    detect_force_push().
+
+    Args:
+        context: Execution context (unused).
+        command: The shell command about to run.
+        cwd: Working directory (unused).
+        timeout: Command timeout (unused).
+
+    Returns:
+        None if the command is safe to proceed or user approved it.
+        Dict with blocked=True if a force push was detected and rejected.
+    """
+    # Check if dangerous command guards are disabled
+    if get_disable_dangerous_command_guard():
+        return None
+
+    match = detect_force_push(command)
+    if match is None:
+        return None
+
+    # Granular allowlist: trusted force-push patterns bypass the guard while
+    # everything else stays protected (unlike the all-or-nothing disable flag).
+    if is_dangerous_command_allowlisted(match.pattern_name):
+        emit_info(
+            f"Allowlisted force-push pattern '{match.pattern_name}' -- "
+            "proceeding (guard still active for other patterns)."
+        )
+        return None
+
+    # --- Interactive TTY: ask the user ---
+    if _is_interactive():
+        return await _prompt_user_approval(command, match)
+
+    # --- Non-interactive: hard-block ---
+    return _block_command(command, match)
+
+
+async def _prompt_user_approval(command: str, match: Any) -> Optional[Dict[str, Any]]:
+    """Show an interactive approval prompt for the detected force push.
+
+    Args:
+        command: The original shell command.
+        match: The ForcePushMatch from the detector.
+
+    Returns:
+        None if user approves, Dict with blocked=True if rejected.
+    """
+    from code_puppy.tools.common import get_user_approval_async
+
+    panel_content = Text()
+    panel_content.append("⚠️  Force push detected: ", style="bold yellow")
+    panel_content.append(match.pattern_name, style="bold red")
+    panel_content.append("\n", style="")
+    panel_content.append(f"  {match.description}", style="dim")
+    panel_content.append("\n\n", style="")
+    panel_content.append("$ ", style="bold green")
+    panel_content.append(command, style="bold white")
+    panel_content.append(
+        "\n\nForce pushing rewrites remote history and can destroy others' work.",
+        style="yellow",
+    )
+
+    confirmed, user_feedback = await get_user_approval_async(
+        title="Force Push Guard 🛡️",
+        content=panel_content,
+        border_style="red",
+    )
+
+    if confirmed:
+        emit_info("⚠️  Force push approved — proceeding with caution.")
+        return None  # Allow the command through
+
+    # Rejected
+    reason = user_feedback or "User rejected force push"
+    return {
+        "blocked": True,
+        "reasoning": f"Force push rejected: {match.pattern_name} — {reason}",
+        "error_message": (
+            f"🛑 Force push rejected. Detected {match.pattern_name} "
+            f"in command:\n  {command}\n"
+            f"  {match.description}\n"
+            f"Feedback: {reason}"
+        ),
+    }
+
+
+def _block_command(command: str, match: Any) -> Dict[str, Any]:
+    """Hard-block a force push in non-interactive contexts.
+
+    Args:
+        command: The original shell command.
+        match: The ForcePushMatch from the detector.
+
+    Returns:
+        Dict with blocked=True and a descriptive error.
+    """
+    error_message = (
+        f"🛑 Force push blocked! Detected {match.pattern_name} "
+        f"in command:\n  {command}\n"
+        f"  {match.description}\n\n"
+        f"Force pushing rewrites remote history and can destroy others' work.\n"
+        f"If you *really* need to force push, use the exact command directly\n"
+        f"in your terminal (outside code puppy) after double-checking the target branch."
+    )
+
+    emit_warning(error_message)
+
+    return {
+        "blocked": True,
+        "reasoning": f"Force push detected: {match.pattern_name} — {match.description}",
+        "error_message": error_message,
+    }
+
+
+def register() -> None:
+    """Register the force push guard callback."""
+    register_callback("run_shell_command", force_push_guard_callback)
+
+
+# Auto-register when this module is imported
+register()

code_puppy_core_plugins/fork/__init__.py

@@ -0,0 +1,7 @@
+"""Fork plugin.
+
+``/fork [@agent] <prompt>`` spawns a sub-agent as a background asyncio
+task -- usable at the idle prompt or mid-run -- and reports the result
+when it lands. ``/forks`` lists fork status; ``/fork cancel <id>`` stops
+a running fork.
+"""