code-muse 0.0.1__py3-none-any.whl

code_muse/plugins/file_permission_handler/register_callbacks.py

@@ -0,0 +1,441 @@
+"""File Permission Handler Plugin.
+
+This plugin handles user permission prompts for file operations,
+providing a consistent and extensible permission system.
+"""
+
+import contextlib
+import difflib
+import threading
+from pathlib import Path
+from typing import Any
+
+from rich.text import Text as RichText
+
+from code_muse.callbacks import register_callback
+from code_muse.config import get_diff_context_lines, get_yolo_mode
+from code_muse.messaging import emit_warning
+from code_muse.tools.common import (
+    _find_best_window,
+    get_user_approval,
+)
+
+# Lock for preventing multiple simultaneous permission prompts.
+# FREE-THREADED: Sync-only file confirmation; keep threading.Lock.
+_FILE_CONFIRMATION_LOCK = threading.Lock()
+
+# Thread-local storage for user feedback from permission prompts
+_thread_local = threading.local()
+
+
+def get_last_user_feedback() -> str | None:
+    """Get the last user feedback from a permission prompt in this thread.
+
+    Returns:
+        The user feedback string, or None if no feedback was provided.
+    """
+    return getattr(_thread_local, "last_user_feedback", None)
+
+
+def _set_user_feedback(feedback: str | None) -> None:
+    """Store user feedback in thread-local storage."""
+    _thread_local.last_user_feedback = feedback
+
+
+def clear_user_feedback() -> None:
+    """Clear any stored user feedback."""
+    _thread_local.last_user_feedback = None
+
+
+def set_diff_already_shown(shown: bool = True) -> None:
+    """Mark that a diff preview was already shown during permission prompt."""
+    _thread_local.diff_already_shown = shown
+
+
+def was_diff_already_shown() -> bool:
+    """Check if a diff was already shown during the permission prompt.
+
+    Returns:
+        True if diff was shown, False otherwise
+    """
+    return getattr(_thread_local, "diff_already_shown", False)
+
+
+def clear_diff_shown_flag() -> None:
+    """Clear the diff-already-shown flag."""
+    _thread_local.diff_already_shown = False
+
+
+# Diff formatting is now handled by common.format_diff_with_colors()
+# Arrow selector and approval UI now handled by common.get_user_approval()
+
+
+def _preview_delete_snippet(file_path: str, snippet: str) -> str | None:
+    """Generate a preview diff for deleting a snippet without modifying the file."""
+    try:
+        file_path = Path(file_path).resolve()
+        if not file_path.exists() or not file_path.is_file():
+            return None
+
+        with open(file_path, encoding="utf-8", errors="surrogateescape") as f:
+            original = f.read()
+
+        # Sanitize any surrogate characters
+        with contextlib.suppress(UnicodeEncodeError, UnicodeDecodeError):
+            original = original.encode("utf-8", errors="surrogatepass").decode(
+                "utf-8", errors="replace"
+            )
+
+        if snippet not in original:
+            return None
+
+        modified = original.replace(snippet, "")
+        diff_text = "".join(
+            difflib.unified_diff(
+                original.splitlines(keepends=True),
+                modified.splitlines(keepends=True),
+                fromfile=f"a/{file_path.name}",
+                tofile=f"b/{file_path.name}",
+                n=get_diff_context_lines(),
+            )
+        )
+        return diff_text
+    except Exception:
+        return None
+
+
+def _preview_write_to_file(
+    file_path: str, content: str, overwrite: bool = False
+) -> str | None:
+    """Generate a preview diff for writing to a file without modifying it."""
+    try:
+        file_path = Path(file_path).resolve()
+        exists = file_path.exists()
+
+        if exists and not overwrite:
+            return None
+
+        diff_lines = difflib.unified_diff(
+            [] if not exists else [""],
+            content.splitlines(keepends=True),
+            fromfile="/dev/null" if not exists else f"a/{file_path.name}",
+            tofile=f"b/{file_path.name}",
+            n=get_diff_context_lines(),
+        )
+        return "".join(diff_lines)
+    except Exception:
+        return None
+
+
+def _preview_replace_in_file(
+    file_path: str, replacements: list[dict[str, str]]
+) -> str | None:
+    """Generate a preview diff for replacing text in a file without modifying the file."""
+    try:
+        file_path = Path(file_path).resolve()
+
+        with open(file_path, encoding="utf-8", errors="surrogateescape") as f:
+            original = f.read()
+
+        # Sanitize any surrogate characters
+        with contextlib.suppress(UnicodeEncodeError, UnicodeDecodeError):
+            original = original.encode("utf-8", errors="surrogatepass").decode(
+                "utf-8", errors="replace"
+            )
+
+        modified = original
+        for rep in replacements:
+            old_snippet = rep.get("old_str", "")
+            new_snippet = rep.get("new_str", "")
+
+            if old_snippet and old_snippet in modified:
+                modified = modified.replace(old_snippet, new_snippet)
+                continue
+
+            # Use the same logic as file_modifications for fuzzy matching
+            orig_lines = modified.splitlines()
+            loc, score = _find_best_window(orig_lines, old_snippet)
+
+            if score < 0.95 or loc is None:
+                return None
+
+            start, end = loc
+            had_trailing_newline = modified.endswith("\n")
+            prefix = "\n".join(orig_lines[:start])
+            suffix = "\n".join(orig_lines[end:])
+            parts = []
+            if prefix:
+                parts.append(prefix)
+            parts.append(new_snippet.rstrip("\n"))
+            if suffix:
+                parts.append(suffix)
+            modified = "\n".join(parts)
+            if had_trailing_newline and not modified.endswith("\n"):
+                modified += "\n"
+
+        if modified == original:
+            return None
+
+        diff_text = "".join(
+            difflib.unified_diff(
+                original.splitlines(keepends=True),
+                modified.splitlines(keepends=True),
+                fromfile=f"a/{file_path.name}",
+                tofile=f"b/{file_path.name}",
+                n=get_diff_context_lines(),
+            )
+        )
+        return diff_text
+    except Exception:
+        return None
+
+
+def _preview_delete_file(file_path: str) -> str | None:
+    """Whole-file deletes intentionally do not show content diffs."""
+    return None
+
+
+def prompt_for_file_permission(
+    file_path: str,
+    operation: str,
+    preview: str | None = None,
+    message_group: str | None = None,
+) -> tuple[bool, str | None]:
+    """Prompt the user for permission to perform a file operation.
+
+    This function provides a unified permission prompt system for all file operations.
+
+    Args:
+        file_path: Path to the file being modified.
+        operation: Description of the operation (e.g., "edit", "delete", "create").
+        preview: Optional preview of changes (diff or content preview).
+        message_group: Optional message group for organizing output.
+
+    Returns:
+        Tuple of (confirmed: bool, user_feedback: str | None)
+        - confirmed: True if permission is granted, False otherwise
+        - user_feedback: Optional feedback message from user to send back to the model
+    """
+    yolo_mode = get_yolo_mode()
+
+    # Skip confirmation only if in yolo mode (removed TTY check for better compatibility)
+    if yolo_mode:
+        return True, None
+
+    # Try to acquire the lock to prevent multiple simultaneous prompts
+    confirmation_lock_acquired = _FILE_CONFIRMATION_LOCK.acquire(blocking=False)
+    if not confirmation_lock_acquired:
+        emit_warning(
+            "Another file operation is currently awaiting confirmation",
+            message_group=message_group,
+        )
+        return False, None
+
+    try:
+        # Build panel content
+        panel_content = RichText()
+        panel_content.append("🔒 Requesting permission to ", style="bold yellow")
+        panel_content.append(operation, style="bold cyan")
+        panel_content.append(":\n", style="bold yellow")
+        panel_content.append("📄 ", style="dim")
+        panel_content.append(file_path, style="bold white")
+
+        # Use the common approval function
+        confirmed, user_feedback = get_user_approval(
+            title="File Operation",
+            content=panel_content,
+            preview=preview,
+            border_style="dim white",
+        )
+
+        return confirmed, user_feedback
+
+    finally:
+        if confirmation_lock_acquired:
+            _FILE_CONFIRMATION_LOCK.release()
+
+
+def handle_edit_file_permission(
+    context: Any,
+    file_path: str,
+    operation_type: str,
+    operation_data: Any,
+    message_group: str | None = None,
+) -> bool:
+    """Handle permission for edit_file operations with automatic preview generation.
+
+    Args:
+        context: The operation context
+        file_path: Path to the file being operated on
+        operation_type: Type of edit operation ('write', 'replace', 'delete_snippet')
+        operation_data: Operation-specific data (content, replacements, snippet, etc.)
+        message_group: Optional message group
+
+    Returns:
+        True if permission granted, False if denied
+    """
+    preview = None
+
+    if operation_type == "write":
+        content = operation_data.get("content", "")
+        overwrite = operation_data.get("overwrite", False)
+        preview = _preview_write_to_file(file_path, content, overwrite)
+        operation_desc = "write to"
+    elif operation_type == "replace":
+        replacements = operation_data.get("replacements", [])
+        preview = _preview_replace_in_file(file_path, replacements)
+        operation_desc = "replace text in"
+    elif operation_type == "delete_snippet":
+        snippet = operation_data.get("delete_snippet", "")
+        preview = _preview_delete_snippet(file_path, snippet)
+        operation_desc = "delete snippet from"
+    else:
+        operation_desc = f"perform {operation_type} operation on"
+
+    confirmed, user_feedback = prompt_for_file_permission(
+        file_path, operation_desc, preview, message_group
+    )
+    # Store feedback in thread-local storage so the tool can access it
+    _set_user_feedback(user_feedback)
+    return confirmed
+
+
+def handle_delete_file_permission(
+    context: Any,
+    file_path: str,
+    message_group: str | None = None,
+) -> bool:
+    """Handle permission for delete_file operations with automatic preview generation.
+
+    Args:
+        context: The operation context
+        file_path: Path to the file being deleted
+        message_group: Optional message group
+
+    Returns:
+        True if permission granted, False if denied
+    """
+    preview = _preview_delete_file(file_path)
+    confirmed, user_feedback = prompt_for_file_permission(
+        file_path, "delete", preview, message_group
+    )
+    # Store feedback in thread-local storage so the tool can access it
+    _set_user_feedback(user_feedback)
+    return confirmed
+
+
+def handle_file_permission(
+    context: Any,
+    file_path: str,
+    operation: str,
+    preview: str | None = None,
+    message_group: str | None = None,
+    operation_data: Any = None,
+) -> bool:
+    """Callback handler for file permission checks.
+
+    This function is called by file operations to check for user permission.
+    It returns True if the operation should proceed, False if it should be cancelled.
+
+    Args:
+        context: The operation context
+        file_path: Path to the file being operated on
+        operation: Description of the operation
+        preview: Optional preview of changes (deprecated - use operation_data instead)
+        message_group: Optional message group
+        operation_data: Operation-specific data for preview generation
+
+    Returns:
+        True if permission granted, False if denied
+    """
+    # Generate preview from operation_data if provided
+    if operation_data is not None:
+        preview = _generate_preview_from_operation_data(
+            file_path, operation, operation_data
+        )
+
+    confirmed, user_feedback = prompt_for_file_permission(
+        file_path, operation, preview, message_group
+    )
+    # Store feedback in thread-local storage so the tool can access it
+    _set_user_feedback(user_feedback)
+    return confirmed
+
+
+def _generate_preview_from_operation_data(
+    file_path: str, operation: str, operation_data: Any
+) -> str | None:
+    """Generate preview diff from operation data.
+
+    Args:
+        file_path: Path to the file
+        operation: Type of operation
+        operation_data: Operation-specific data
+
+    Returns:
+        Preview diff or None if generation fails
+    """
+    try:
+        if operation == "delete":
+            return _preview_delete_file(file_path)
+        elif operation == "write":
+            content = operation_data.get("content", "")
+            overwrite = operation_data.get("overwrite", False)
+            return _preview_write_to_file(file_path, content, overwrite)
+        elif operation == "delete snippet from":
+            snippet = operation_data.get("snippet", "")
+            return _preview_delete_snippet(file_path, snippet)
+        elif operation == "replace text in":
+            replacements = operation_data.get("replacements", [])
+            return _preview_replace_in_file(file_path, replacements)
+        elif operation == "edit_file":
+            # Handle edit_file operations
+            if "delete_snippet" in operation_data:
+                return _preview_delete_snippet(
+                    file_path, operation_data["delete_snippet"]
+                )
+            elif "replacements" in operation_data:
+                return _preview_replace_in_file(
+                    file_path, operation_data["replacements"]
+                )
+            elif "content" in operation_data:
+                content = operation_data.get("content", "")
+                overwrite = operation_data.get("overwrite", False)
+                return _preview_write_to_file(file_path, content, overwrite)
+
+        return None
+    except Exception:
+        return None
+
+
+def get_permission_handler_help() -> str:
+    """Return help information for the file permission handler."""
+    return """File Permission Handler Plugin:
+- Unified permission prompts for all file operations
+- YOLO mode support for automatic approval
+- Thread-safe confirmation system
+- Consistent user experience across file operations
+- Detailed preview support with diff highlighting
+- Automatic preview generation from operation data"""
+
+
+def get_file_permission_prompt_additions() -> str:
+    """Return file permission handling prompt additions for agents."""
+    if get_yolo_mode():
+        return ""
+
+    return """
+## User Approval System
+
+When file operations are rejected, the response includes a `user_feedback` field:
+- If `user_feedback` has text: implement their suggestion and retry the operation.
+- If `user_feedback` is empty: stop and ask the user what they want instead.
+- Never retry the exact same rejected operation without changes.
+"""
+
+
+# Register the callback for file permission handling
+register_callback("file_permission", handle_file_permission)
+
+# Register the prompt hook for file permission instructions
+register_callback("load_prompt", get_file_permission_prompt_additions)

code_muse/plugins/filter_engine/__init__.py

@@ -0,0 +1,30 @@
+"""Filter Engine plugin for Muse.
+
+Intercepts shell commands, classifies them, applies compression strategies,
+and returns compact results to reduce token usage.
+"""
+
+from code_muse.plugins.filter_engine.classifier import CommandClassifier
+from code_muse.plugins.filter_engine.dispatcher import FilterDispatcher
+from code_muse.plugins.filter_engine.register_callbacks import (
+    filter_engine_callback,
+)
+from code_muse.plugins.filter_engine.registry import StrategyRegistry
+
+# Import strategies so they self-register with the strategy registry
+from code_muse.plugins.filter_engine.strategies import (  # noqa: F401
+    code,
+    git,
+    lint,
+    test,
+)
+from code_muse.plugins.filter_engine.verbosity import VerbosityLevel, get_verbosity
+
+__all__ = [
+    "CommandClassifier",
+    "FilterDispatcher",
+    "StrategyRegistry",
+    "VerbosityLevel",
+    "filter_engine_callback",
+    "get_verbosity",
+]

code_muse/plugins/filter_engine/classifier.py

@@ -0,0 +1,153 @@
+"""Command classifier for the filter engine.
+
+Uses pre-compiled regex patterns to classify shell commands into categories
+that determine which compression strategy is applied.
+"""
+
+import re
+from typing import ClassVar
+
+
+class CommandClassifier:
+    """Classify shell commands into categories using regex patterns."""
+
+    # Pre-compiled pattern sets for each category
+    PATTERNS: ClassVar[dict[str, list[re.Pattern[str]]]] = {
+        "git": [
+            re.compile(r"^\s*git\s+status"),
+            re.compile(r"^\s*git\s+log"),
+            re.compile(r"^\s*git\s+diff"),
+            re.compile(r"^\s*git\s+add"),
+            re.compile(r"^\s*git\s+commit"),
+            re.compile(r"^\s*git\s+push"),
+            re.compile(r"^\s*git\s+pull"),
+            re.compile(r"^\s*git\s+fetch"),
+            re.compile(r"^\s*git\s+branch"),
+            re.compile(r"^\s*git\s+checkout"),
+            re.compile(r"^\s*git\s+merge"),
+            re.compile(r"^\s*git\s+rebase"),
+            re.compile(r"^\s*git\s+show"),
+            re.compile(r"^\s*git\s+blame"),
+            re.compile(r"^\s*git\s+stash"),
+            re.compile(r"^\s*git\s+reset"),
+            re.compile(r"^\s*git\s+tag"),
+            re.compile(r"^\s*git\s+clone"),
+            re.compile(r"^\s*git\s+init"),
+            re.compile(r"^\s*git\s+remote"),
+            re.compile(r"^\s*git\s+config"),
+            re.compile(r"^\s*git\s+\S"),  # catch-all for any other git command
+        ],
+        "test": [
+            re.compile(r"^\s*pytest\b"),
+            re.compile(r"^\s*python\s+-m\s+pytest\b"),
+            re.compile(r"^\s*vitest\b"),
+            re.compile(r"^\s*jest\b"),
+            re.compile(r"^\s*cargo\s+test\b"),
+            re.compile(r"^\s*rspec\b"),
+            re.compile(r"^\s*go\s+test\b"),
+            re.compile(r"^\s*npm\s+test\b"),
+            re.compile(r"^\s*yarn\s+test\b"),
+            re.compile(r"^\s*npx\s+jest\b"),
+            re.compile(r"^\s*npx\s+vitest\b"),
+            re.compile(r"^\s*python\s+-m\s+unittest\b"),
+            re.compile(r"^\s*mvn\s+test\b"),
+            re.compile(r"^\s*gradle\s+test\b"),
+            re.compile(r"^\s*tox\b"),
+            re.compile(r"^\s*nox\b"),
+        ],
+        "lint": [
+            re.compile(r"^\s*ruff\b"),
+            re.compile(r"^\s*eslint\b"),
+            re.compile(r"^\s*tsc\b"),
+            re.compile(r"^\s*golangci-lint\b"),
+            re.compile(r"^\s*rubocop\b"),
+            re.compile(r"^\s*flake8\b"),
+            re.compile(r"^\s*mypy\b"),
+            re.compile(r"^\s*pyright\b"),
+            re.compile(r"^\s*cargo\s+clippy\b"),
+            re.compile(r"^\s*clippy\b"),
+            re.compile(r"^\s*shellcheck\b"),
+            re.compile(r"^\s*markdownlint\b"),
+            re.compile(r"^\s*pylint\b"),
+            re.compile(r"^\s*black\s+--check\b"),
+            re.compile(r"^\s*isort\s+--check\b"),
+            re.compile(r"^\s*prettier\s+--check\b"),
+        ],
+        "code": [
+            re.compile(r"^\s*cat\b"),
+            re.compile(r"^\s*head\b"),
+            re.compile(r"^\s*tail\b"),
+            re.compile(r"^\s*less\b"),
+            re.compile(r"^\s*bat\b"),
+            re.compile(r"^\s*nl\b"),
+            re.compile(r"^\s*sed\b"),
+            re.compile(r"^\s*awk\b"),
+            re.compile(r"^\s*grep\b"),
+            re.compile(r"^\s*rg\b"),
+            re.compile(r"^\s*find\b"),
+            re.compile(r"^\s*ls\b"),
+            re.compile(r"^\s*tree\b"),
+            re.compile(r"^\s*wc\b"),
+            re.compile(r"^\s*sort\b"),
+            re.compile(r"^\s*uniq\b"),
+            re.compile(r"^\s*xargs\b"),
+            re.compile(r"^\s*cut\b"),
+            re.compile(r"^\s*tr\b"),
+            re.compile(r"^\s*dd\b"),
+            re.compile(r"^\s*diff\b"),
+            re.compile(r"^\s*cmp\b"),
+        ],
+        "read": [
+            re.compile(r"^\s*cat\b"),
+            re.compile(r"^\s*head\b"),
+            re.compile(r"^\s*tail\b"),
+            re.compile(r"^\s*less\b"),
+            re.compile(r"^\s*bat\b"),
+        ],
+    }
+
+    @classmethod
+    def classify(cls, command: str) -> str:
+        """Classify a shell command into a category.
+
+        Categories are checked in priority order: git, test, lint, code, read.
+        The ``read`` category is a subset of ``code``; if a command matches both,
+        it is classified as ``read`` because read is more specific.
+
+        Args:
+            command: The raw shell command string.
+
+        Returns:
+            One of ``git``, ``test``, ``lint``, ``code``, ``read``, or ``unknown``.
+        """
+        if not command or not command.strip():
+            return "unknown"
+
+        stripped = command.strip()
+
+        # Check git first (most specific)
+        for pattern in cls.PATTERNS["git"]:
+            if pattern.search(stripped):
+                return "git"
+
+        # Check test
+        for pattern in cls.PATTERNS["test"]:
+            if pattern.search(stripped):
+                return "test"
+
+        # Check lint
+        for pattern in cls.PATTERNS["lint"]:
+            if pattern.search(stripped):
+                return "lint"
+
+        # Check read (subset of code, checked before code)
+        for pattern in cls.PATTERNS["read"]:
+            if pattern.search(stripped):
+                return "read"
+
+        # Check code
+        for pattern in cls.PATTERNS["code"]:
+            if pattern.search(stripped):
+                return "code"
+
+        return "unknown"