code-muse 0.0.1__tar.gz → 0.1.2__tar.gz

{code_muse-0.0.1 → code_muse-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-muse
-Version: 0.0.1
+Version: 0.1.2
 Summary: Muse — eternal guide of creators in the arts and sciences. An elegant AI coding assistant.
 Project-URL: Repository, https://github.com/asx8678/muse
 Project-URL: Homepage, https://github.com/asx8678/muse

code_muse-0.0.1/code_muse/agents/agent_qa_melpomene.py → code_muse-0.1.2/code_muse/agents/agent_qa_iris.py

@@ -1,25 +1,25 @@
-"""QA Melpomene — Playwright-powered browser automation agent."""
+"""QA Iris — Playwright-powered browser automation agent."""
 
 from .base_agent import BaseAgent
 
 
-class QualityAssuranceMelpomeneAgent(BaseAgent):
-    """QA Melpomene — Advanced browser automation with Playwright."""
+class QualityAssuranceIrisAgent(BaseAgent):
+    """QA Iris — Advanced browser automation with Playwright."""
 
     @property
     def name(self) -> str:
-        return "qa-melpomene"
+        return "qa-iris"
 
     @property
     def display_name(self) -> str:
-        return "QA Melpomene"
+        return "QA Iris"
 
     @property
     def description(self) -> str:
         return "Advanced web browser automation and quality assurance testing using Playwright with visual analysis capabilities"
 
     def get_available_tools(self) -> list[str]:
-        """Get the list of tools available to QA Melpomene."""
+        """Get the list of tools available to QA Iris."""
         return [
             # Core agent tools
             # Browser control and initialization
@@ -72,9 +72,9 @@ class QualityAssuranceMelpomeneAgent(BaseAgent):
         ]
 
     def get_system_prompt(self) -> str:
-        """Get QA Melpomene's specialized system prompt."""
+        """Get QA Iris's specialized system prompt."""
         return """
-You are QA Melpomene, an advanced autonomous browser automation and QA testing agent powered by Playwright!
+You are QA Iris, an advanced autonomous browser automation and QA testing agent powered by Playwright!
 
 You specialize in:
 🎯 **Quality Assurance Testing** - automated testing of web applications and user workflows

{code_muse-0.0.1 → code_muse-0.1.2}/code_muse/agents/event_stream_handler.py

@@ -35,14 +35,17 @@ def _handle_stream_task_exception(task: asyncio.Task) -> None:
 
 
 def _fire_stream_event(event_type: str, event_data: Any) -> None:
-    """Fire a stream event callback asynchronously (non-blocking).
+    """Fire a stream event callback to registered plugins.
 
-    PERF-08: Only fires for structural events (part_start, part_end).
-    High-frequency part_delta events are skipped since no current plugin
-    consumes them, and creating 100+ micro-tasks per response is wasteful.
+    For high-frequency part_delta events, fires synchronously without
+    creating a task to avoid overhead. For structural events (part_start,
+    part_end), fires asynchronously via task.
     """
     if event_type == "part_delta":
+        # Fire synchronously for perf — tps_meter plugin consumes these
+        _fire_stream_event_sync(event_type, event_data)
         return
+
     try:
         from code_muse import callbacks
         from code_muse.messaging import get_session_context
@@ -58,6 +61,24 @@ def _fire_stream_event(event_type: str, event_data: Any) -> None:
         logger.debug("Error firing stream event callback: %s", e)
 
 
+def _fire_stream_event_sync(event_type: str, event_data: Any) -> None:
+    """Fire stream event callbacks synchronously (no task creation).
+
+    Used for high-frequency events like part_delta where creating 100+
+    asyncio tasks per response would be wasteful.
+    """
+    try:
+        from code_muse import callbacks
+        from code_muse.messaging import get_session_context
+
+        agent_session_id = get_session_context()
+        callbacks.on_stream_event_sync(event_type, event_data, agent_session_id)
+    except ImportError:
+        logger.debug("callbacks or messaging module not available for stream event")
+    except Exception as e:
+        logger.debug("Error firing stream event callback: %s", e)
+
+
 # Module-level console for streaming output
 # Set via set_streaming_console() to share console with spinner
 _streaming_console: Console | None = None
@@ -302,11 +323,20 @@ async def event_stream_handler(
 
         # PartEndEvent - finish the streaming with a newline
         elif isinstance(event, PartEndEvent):
+            # Determine part type from tracking sets
+            _part_end_type = "unknown"
+            if event.index in text_parts:
+                _part_end_type = "TextPart"
+            elif event.index in thinking_parts:
+                _part_end_type = "ThinkingPart"
+            elif event.index in tool_parts:
+                _part_end_type = "ToolCallPart"
             # Fire stream event callback for part_end
             _fire_stream_event(
                 "part_end",
                 {
                     "index": event.index,
+                    "part_type": _part_end_type,
                     "next_part_kind": getattr(event, "next_part_kind", None),
                 },
             )

{code_muse-0.0.1 → code_muse-0.1.2}/code_muse/agents/prompt_v3.py

@@ -348,7 +348,7 @@ Calliope — epic vision and eloquent structure
 Clio — memory and historical context
 Erato — lyric beauty and emotional resonance
 Euterpe — rhythm and harmonious flow
-Melpomene — resilience in the face of error
+Iris — resilience in the face of error
 Polyhymnia — sacred geometry and deep architecture
 Terpsichore — graceful movement, interaction, and delightful UX choreography
 Thalia — joyful insight and accessible wisdom

{code_muse-0.0.1 → code_muse-0.1.2}/code_muse/callbacks.py

@@ -541,6 +541,20 @@ async def on_stream_event(
     )
 
 
+def on_stream_event_sync(
+    event_type: str, event_data: Any, agent_session_id: str | None = None
+) -> list[Any]:
+    """Synchronous version of on_stream_event — no task creation.
+
+    Used for high-frequency events (part_delta) where async overhead
+    would be wasteful. Callbacks are fired synchronously in the caller's
+    thread.
+    """
+    return _trigger_callbacks_sync(
+        "stream_event", event_type, event_data, agent_session_id
+    )
+
+
 def on_register_tools() -> list[dict[str, Any]]:
     """Collect custom tool registrations from plugins.
 

{code_muse-0.0.1 → code_muse-0.1.2}/code_muse/cli_runner/__init__.py

@@ -101,11 +101,11 @@ async def main():
             import pyfiglet
 
             intro_lines = pyfiglet.figlet_format(
-                "FAST PUPPY", font="ansi_shadow"
+                "Muse", font="ansi_shadow"
             ).split("\n")
 
-            # Simple blue to green gradient (top to bottom)
-            gradient_colors = ["bright_blue", "bright_cyan", "bright_green"]
+            # Warm gold to deep red gradient (top to bottom)
+            gradient_colors = ["gold1", "dark_orange", "red1"]
             display_console.print("\n")
 
             lines = []
@@ -113,7 +113,7 @@ async def main():
             for line_num, line in enumerate(intro_lines):
                 if line.strip():
                     # Use line position to determine color
-                    # (top blue, middle cyan, bottom green)
+                    # (top gold, middle orange, bottom red)
                     color_idx = min(line_num // 2, len(gradient_colors) - 1)
                     color = gradient_colors[color_idx]
                     lines.append(f"[{color}]{line}[/{color}]")

{code_muse-0.0.1 → code_muse-0.1.2}/code_muse/command_line/onboarding_slides.py

@@ -45,8 +45,8 @@ def get_gradient_banner() -> str:
     try:
         import pyfiglet
 
-        lines = pyfiglet.figlet_format("CODE PUPPY", font="ansi_shadow").split("\n")
-        colors = ["bright_blue", "bright_cyan", "bright_green"]
+        lines = pyfiglet.figlet_format("Muse", font="ansi_shadow").split("\n")
+        colors = ["gold1", "dark_orange", "red1"]
         result = []
         for i, line in enumerate(lines):
             if line.strip():
@@ -54,7 +54,7 @@ def get_gradient_banner() -> str:
                 result.append(f"[{color}]{line}[/{color}]")
         return "\n".join(result)
     except ImportError:
-        return "[bold bright_cyan]═══ CODE PUPPY ═══[/bold bright_cyan]"
+        return "[bold bright_red]═══ Muse ═══[/bold bright_red]"
 
 
 # ============================================================================

{code_muse-0.0.1 → code_muse-0.1.2}/code_muse/command_line/prompt_toolkit_completion.py

@@ -7,6 +7,7 @@
 # YELLOW = '\033[1;33m'
 # BOLD = '\033[1m'
 import asyncio
+import contextlib
 import os
 import sys
 from pathlib import Path
@@ -47,6 +48,15 @@ from code_muse.config import (
     get_value,
 )
 
+# Optional TPS meter integration for bottom toolbar
+_tps_state = None
+try:
+    from code_muse.plugins.tps_meter.register_callbacks import get_tps_state
+
+    _tps_state = get_tps_state()
+except ImportError:
+    pass
+
 
 def _sanitize_for_encoding(text: str) -> str:
     """Remove or replace characters that can't be safely encoded.
@@ -133,8 +143,9 @@ class SetCompleter(Completer):
         if not stripped_text_for_trigger_check.startswith(self.trigger + " "):
             return
 
-        # Determine the part of the text that is relevant for this completer
-        # This handles cases like "  /set foo" where the trigger isn't at the start of the string
+        # Determine the part of the text that is relevant for this completer.
+        # This handles cases like "  /set foo" where the trigger
+        # isn't at the start of the string.
         actual_trigger_pos = text_before_cursor.find(self.trigger)
 
         # Extract the input after /set and space (up to cursor)
@@ -152,7 +163,8 @@ class SetCompleter(Completer):
 
         for key in config_keys:
             if key == "model" or key == "muse_token":
-                continue  # exclude 'model' and 'muse_token' from regular /set completions
+                # Exclude 'model' and 'muse_token' from regular /set completions
+                continue
             if key.startswith(text_after_trigger):
                 prev_value = get_value(key)
                 value_part = f" = {prev_value}" if prev_value is not None else " = "
@@ -292,7 +304,8 @@ class CDCompleter(Completer):
         text_before_cursor = document.text_before_cursor
         stripped_text = text_before_cursor.lstrip()
 
-        # Require a space after /cd before showing completions (consistency with other completers)
+        # Require a space after /cd before showing completions
+        # (consistency with other completers)
         if not stripped_text.startswith(self.trigger + " "):
             return
 
@@ -321,7 +334,8 @@ class CDCompleter(Completer):
                 original_prefix = None
 
             for d in dirnames:
-                # Build the completion text so we keep the already-typed directory parts.
+                # Build the completion text so we keep the
+                # already-typed directory parts.
                 if user_prefix and original_prefix:
                     # Restore ~ prefix
                     suggestion = user_prefix + d + os.sep
@@ -451,7 +465,8 @@ class SlashCompleter(Completer):
                             "text": alias,
                             "display": f"/{alias} (alias for /{cmd.name})",
                             "meta": cmd.description,
-                            "sort_key": alias.lower(),  # Sort by alias name, not primary command
+                            "sort_key": alias.lower(),
+                            # Sort by alias name, not primary command
                         }
                     )
 
@@ -616,26 +631,26 @@ async def get_input_with_combined_completion(
     # Ctrl+X keybinding - exit with KeyboardInterrupt for shell command cancellation
     @bindings.add(Keys.ControlX)
     def _(event):
-        try:
+        with contextlib.suppress(Exception):
+            # Ignore "Return value already set" errors when exit was
+            # already called. This happens when user presses multiple
+            # exit keys in quick succession.
             event.app.exit(exception=KeyboardInterrupt)
-        except Exception:
-            # Ignore "Return value already set" errors when exit was already called
-            # This happens when user presses multiple exit keys in quick succession
-            pass
 
     # Escape keybinding - exit with KeyboardInterrupt
     @bindings.add(Keys.Escape)
     def _(event):
-        try:
+        with contextlib.suppress(Exception):
+            # Ignore "Return value already set" errors when exit
+            # was already called.
             event.app.exit(exception=KeyboardInterrupt)
-        except Exception:
-            # Ignore "Return value already set" errors when exit was already called
-            pass
 
     # NOTE: We intentionally do NOT override Ctrl+C here.
-    # prompt_toolkit's default Ctrl+C handler properly resets the terminal state on Windows.
-    # Overriding it with event.app.exit(exception=KeyboardInterrupt) can leave the terminal
-    # in a bad state where characters cannot be typed. Let prompt_toolkit handle Ctrl+C natively.
+    # prompt_toolkit's default Ctrl+C handler properly resets the
+    # terminal state on Windows. Overriding it with
+    # event.app.exit(exception=KeyboardInterrupt) can leave the
+    # terminal in a bad state where characters cannot be typed.
+    # Let prompt_toolkit handle Ctrl+C natively.
 
     # Toggle multiline with Alt+M
     @bindings.add(Keys.Escape, "m")
@@ -704,9 +719,12 @@ async def get_input_with_combined_completion(
             buffer.start_completion(select_first=False)
 
     # Handle bracketed paste - smart detection for text vs images.
-    # Most terminals (Windows included!) send Ctrl+V through bracketed paste.
-    # - If there's meaningful text content → paste as text (drag-and-drop file paths, copied text)
-    # - If text is empty/whitespace → check for clipboard image (image paste on Windows)
+    # Most terminals (Windows included!) send Ctrl+V through
+    # bracketed paste.
+    # - If there's meaningful text content → paste as text
+    #   (drag-and-drop file paths, copied text)
+    # - If text is empty/whitespace → check for clipboard image
+    #   (image paste on Windows)
     @bindings.add(Keys.BracketedPaste)
     def handle_bracketed_paste(event):
         """Handle bracketed paste - smart text vs image detection."""
@@ -748,8 +766,9 @@ async def get_input_with_combined_completion(
                 placeholder = capture_clipboard_image_to_pending()
                 if placeholder:
                     event.app.current_buffer.insert_text(placeholder + " ")
-                    # The placeholder itself is visible feedback - no need for extra output
-                    # Use bell for audible feedback (works in most terminals)
+                    # The placeholder itself is visible feedback -
+                    # no need for extra output. Use bell for audible
+                    # feedback (works in most terminals).
                     event.app.output.bell()
                     return  # Don't also paste text
         except Exception:
@@ -841,11 +860,27 @@ async def get_input_with_combined_completion(
         key_bindings=bindings,
         input_processors=[AttachmentPlaceholderProcessor()],
     )
-    # If they pass a string, backward-compat: convert it to formatted_text
-    if isinstance(prompt_str, str):
-        from prompt_toolkit.formatted_text import FormattedText
 
-        prompt_str = FormattedText([(None, prompt_str)])
+    # Build dynamic prompt that includes TPS stats inline (if plugin loaded)
+    def _build_prompt():
+        if isinstance(prompt_str, str):
+            from prompt_toolkit.formatted_text import FormattedText
+
+            parts = FormattedText([(None, prompt_str)])
+        else:
+            if hasattr(prompt_str, "__iter__"):
+                parts = list(prompt_str)
+            else:
+                parts = [prompt_str]
+
+        # Append TPS stats before the arrow if available
+        if _tps_state is not None:
+            tps_text = _tps_state.get_toolbar_text()
+            if tps_text:
+                parts.insert(-1, ("class:tps-meter", f" {tps_text} "))
+
+        return parts
+
     style = Style.from_dict(
         {
             # Keys must AVOID the 'class:' prefix – that prefix is used only when
@@ -857,9 +892,10 @@ async def get_input_with_combined_completion(
             "cwd": "bold ansibrightgreen",
             "arrow": "bold ansibrightblue",
             "attachment-placeholder": "italic ansicyan",
+            "tps-meter": "italic ansigreen",
         }
     )
-    text = await session.prompt_async(prompt_str, style=style)
+    text = await session.prompt_async(_build_prompt, style=style)
     # NOTE: We used to call update_model_in_input(text) here to handle /model and /m
     # commands at the prompt level, but that prevented the command handler from running
     # and emitting success messages. Now we let all /model commands fall through to

{code_muse-0.0.1 → code_muse-0.1.2}/code_muse/config_appearance.py

@@ -101,25 +101,25 @@ def set_diff_deletion_color(color: str):
 
 
 DEFAULT_BANNER_COLORS = {
-    "thinking": "deep_sky_blue4",  # Sapphire - contemplation
-    "agent_response": "medium_purple4",  # Amethyst - main AI output
-    "shell_command": "dark_orange3",  # Amber - system commands
-    "read_file": "steel_blue",  # Steel - reading files
-    "edit_file": "dark_goldenrod",  # Gold - modifications (legacy)
-    "create_file": "dark_goldenrod",  # Gold - file creation
-    "replace_in_file": "dark_goldenrod",  # Gold - file modifications
-    "delete_snippet": "dark_goldenrod",  # Gold - snippet removal
-    "grep": "grey37",  # Silver - search results
-    "directory_listing": "dodger_blue2",  # Sky - navigation
+    "thinking": "dark_violet",  # Violet - contemplation
+    "agent_response": "purple4",  # Deep Purple - main AI output
+    "shell_command": "deeppink3",  # Deep Pink - system commands
+    "read_file": "dark_magenta",  # Magenta - reading files
+    "edit_file": "purple4",  # Purple - modifications
+    "create_file": "purple4",  # Purple - file creation
+    "replace_in_file": "purple4",  # Purple - file modifications
+    "delete_snippet": "dark_violet",  # Violet - snippet removal
+    "grep": "medium_purple3",  # Light Purple - search results
+    "directory_listing": "deeppink4",  # Deep Pink - navigation
     "agent_reasoning": "dark_violet",  # Violet - deep thought
-    "invoke_agent": "deep_pink4",  # Ruby - agent invocation
-    "subagent_response": "sea_green3",  # Emerald - sub-agent success
-    "list_agents": "dark_slate_gray3",  # Slate - neutral listing
-    "universal_constructor": "dark_cyan",  # Teal - constructing tools
-    # Browser/Terminal tools - same color as edit_file (gold)
-    "terminal_tool": "dark_goldenrod",  # Gold - browser terminal operations
-    # User-initiated shell pass-through (! prefix) - distinct from agent's shell_command
-    "shell_passthrough": "medium_sea_green",  # Green - user's own shell commands
+    "invoke_agent": "deeppink3",  # Deep Pink - agent invocation
+    "subagent_response": "purple3",  # Purple - sub-agent success
+    "list_agents": "dark_magenta",  # Magenta - neutral listing
+    "universal_constructor": "dark_violet",  # Violet - constructing tools
+    # Browser/Terminal tools
+    "terminal_tool": "purple4",  # Purple - browser terminal operations
+    # User-initiated shell pass-through
+    "shell_passthrough": "deeppink4",  # Deep Pink - user's own shell commands
 }
 
 

{code_muse-0.0.1 → code_muse-0.1.2}/code_muse/messaging/subagent_console.py

@@ -172,7 +172,7 @@ class SubAgentConsoleManager:
 
         Args:
             session_id: Unique identifier for this agent session.
-            agent_name: Name of the agent (e.g., 'muse', 'qa-melpomene').
+            agent_name: Name of the agent (e.g., 'muse', 'qa-iris').
             model_name: Name of the model being used (e.g., 'gpt-4o').
         """
         with self._agents_lock:

code_muse-0.1.2/code_muse/plugins/auto_review/__init__.py

@@ -0,0 +1,6 @@
+"""Auto-Review plugin — second-agent review of file changes.
+
+Hooks into ``post_tool_call`` to automatically review file modifications
+using a separate LLM call. Displays visible review status so the user always
+knows when a review is happening and what was found.
+"""

code_muse-0.1.2/code_muse/plugins/auto_review/cache.py

@@ -0,0 +1,33 @@
+"""In-memory cache for auto-review results."""
+
+import hashlib
+
+
+class ReviewCache:
+    """Simple cache keyed by SHA256(file_path + content_hash)."""
+
+    def __init__(self) -> None:
+        self._cache: dict[str, dict] = {}
+
+    def _key(self, file_path: str, content_hash: str) -> str:
+        return hashlib.sha256(f"{file_path}::{content_hash}".encode()).hexdigest()
+
+    def get(self, file_path: str, content_hash: str) -> dict | None:
+        """Return cached review result or None."""
+        return self._cache.get(self._key(file_path, content_hash))
+
+    def set(self, file_path: str, content_hash: str, result: dict) -> None:
+        """Store a review result in the cache."""
+        self._cache[self._key(file_path, content_hash)] = result
+
+    def clear(self) -> None:
+        """Clear all cached entries."""
+        self._cache.clear()
+
+
+_review_cache = ReviewCache()
+
+
+def get_review_cache() -> ReviewCache:
+    """Return the module-level ReviewCache singleton."""
+    return _review_cache

code_muse-0.1.2/code_muse/plugins/auto_review/config.py

@@ -0,0 +1,35 @@
+"""Configuration accessors for the Auto-Review plugin."""
+
+from code_muse.config import get_value
+
+
+def is_auto_review_enabled() -> bool:
+    """Check if auto-review is enabled (default: True)."""
+    val = get_value("auto_review_enabled")
+    if val is None:
+        return True
+    return str(val).lower() in ("1", "true", "yes", "on")
+
+
+def get_auto_review_model() -> str | None:
+    """Get the model to use for auto-review, or None to use the global model."""
+    return get_value("auto_review_model")
+
+
+def get_auto_review_mode() -> str:
+    """Get the review mode: 'background' or 'blocking' (default: 'background')."""
+    val = get_value("auto_review_mode")
+    if val and val.strip().lower() in ("background", "blocking"):
+        return val.strip().lower()
+    return "background"
+
+
+def get_auto_review_min_diff_length() -> int:
+    """Minimum diff length (in characters) to trigger a review (default: 10)."""
+    val = get_value("auto_review_min_diff_length")
+    if val is not None:
+        try:
+            return max(0, int(val))
+        except (ValueError, TypeError):
+            pass
+    return 10

code_muse-0.1.2/code_muse/plugins/auto_review/register_callbacks.py

@@ -0,0 +1,122 @@
+"""Callback registration for the Auto-Review plugin.
+
+Registers:
+    - ``post_tool_call`` hook — automatically reviews file changes
+    - ``request_code_review`` tool — manual review trigger
+"""
+
+import logging
+from typing import Any
+
+from code_muse.callbacks import register_callback
+from code_muse.plugins.auto_review.reviewer import (
+    request_manual_review,
+    run_auto_review,
+)
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# post_tool_call hook
+# ---------------------------------------------------------------------------
+
+
+async def _on_post_tool_call(
+    tool_name: str,
+    tool_args: dict,
+    result: dict,
+    duration_ms: float,
+    context: Any = None,
+) -> None:
+    """Review file changes after tool execution."""
+    try:
+        await run_auto_review(tool_name, tool_args, result)
+    except Exception as exc:
+        logger.error("Auto-review hook failed: %s", exc, exc_info=True)
+
+
+# ---------------------------------------------------------------------------
+# Tool registration
+# ---------------------------------------------------------------------------
+
+
+def _register_review_tools() -> list[dict]:
+    """Return tool definitions for the auto-review plugin."""
+
+    def register_request_code_review(agent):
+        """Register the request_code_review tool on an agent."""
+
+        @agent.tool
+        async def request_code_review(
+            context,
+            file_path: str = "",
+            reason: str | None = None,
+        ) -> dict:
+            """Request a code review for a specific file.
+
+            The reviewer analyzes the file for correctness, safety, style,
+            edge cases, and completeness. Returns structured feedback.
+
+            Args:
+                file_path: Path to the file to review
+                reason: Optional focus area for the review \
+                    (e.g., "security", "performance")
+
+            Returns:
+                Dict with verdict, summary, issues, and suggestion
+            """
+            return await request_manual_review(file_path, reason)
+
+    return [
+        {
+            "name": "request_code_review",
+            "register_func": register_request_code_review,
+        },
+    ]
+
+
+# ---------------------------------------------------------------------------
+# Help entry
+# ---------------------------------------------------------------------------
+
+
+def _on_custom_command_help() -> list[tuple[str, str]]:
+    return [
+        ("review <path>", "Request an auto-review for a specific file"),
+    ]
+
+
+def _on_custom_command(command: str, name: str) -> bool | None:
+    """Handle ``/review <path>`` command."""
+    if name == "review":
+        parts = command.split(maxsplit=1)
+        file_path = parts[1].strip() if len(parts) > 1 else ""
+        if not file_path:
+            from code_muse.messaging import emit_warning
+
+            emit_warning("Usage: /review <file_path>")
+            return True
+
+        import asyncio
+
+        try:
+            loop = asyncio.get_running_loop()
+            loop.create_task(request_manual_review(file_path))
+        except RuntimeError:
+            asyncio.run(request_manual_review(file_path))
+
+        return True
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Register all callbacks
+# ---------------------------------------------------------------------------
+
+register_callback("post_tool_call", _on_post_tool_call)
+register_callback("register_tools", _register_review_tools)
+register_callback("custom_command_help", _on_custom_command_help)
+register_callback("custom_command", _on_custom_command)
+
+logger.debug("Auto-Review plugin callbacks registered")

code_muse-0.1.2/code_muse/plugins/auto_review/review_prompt.py

@@ -0,0 +1,23 @@
+"""Reviewer system prompt templates."""
+
+REVIEWER_SYSTEM_PROMPT = """\
+You are a code reviewer. Review the following file change and \
+provide structured feedback.
+
+Evaluate:
+1. CORRECTNESS — Does the change achieve its apparent goal? Any bugs?
+2. SAFETY — Could this change introduce security issues, data loss, or breakage?
+3. STYLE — Does it follow best practices for the language/framework?
+4. EDGE CASES — Are there inputs or states where this fails?
+5. COMPLETENESS — Is the change self-contained? Missing imports, error handling, tests?
+
+Be concise. Focus on actionable issues. If the change looks good, say so.
+
+Return your review as JSON with:
+{
+  "verdict": "approved" | "flagged" | "rejected",
+  "summary": "One-line summary of findings",
+  "issues": ["list of specific issues, or empty list"],
+  "suggestion": "Optional improvement suggestion or null"
+}
+"""