code-muse 0.0.1__py3-none-any.whl

code_muse/plugins/custom_commands/command_discovery.py

@@ -0,0 +1,89 @@
+import logging
+import re
+from pathlib import Path
+
+from code_muse.plugins.custom_commands.command_toml_schema import (
+    CommandDef,
+    parse_command_toml,
+)
+
+logger = logging.getLogger(__name__)
+
+_VALID_NAME_RE = re.compile(r"^[a-zA-Z0-9_-]+$")
+
+_USER_COMMANDS_DIR = Path.home() / ".muse" / "commands"
+_PROJECT_COMMANDS_DIR = Path(".muse") / "commands"
+
+
+def _resolve_namespace(file_path: Path, commands_dir: Path) -> str:
+    """Derive the command namespace from its path relative to *commands_dir*.
+
+    Examples:
+        - ``commands_dir / "fix.toml"`` → ``/fix``
+        - ``commands_dir / "git" / "fix.toml"`` → ``/git:fix``
+    """
+    rel = file_path.relative_to(commands_dir)
+    # Drop the .toml extension and replace path separators with colons
+    namespace = "/" + str(rel.with_suffix("")).replace("/", ":")
+    return namespace
+
+
+def _scan_tier(commands_dir: Path, tier_label: str) -> dict[str, CommandDef]:
+    """Scan a single directory tier for ``*.toml`` command files.
+
+    Returns a mapping of ``namespace → CommandDef``.
+    """
+    discovered: dict[str, CommandDef] = {}
+    if not commands_dir.exists():
+        return discovered
+
+    # Collect both flat and nested files
+    files = sorted(commands_dir.rglob("*.toml"))
+    for file_path in files:
+        # Skip hidden files / directories
+        if any(
+            part.startswith(".") for part in file_path.relative_to(commands_dir).parts
+        ):
+            continue
+
+        name_part = file_path.stem
+        if not _VALID_NAME_RE.match(name_part):
+            logger.warning(
+                "Skipping invalid command filename %s (names must be alphanumeric, hyphens, underscores)",
+                file_path,
+            )
+            continue
+
+        namespace = _resolve_namespace(file_path, commands_dir)
+        try:
+            cmd_def = parse_command_toml(file_path)
+            cmd_def.name = namespace  # override with the namespaced name
+        except ValueError as exc:
+            logger.warning("Failed to load command from %s: %s", file_path, exc)
+            continue
+
+        discovered[namespace] = cmd_def
+
+    return discovered
+
+
+def discover_commands(
+    user_dir: Path | None = None,
+    project_dir: Path | None = None,
+) -> dict[str, CommandDef]:
+    """Discover custom commands from user and project tiers.
+
+    Scans ``~/.muse/commands/**/*.toml`` (user tier) and
+    ``.muse/commands/**/*.toml`` (project tier).  Project
+    definitions override user definitions for the same namespace.
+
+    Returns:
+        Mapping of ``namespace → CommandDef``.
+    """
+    user_tier = _scan_tier(user_dir or _USER_COMMANDS_DIR, "user")
+    project_tier = _scan_tier(project_dir or _PROJECT_COMMANDS_DIR, "project")
+
+    # Project tier overrides user tier
+    merged = dict(user_tier)
+    merged.update(project_tier)
+    return merged

code_muse/plugins/custom_commands/command_toml_schema.py

@@ -0,0 +1,71 @@
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+_KNOWN_FIELDS = {"prompt", "description"}
+
+
+@dataclass
+class CommandDef:
+    """Definition of a custom command loaded from a TOML file."""
+
+    name: str
+    prompt: str
+    description: str = ""
+
+
+def _warn_unknown_fields(data: dict[str, Any], path: Path) -> None:
+    unknown = set(data.keys()) - _KNOWN_FIELDS
+    if unknown:
+        logger.warning(
+            "Unknown fields in command file %s: %s",
+            path,
+            ", ".join(sorted(unknown)),
+        )
+
+
+def parse_command_toml(path: Path) -> CommandDef:
+    """Parse a single command definition from a TOML file.
+
+    Args:
+        path: Path to the ``.toml`` file.
+
+    Returns:
+        ``CommandDef`` with ``name`` derived from the file path,
+        ``prompt`` from the TOML ``prompt`` key, and optional
+        ``description``.
+
+    Raises:
+        ValueError: If ``prompt`` is missing, empty, or not a string.
+    """
+    import tomllib
+
+    raw = path.read_text(encoding="utf-8")
+    data = tomllib.loads(raw)
+
+    if not isinstance(data, dict):
+        raise ValueError(
+            f"Invalid TOML in {path}: expected table, got {type(data).__name__}"
+        )
+
+    _warn_unknown_fields(data, path)
+
+    prompt = data.get("prompt")
+    if prompt is None:
+        raise ValueError(f"Command file {path} is missing required field 'prompt'")
+    if not isinstance(prompt, str):
+        raise ValueError(
+            f"Command file {path}: 'prompt' must be a string, got {type(prompt).__name__}"
+        )
+    if not prompt.strip():
+        raise ValueError(f"Command file {path}: 'prompt' must be a non-empty string")
+
+    description = data.get("description", "")
+    if description is not None and not isinstance(description, str):
+        raise ValueError(f"Command file {path}: 'description' must be a string")
+
+    name = path.stem
+    return CommandDef(name=name, prompt=prompt, description=description or "")

code_muse/plugins/custom_commands/register_callbacks.py

@@ -0,0 +1,176 @@
+import logging
+from typing import Any
+
+from code_muse.callbacks import register_callback
+from code_muse.messaging import emit_info, emit_success
+from code_muse.plugins.custom_commands.args_injection import (
+    apply_shell_flags,
+    detect_shell_blocks,
+    inject_args,
+)
+from code_muse.plugins.custom_commands.command_discovery import (
+    CommandDef,
+    discover_commands,
+)
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Result wrapper so command_handler.py sends the prompt to the agent
+# ---------------------------------------------------------------------------
+
+
+class CustomCommandResult:
+    """Marker class for custom-command results that should be processed as input."""
+
+    def __init__(self, content: str):
+        self.content = content
+
+    def __str__(self) -> str:
+        return self.content
+
+    def __repr__(self) -> str:
+        return f"CustomCommandResult({len(self.content)} chars)"
+
+
+# ---------------------------------------------------------------------------
+# Command cache
+# ---------------------------------------------------------------------------
+
+_command_cache: dict[str, CommandDef] = {}
+_cache_loaded: bool = False
+
+
+def _load_commands() -> None:
+    """Load or reload the command discovery cache."""
+    global _command_cache, _cache_loaded
+    _command_cache = discover_commands()
+    _cache_loaded = True
+    logger.debug("Loaded %d custom command(s)", len(_command_cache))
+
+
+def _reload_commands() -> None:
+    """Clear cache and re-discover commands."""
+    global _command_cache, _cache_loaded
+    _command_cache.clear()
+    _cache_loaded = False
+    _load_commands()
+
+
+# ---------------------------------------------------------------------------
+# Callbacks
+# ---------------------------------------------------------------------------
+
+
+def _on_custom_command(command: str, name: str) -> Any:
+    """Handle a TOML-defined custom command.
+
+    Args:
+        command: Full command string (e.g. ``"/git:fix arg1"``).
+        name: Command name extracted by the handler (e.g. ``"git:fix"``).
+
+    Returns:
+        - ``CustomCommandResult(prompt)`` when a custom command is resolved
+          and should be sent to the agent as input.
+        - ``True`` for management commands (``/commands list``, ``/commands reload``).
+        - ``None`` if the command is not recognised (passthrough).
+    """
+    if not name:
+        return None
+
+    # Management commands
+    if name == "commands":
+        return _handle_commands_management(command)
+
+    # Ensure cache is populated
+    if not _cache_loaded:
+        _load_commands()
+
+    cmd_def = _command_cache.get("/" + name)
+    if cmd_def is None:
+        return None
+
+    # Extract args (everything after the command name)
+    parts = command.split(maxsplit=1)
+    args = parts[1] if len(parts) > 1 else ""
+
+    # Inject {{args}}
+    prompt = inject_args(cmd_def.prompt, args)
+
+    # Shell-context mode: auto-append efficiency flags
+    if detect_shell_blocks(prompt):
+        prompt = apply_shell_flags(prompt)
+
+    return CustomCommandResult(prompt)
+
+
+def _handle_commands_management(command: str) -> bool:
+    """Handle ``/commands``, ``/commands list``, and ``/commands reload``."""
+    rest = command.split(maxsplit=1)
+    subcommand = rest[1].strip().lower() if len(rest) > 1 else ""
+
+    if subcommand == "reload":
+        _reload_commands()
+        emit_success(f"🔄 Reloaded {len(_command_cache)} custom command(s)")
+        return True
+
+    # Default to list
+    return _commands_list()
+
+
+def _commands_list() -> bool:
+    """Display all discovered custom commands and return ``True``."""
+    if not _cache_loaded:
+        _load_commands()
+
+    if not _command_cache:
+        emit_info("No custom commands found.")
+        emit_info(
+            "Create .toml files in ~/.muse/commands/ or .muse/commands/"
+        )
+        return True
+
+    lines: list[str] = ["Custom commands:"]
+    for namespace in sorted(_command_cache):
+        cmd = _command_cache[namespace]
+        desc = f" — {cmd.description}" if cmd.description else ""
+        lines.append(f"  {namespace}{desc}")
+
+    lines.append("")
+    lines.append("Management:")
+    lines.append("  /commands list   — Show this list")
+    lines.append("  /commands reload — Rescan command directories")
+
+    emit_info("\n".join(lines))
+    return True
+
+
+def _on_custom_command_help() -> list[tuple[str, str]]:
+    """Return help entries for all discovered commands."""
+    if not _cache_loaded:
+        _load_commands()
+
+    entries: list[tuple[str, str]] = []
+    for namespace in sorted(_command_cache):
+        cmd = _command_cache[namespace]
+        desc = cmd.description or "Custom TOML command"
+        entries.append((namespace.lstrip("/"), desc))
+
+    # Management commands
+    entries.append(("commands list", "List available custom commands"))
+    entries.append(("commands reload", "Rescan custom command directories"))
+    return entries
+
+
+def _on_startup() -> None:
+    """Load commands at startup so they're available immediately."""
+    _load_commands()
+
+
+# ---------------------------------------------------------------------------
+# Registration
+# ---------------------------------------------------------------------------
+
+register_callback("custom_command", _on_custom_command)
+register_callback("custom_command_help", _on_custom_command_help)
+register_callback("startup", _on_startup)

code_muse/plugins/customizable_commands/register_callbacks.py

@@ -0,0 +1,136 @@
+from pathlib import Path
+from typing import Any
+
+from code_muse.callbacks import register_callback
+from code_muse.command_line.types import MarkdownCommandResult
+from code_muse.messaging import emit_error, emit_info
+
+# Global cache for loaded commands
+_custom_commands: dict[str, str] = {}
+_command_descriptions: dict[str, str] = {}
+_commands_loaded: bool = False  # Sentinel to track if commands have been loaded
+
+# Directories to scan for commands (in priority order - later directories override earlier)
+_COMMAND_DIRECTORIES = [
+    "~/.muse/commands",  # Global commands (all projects)
+    ".claude/commands",
+    ".github/prompts",
+    ".agents/commands",
+]
+
+
+def _load_markdown_commands() -> None:
+    """Load markdown command files from the configured directories.
+
+    Scans for *.md files in the configured directories and loads them
+    as custom commands. Later directories override earlier ones with the
+    same command name (project commands override global).
+    """
+    global _custom_commands, _command_descriptions, _commands_loaded
+
+    _custom_commands.clear()
+    _command_descriptions.clear()
+    _commands_loaded = True  # Mark as loaded even if directories are empty
+
+    # Process directories in order - later directories override earlier ones
+    for directory in _COMMAND_DIRECTORIES:
+        dir_path = Path(directory).expanduser()
+        if not dir_path.exists():
+            continue
+
+        # Look for markdown files
+        pattern = "*.md" if directory != ".github/prompts" else "*.prompt.md"
+        # Sort within directory for consistent ordering
+        md_files = sorted(dir_path.glob(pattern))
+
+        for md_file in md_files:
+            try:
+                # Extract command name from filename
+                if md_file.name.endswith(".prompt.md"):
+                    base_name = md_file.name[: -len(".prompt.md")]
+                else:
+                    base_name = md_file.stem
+
+                # Read file content
+                content = md_file.read_text(encoding="utf-8").strip()
+                if not content:
+                    continue
+
+                # Extract first line as description (or use filename)
+                lines = content.split("\n")
+                description = base_name.replace("_", " ").replace("-", " ").title()
+
+                # Try to get description from first non-empty line that's not a heading
+                for line in lines:
+                    stripped = line.strip()
+                    if stripped and not stripped.startswith("#"):
+                        # Truncate long descriptions
+                        description = stripped[:50] + (
+                            "..." if len(stripped) > 50 else ""
+                        )
+                        break
+
+                # Later directories override earlier ones (project > global)
+                _custom_commands[base_name] = content
+                _command_descriptions[base_name] = description
+
+            except Exception as e:
+                emit_error(f"Failed to load command from {md_file}: {e}")
+
+
+def _custom_help() -> list[tuple[str, str]]:
+    """Return help entries for loaded markdown commands."""
+    # Reload commands to pick up any changes
+    _load_markdown_commands()
+
+    help_entries = []
+    for name, description in sorted(_command_descriptions.items()):
+        help_entries.append((name, f"Execute markdown command: {description}"))
+
+    return help_entries
+
+
+def _handle_custom_command(command: str, name: str) -> Any | None:
+    """Handle a markdown-based custom command.
+
+    Args:
+        command: The full command string
+        name: The command name without leading slash
+
+    Returns:
+        MarkdownCommandResult with content to be processed as input,
+        or None if not found
+    """
+    if not name:
+        return None
+
+    # Ensure commands are loaded (use sentinel, not dict emptiness)
+    if not _commands_loaded:
+        _load_markdown_commands()
+
+    # Look up the command
+    content = _custom_commands.get(name)
+    if content is None:
+        return None
+
+    # Extract any additional arguments from the command
+    parts = command.split(maxsplit=1)
+    args = parts[1] if len(parts) > 1 else ""
+
+    # If there are arguments, append them to the prompt
+    prompt = f"{content}\n\nAdditional context: {args}" if args else content
+
+    # Emit info message and return the special marker
+    emit_info(f"📝 Executing markdown command: {name}")
+    return MarkdownCommandResult(prompt)
+
+
+# Register callbacks
+register_callback("custom_command_help", _custom_help)
+register_callback("custom_command", _handle_custom_command)
+
+# Re-export the shared type for backward compatibility
+__all__ = ["MarkdownCommandResult"]
+
+# Load commands at import time
+_load_markdown_commands()

code_muse/plugins/destructive_command_guard/__init__.py

@@ -0,0 +1,14 @@
+"""Destructive command guard plugin.
+
+Intercepts potentially-destructive shell commands and prompts the user for
+approval before allowing them through. Always active, pure regex, no LLM calls.
+
+Covers:
+- Unix/Linux: rm -rf /, rm -rf ~, rm -rf /*, rm -rf ~/*
+- Cross-platform (git, docker, npm/yarn, twine, SQL clients):
+  git push --mirror, git clean -fd, git reset --hard, git checkout/restore .,
+  DROP via SQL client, docker prune, npm/yarn publish, twine upload
+- Windows PowerShell: Remove-Item -Recurse -Force, Format-Volume, Clear-Disk,
+  Remove-ItemProperty, Clear-RecycleBin, irm | iex (remote code execution)
+- Windows CMD: rd /s /q, del /s system files, format, diskpart, bcdedit, reg delete
+"""