code-muse 0.0.1__py3-none-any.whl

code_muse/command_line/session_commands.py

@@ -0,0 +1,304 @@
+"""Command handlers for Muse - SESSION commands.
+
+This module contains @register_command decorated handlers that are automatically
+discovered by the command registry system.
+"""
+
+from datetime import datetime
+from pathlib import Path
+
+from code_muse.command_line.command_registry import register_command
+from code_muse.config import CONTEXTS_DIR
+from code_muse.session_storage import list_sessions, load_session, save_session
+
+
+# Import get_commands_help from command_handler to avoid circular imports
+# This will be defined in command_handler.py
+def get_commands_help():
+    """Lazy import to avoid circular dependency."""
+    from code_muse.command_line.command_handler import get_commands_help as _gch
+
+    return _gch()
+
+
+@register_command(
+    name="session",
+    description="Show or rotate autosave session ID",
+    usage="/session [id|new]",
+    aliases=["s"],
+    category="session",
+    detailed_help="""
+    Manage autosave sessions.
+
+    Commands:
+      /session        Show current session ID
+      /session id     Show current session ID
+      /session new    Create new session and rotate ID
+
+    Sessions are used for auto-saving conversation history.
+    """,
+)
+def handle_session_command(command: str) -> bool:
+    """Handle /session command."""
+    from code_muse.config import (
+        AUTOSAVE_DIR,
+        get_current_autosave_id,
+        get_current_autosave_session_name,
+        rotate_autosave_id,
+    )
+    from code_muse.messaging import emit_info, emit_success, emit_warning
+
+    tokens = command.split()
+
+    if len(tokens) == 1 or tokens[1] == "id":
+        sid = get_current_autosave_id()
+        emit_info(
+            f"[bold magenta]Autosave Session[/bold magenta]: {sid}\n"
+            f"Files prefix: {Path(AUTOSAVE_DIR) / get_current_autosave_session_name()}"
+        )
+        return True
+    if tokens[1] == "new":
+        new_sid = rotate_autosave_id()
+        emit_success(f"New autosave session id: {new_sid}")
+        return True
+    emit_warning("Usage: /session [id|new]")
+    return True
+
+
+@register_command(
+    name="compact",
+    description="Summarize and compact current chat history (uses compaction_strategy config)",
+    usage="/compact",
+    category="session",
+)
+def handle_compact_command(command: str) -> bool:
+    """Compact message history using configured strategy."""
+    from code_muse.agents.agent_manager import get_current_agent
+    from code_muse.config import get_compaction_strategy, get_protected_token_count
+    from code_muse.messaging import emit_error, emit_info, emit_success, emit_warning
+
+    try:
+        agent = get_current_agent()
+        history = agent.get_message_history()
+        if not history:
+            emit_warning("No history to compact yet. Ask me something first!")
+            return True
+
+        current_agent = get_current_agent()
+        before_tokens = sum(
+            current_agent.estimate_tokens_for_message(m) for m in history
+        )
+        compaction_strategy = get_compaction_strategy()
+        protected_tokens = get_protected_token_count()
+        emit_info(
+            f"🤔 Compacting {len(history)} messages using {compaction_strategy} strategy... (~{before_tokens} tokens)"
+        )
+
+        current_agent = get_current_agent()
+        if compaction_strategy == "truncation":
+            from code_muse.agents._compaction import truncate
+
+            compacted = truncate(history, protected_tokens)
+            summarized_messages = []  # No summarization in truncation mode
+        else:
+            # Default to summarization
+            compacted, summarized_messages = current_agent.summarize_messages(
+                history, with_protection=True
+            )
+
+        if not compacted:
+            emit_error("Compaction failed. History unchanged.")
+            return True
+
+        agent.set_message_history(compacted)
+
+        current_agent = get_current_agent()
+        after_tokens = sum(
+            current_agent.estimate_tokens_for_message(m) for m in compacted
+        )
+        reduction_pct = (
+            ((before_tokens - after_tokens) / before_tokens * 100)
+            if before_tokens > 0
+            else 0
+        )
+
+        strategy_info = (
+            f"using {compaction_strategy} strategy"
+            if compaction_strategy == "truncation"
+            else "via summarization"
+        )
+        emit_success(
+            f"✨ Done! History: {len(history)} → {len(compacted)} messages {strategy_info}\n"
+            f"🏦 Tokens: {before_tokens:,} → {after_tokens:,} ({reduction_pct:.1f}% reduction)"
+        )
+        return True
+    except Exception as e:
+        emit_error(f"/compact error: {e}")
+        return True
+
+
+@register_command(
+    name="truncate",
+    description="Truncate history to N most recent messages (e.g., /truncate 10)",
+    usage="/truncate <N>",
+    category="session",
+)
+def handle_truncate_command(command: str) -> bool:
+    """Truncate message history to N most recent messages."""
+    from code_muse.agents.agent_manager import get_current_agent
+    from code_muse.messaging import emit_error, emit_info, emit_success, emit_warning
+
+    tokens = command.split()
+    if len(tokens) != 2:
+        emit_error("Usage: /truncate <N> (where N is the number of messages to keep)")
+        return True
+
+    try:
+        n = int(tokens[1])
+        if n < 1:
+            emit_error("N must be a positive integer")
+            return True
+    except ValueError:
+        emit_error("N must be a valid integer")
+        return True
+
+    agent = get_current_agent()
+    history = agent.get_message_history()
+    if not history:
+        emit_warning("No history to truncate yet. Ask me something first!")
+        return True
+
+    if len(history) <= n:
+        emit_info(
+            f"History already has {len(history)} messages, which is <= {n}. Nothing to truncate."
+        )
+        return True
+
+    # Always keep the first message (system message) and then keep the N-1 most recent messages
+    truncated_history = [history[0]] + history[-(n - 1) :] if n > 1 else [history[0]]
+
+    agent.set_message_history(truncated_history)
+    emit_success(
+        f"Truncated message history from {len(history)} to {len(truncated_history)} messages (keeping system message and {n - 1} most recent)"
+    )
+    return True
+
+
+@register_command(
+    name="autosave_load",
+    description="Load an autosave session interactively",
+    usage="/autosave_load",
+    aliases=["resume"],
+    category="session",
+)
+def handle_autosave_load_command(command: str) -> bool:
+    """Load an autosave session."""
+    # Return a special marker to indicate we need to run async autosave loading
+    return "__AUTOSAVE_LOAD__"
+
+
+@register_command(
+    name="dump_context",
+    description="Save current message history to file",
+    usage="/dump_context <name>",
+    category="session",
+)
+def handle_dump_context_command(command: str) -> bool:
+    """Dump message history to a file."""
+    from code_muse.agents.agent_manager import get_current_agent
+    from code_muse.messaging import emit_error, emit_success, emit_warning
+
+    tokens = command.split()
+    if len(tokens) != 2:
+        emit_warning("Usage: /dump_context <session_name>")
+        return True
+
+    session_name = tokens[1]
+    agent = get_current_agent()
+    history = agent.get_message_history()
+
+    if not history:
+        emit_warning("No message history to dump!")
+        return True
+
+    try:
+        metadata = save_session(
+            history=history,
+            session_name=session_name,
+            base_dir=Path(CONTEXTS_DIR),
+            timestamp=datetime.now().isoformat(),
+            token_estimator=agent.estimate_tokens_for_message,
+        )
+        emit_success(
+            f"✅ Context saved: {metadata.message_count} messages ({metadata.total_tokens} tokens)\n"
+            f"📁 Files: {metadata.pickle_path}, {metadata.metadata_path}"
+        )
+        return True
+
+    except Exception as exc:
+        emit_error(f"Failed to dump context: {exc}")
+        return True
+
+
+@register_command(
+    name="load_context",
+    description="Load message history from file",
+    usage="/load_context <name>",
+    category="session",
+)
+def handle_load_context_command(command: str) -> bool:
+    """Load message history from a file."""
+    from rich.text import Text
+
+    from code_muse.agents.agent_manager import get_current_agent
+    from code_muse.config import rotate_autosave_id
+    from code_muse.messaging import emit_error, emit_info, emit_success, emit_warning
+
+    tokens = command.split()
+    if len(tokens) != 2:
+        emit_warning("Usage: /load_context <session_name>")
+        return True
+
+    session_name = tokens[1]
+    contexts_dir = Path(CONTEXTS_DIR)
+    session_path = contexts_dir / f"{session_name}.json"
+
+    try:
+        history = load_session(session_name, contexts_dir)
+    except FileNotFoundError:
+        emit_error(f"Context file not found: {session_path}")
+        available = list_sessions(contexts_dir)
+        if available:
+            emit_info(f"Available contexts: {', '.join(available)}")
+        return True
+    except Exception as exc:
+        emit_error(f"Failed to load context: {exc}")
+        return True
+
+    agent = get_current_agent()
+    agent.set_message_history(history)
+    total_tokens = sum(agent.estimate_tokens_for_message(m) for m in history)
+
+    # Rotate autosave id to avoid overwriting any existing autosave
+    try:
+        new_id = rotate_autosave_id()
+        autosave_info = Text.from_markup(
+            f"\n[dim]Autosave session rotated to: {new_id}[/dim]"
+        )
+    except Exception:
+        autosave_info = Text("")
+
+    # Build the success message with proper Text concatenation
+    success_msg = Text(
+        f"✅ Context loaded: {len(history)} messages ({total_tokens} tokens)\n"
+        f"📁 From: {session_path}"
+    )
+    success_msg.append_text(autosave_info)
+    emit_success(success_msg)
+
+    # Display recent message history for context
+    from code_muse.command_line.autosave_menu import display_resumed_history
+
+    display_resumed_history(history)
+
+    return True

code_muse/command_line/shell_passthrough.py

@@ -0,0 +1,145 @@
+"""Shell pass-through for direct command execution.
+
+Prepend a prompt with `!` to execute it as a shell command directly,
+bypassing the agent entirely. Inspired by Claude Code's `!` prefix.
+
+Examples:
+    !ls -la
+    !git status
+    !python --version
+"""
+
+import os
+import subprocess
+import sys
+import time
+
+from rich.console import Console
+from rich.markup import escape as escape_rich_markup
+
+from code_muse.config import get_banner_color
+
+# The prefix character that triggers shell pass-through
+SHELL_PASSTHROUGH_PREFIX = "!"
+
+# Banner identifier — matches the key in DEFAULT_BANNER_COLORS
+_BANNER_NAME = "shell_passthrough"
+
+
+def _get_console() -> Console:
+    """Get a Rich console for direct output.
+
+    Separated for testability — tests can mock this to capture output.
+    """
+    return Console()
+
+
+def _format_banner() -> str:
+    """Format the SHELL PASSTHROUGH banner using the configured color.
+
+    Uses the same `[bold white on {color}]` pattern as rich_renderer.py
+    so the banner looks consistent with SHELL COMMAND, EDIT FILE, etc.
+
+    Returns:
+        Rich markup string for the banner.
+    """
+    color = get_banner_color(_BANNER_NAME)
+    return f"[bold white on {color}] 🐚 SHELL PASSTHROUGH [/bold white on {color}]"
+
+
+def is_shell_passthrough(task: str) -> bool:
+    """Check if user input is a shell pass-through command.
+
+    A pass-through command starts with `!` followed by a non-empty command.
+    A bare `!` with nothing after it is NOT a pass-through.
+
+    Args:
+        task: Raw user input string.
+
+    Returns:
+        True if the input is a shell pass-through command.
+    """
+    stripped = task.strip()
+    return (
+        stripped.startswith(SHELL_PASSTHROUGH_PREFIX)
+        and len(stripped) > len(SHELL_PASSTHROUGH_PREFIX)
+        and not stripped[len(SHELL_PASSTHROUGH_PREFIX) :].isspace()
+    )
+
+
+def extract_command(task: str) -> str:
+    """Extract the shell command from a pass-through input.
+
+    Strips the leading `!` prefix and any surrounding whitespace.
+
+    Args:
+        task: Raw user input (must pass `is_shell_passthrough` check).
+
+    Returns:
+        The shell command to execute.
+    """
+    return task.strip()[len(SHELL_PASSTHROUGH_PREFIX) :].strip()
+
+
+def execute_shell_passthrough(task: str) -> None:
+    """Execute a shell command directly, bypassing the agent.
+
+    Renders a colored banner (matching the codebase banner system) so the
+    user instantly sees they're in pass-through mode, then inherits stdio
+    for raw terminal output.
+
+    Ctrl+C during execution kills the subprocess, not Muse.
+
+    Args:
+        task: Raw user input starting with `!`.
+    """
+    console = _get_console()
+    command = extract_command(task)
+
+    if not command:
+        console.print(
+            "[yellow]Empty command. Usage: !<command> (e.g., !ls -la)[/yellow]"
+        )
+        return
+
+    # Escape command to prevent Rich markup injection
+    safe_command = escape_rich_markup(command)
+
+    # Banner + command on one line, context hint below
+    banner = _format_banner()
+    console.print(f"\n{banner} [dim]$ {safe_command}[/dim]")
+    console.print("[dim]↳ Direct shell · Bypassing AI agent[/dim]")
+
+    start_time = time.monotonic()
+
+    try:
+        result = subprocess.run(
+            command,
+            shell=True,
+            cwd=os.getcwd(),
+            # Inherit stdio — output goes straight to the terminal
+            stdin=sys.stdin,
+            stdout=sys.stdout,
+            stderr=sys.stderr,
+        )
+        elapsed = time.monotonic() - start_time
+
+        if result.returncode == 0:
+            console.print(
+                f"[bold green]✅ Done[/bold green] [dim]({elapsed:.1f}s)[/dim]"
+            )
+        else:
+            console.print(
+                f"[bold red]❌ Exit code {result.returncode}[/bold red] "
+                f"[dim]({elapsed:.1f}s)[/dim]"
+            )
+
+    except KeyboardInterrupt:
+        elapsed = time.monotonic() - start_time
+        console.print(
+            f"\n[bold yellow]⚡ Interrupted[/bold yellow] [dim]({elapsed:.1f}s)[/dim]"
+        )
+
+    except Exception as e:
+        safe_error = escape_rich_markup(str(e))
+        console.print(f"[bold red]Shell error:[/bold red] {safe_error}")

code_muse/command_line/skills_completion.py

@@ -0,0 +1,158 @@
+"""Prompt-toolkit completion for `/skills`.
+
+Mirrors generic completer but simpler:
+- Completes subcommands for `/skills ...`
+- For `/skills install ...`, completes skill ids from the remote catalog
+
+This module is intentionally defensive: if the remote catalog isn't available,
+completion simply returns no skill ids.
+"""
+
+import logging
+import time
+from collections.abc import Iterable
+
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.document import Document
+
+logger = logging.getLogger(__name__)
+
+
+def load_catalog_skill_ids() -> list[str]:
+    """Load skill ids from the remote catalog (lazy, cached)."""
+
+    try:
+        from code_muse.plugins.agent_skills.skill_catalog import catalog
+
+        return [entry.id for entry in catalog.get_all()]
+    except Exception as e:
+        logger.debug(f"Could not load skill ids: {e}")
+        return []
+
+
+class SkillsCompleter(Completer):
+    """Completer for /skills subcommands."""
+
+    def __init__(self, trigger: str = "/skills"):
+        """Initialize the skills completer.
+
+        Args:
+            trigger: The slash command prefix to trigger completion.
+        """
+
+        self.trigger = trigger
+        self.subcommands = {
+            "list": "List all installed skills",
+            "install": "Browse & install from catalog",
+            "enable": "Enable skills integration globally",
+            "disable": "Disable skills integration globally",
+            "toggle": "Toggle skills system on/off",
+            "refresh": "Refresh skill cache",
+            "help": "Show skills help",
+        }
+
+        self._skill_ids_cache: list[str] | None = None
+        self._cache_timestamp: float | None = None
+
+    def _get_skill_ids(self) -> list[str]:
+        """Get skill ids with 30-second cache."""
+
+        current_time = time.time()
+        if (
+            self._skill_ids_cache is None
+            or self._cache_timestamp is None
+            or current_time - self._cache_timestamp > 30
+        ):
+            self._skill_ids_cache = load_catalog_skill_ids()
+            self._cache_timestamp = current_time
+
+        return self._skill_ids_cache or []
+
+    def get_completions(
+        self, document: Document, complete_event
+    ) -> Iterable[Completion]:
+        """Yield completions for /skills subcommands and skill ids."""
+
+        text = document.text
+        cursor_position = document.cursor_position
+        text_before_cursor = text[:cursor_position]
+
+        # Only trigger if /skills is at the very beginning of the line
+        stripped_text = text_before_cursor.lstrip()
+        if not stripped_text.startswith(self.trigger):
+            return
+
+        # Find where /skills starts (after any leading whitespace)
+        skills_pos = text_before_cursor.find(self.trigger)
+        skills_end = skills_pos + len(self.trigger)
+
+        # Require a space after /skills before showing completions
+        if (
+            skills_end >= len(text_before_cursor)
+            or text_before_cursor[skills_end] != " "
+        ):
+            return
+
+        # Everything after /skills (after the space)
+        after_skills = text_before_cursor[skills_end + 1 :].strip()
+
+        # If nothing after /skills, show all subcommands
+        if not after_skills:
+            for subcommand, description in sorted(self.subcommands.items()):
+                yield Completion(
+                    subcommand,
+                    start_position=0,
+                    display=subcommand,
+                    display_meta=description,
+                )
+            return
+
+        parts = after_skills.split()
+
+        # Special-case: /skills install <skill-id>
+        if len(parts) >= 1:
+            subcommand = parts[0].lower()
+
+            if subcommand == "install":
+                # Case 1: exactly `install ` -> show all ids
+                if len(parts) == 1 and text.endswith(" "):
+                    for skill_id in sorted(self._get_skill_ids()):
+                        yield Completion(
+                            skill_id,
+                            start_position=0,
+                            display=skill_id,
+                            display_meta="Skill",
+                        )
+                    return
+
+                # Case 2: `install <partial>` -> filter ids
+                if len(parts) == 2 and cursor_position > (
+                    skills_end + 1 + len(subcommand) + 1
+                ):
+                    partial = parts[1]
+                    start_position = -len(partial)
+                    for skill_id in sorted(self._get_skill_ids()):
+                        if skill_id.lower().startswith(partial.lower()):
+                            yield Completion(
+                                skill_id,
+                                start_position=start_position,
+                                display=skill_id,
+                                display_meta="Skill",
+                            )
+                    return
+
+        # If we only have one part and no trailing space, complete subcommands
+        if len(parts) == 1 and not text.endswith(" "):
+            partial = parts[0]
+            for subcommand, description in sorted(self.subcommands.items()):
+                if subcommand.startswith(partial):
+                    yield Completion(
+                        subcommand,
+                        start_position=-(len(partial)),
+                        display=subcommand,
+                        display_meta=description,
+                    )
+            return
+
+        # Otherwise, no further completion.
+        return

code_muse/command_line/types.py

@@ -0,0 +1,18 @@
+"""Shared type definitions for the command-line subsystem."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class MarkdownCommandResult:
+    """Result of a custom command that should be rendered as markdown.
+
+    Attributes:
+        content: The markdown string to display
+        is_markdown: Always True for this type
+    """
+
+    content: str
+    is_markdown: bool = True