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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-muse
-Version: 0.1.0
+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.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"
+}
+"""

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

@@ -0,0 +1,314 @@
+"""Core review orchestration — builds context, calls LLM, parses result."""
+
+import json
+import logging
+
+from code_muse.plugins.auto_review.cache import get_review_cache
+from code_muse.plugins.auto_review.config import (
+    get_auto_review_min_diff_length,
+    get_auto_review_model,
+    is_auto_review_enabled,
+)
+from code_muse.plugins.auto_review.review_prompt import REVIEWER_SYSTEM_PROMPT
+from code_muse.plugins.auto_review.visibility import (
+    emit_review_approved,
+    emit_review_error,
+    emit_review_flagged,
+    emit_review_rejected,
+    emit_review_started,
+)
+
+logger = logging.getLogger(__name__)
+
+# Known file-modification tools that trigger review
+_FILE_MOD_TOOLS = frozenset(
+    {
+        "create_file",
+        "replace_in_file",
+        "delete_snippet",
+        "delete_file",
+    }
+)
+
+
+def _compute_content_hash(file_path: str, diff: str) -> str:
+    """Compute a stable hash for cache key."""
+    import hashlib
+
+    return hashlib.sha256(f"{file_path}::{diff}".encode()).hexdigest()[:16]
+
+
+def _extract_review_context(
+    tool_name: str,
+    tool_args: dict,
+    result: dict,
+) -> dict | None:
+    """Extract review context from tool call data.
+
+    Returns dict with file_path, operation, diff, content_hash or None
+    if the operation doesn't warrant review (e.g. it failed).
+    """
+    # Only review successful changes
+    if not result.get("success") and not result.get("changed"):
+        return None
+
+    file_path = tool_args.get("file_path", tool_args.get("path", ""))
+    if not file_path:
+        return None
+
+    # Build a review diff from the result
+    diff = ""
+    if "diff" in result:
+        diff = result["diff"]
+
+    # For create_file, the diff might be in the result as a message
+    if not diff and tool_name == "create_file":
+        content = tool_args.get("content", "")
+        if content:
+            lines = content.splitlines()
+            diff = (
+                f"--- /dev/null\n+++ b/{file_path}\n"
+                f"@@ -0,0 +1,{len(lines)} @@\n"
+                + "\n".join(f"+{line}" for line in lines)
+            )
+
+    # For delete_file, note the deletion
+    if not diff and tool_name == "delete_file":
+        diff = f"--- a/{file_path}\n+++ /dev/null\n@@ -1,0 +0,0 @@\nFile deleted."
+
+    # Skip trivial changes
+    if len(diff.strip()) < get_auto_review_min_diff_length():
+        return None
+
+    return {
+        "file_path": file_path,
+        "operation": tool_name,
+        "diff": diff,
+        "content_hash": _compute_content_hash(file_path, diff),
+    }
+
+
+def _build_reviewer_prompt(context: dict) -> str:
+    """Build the user prompt for the reviewer model."""
+    file_path = context["file_path"]
+    ext = file_path.rsplit(".", 1)[-1] if "." in file_path else "unknown"
+    return f"""Please review this file change:
+
+File: {context["file_path"]}
+Operation: {context["operation"]}
+Language/type: {ext}
+
+Diff:
+```
+{context["diff"][:4000]}
+```
+
+Provide your structured review as JSON with verdict, summary, issues, and suggestion.
+"""
+
+
+async def _call_reviewer_llm(prompt: str) -> dict | None:
+    """Call the reviewer LLM and parse the JSON response.
+
+    Uses ModelFactory to get a model instance, creates a temporary
+    pydantic-ai Agent with no tools, and extracts the review.
+    """
+    try:
+        from pydantic_ai import Agent as PydanticAgent
+
+        from code_muse.agents._builder import load_muse_rules
+        from code_muse.config import get_global_model_name
+        from code_muse.model_factory import ModelFactory, make_model_settings
+        from code_muse.model_utils import prepare_prompt_for_model
+
+        model_name = get_auto_review_model() or get_global_model_name()
+        if not model_name:
+            logger.warning("No model available for auto-review")
+            return None
+
+        models_config = ModelFactory.load_config()
+        if model_name not in models_config:
+            logger.warning("Reviewer model '%s' not found in config", model_name)
+            return None
+
+        model = ModelFactory.get_model(model_name, models_config)
+        if model is None:
+            logger.warning("Could not create reviewer model instance")
+            return None
+
+        # Build reviewer instructions
+        instructions = REVIEWER_SYSTEM_PROMPT
+        rules = load_muse_rules()
+        if rules:
+            instructions += f"\n\nProject rules:\n{rules}"
+
+        prepared = prepare_prompt_for_model(
+            model_name,
+            instructions,
+            prompt,
+            prepend_system_to_user=False,
+        )
+        instructions = prepared.instructions
+        user_prompt = prepared.user_prompt or prompt
+
+        model_settings = make_model_settings(model_name)
+
+        # Create a temporary agent with no tools — just text in, text out
+        review_agent = PydanticAgent(
+            model=model,
+            instructions=instructions,
+            output_type=str,
+            retries=1,
+            model_settings=model_settings,
+        )
+
+        result = await review_agent.run(user_prompt, message_history=[])
+        text = result.data if hasattr(result, "data") else str(result)
+
+        # Try to parse JSON from the response
+        # Look for JSON block first
+        import re
+
+        json_match = re.search(r"\{[^{}]*\}", text, re.DOTALL)
+        if json_match:
+            # Expand to find complete JSON object
+            start = text.find("{")
+            end = text.rfind("}") + 1
+            if start >= 0 and end > start:
+                json_str = text[start:end]
+                return json.loads(json_str)
+
+        # Try parsing entire response as JSON
+        try:
+            return json.loads(text)
+        except json.JSONDecodeError:
+            pass
+
+        # Fallback: simple heuristic
+        text_lower = text.lower()
+        if (
+            "looks good" in text_lower
+            or "approved" in text_lower
+            or "no issues" in text_lower
+        ):
+            return {
+                "verdict": "approved",
+                "summary": text[:200],
+                "issues": [],
+                "suggestion": None,
+            }
+        return {
+            "verdict": "flagged",
+            "summary": text[:200],
+            "issues": ["Reviewer produced unstructured output"],
+            "suggestion": None,
+        }
+
+    except Exception as exc:
+        logger.error("Auto-review LLM call failed: %s", exc, exc_info=True)
+        return None
+
+
+async def run_auto_review(
+    tool_name: str,
+    tool_args: dict,
+    result: dict,
+) -> None:
+    """Main entry point — run auto-review on a completed tool call.
+
+    Called from the ``post_tool_call`` hook. Checks eligibility,
+    extracts context, checks cache, calls reviewer, emits results.
+    """
+    if not is_auto_review_enabled():
+        return
+
+    # Only review file modification tools
+    if tool_name not in _FILE_MOD_TOOLS:
+        return
+
+    context = _extract_review_context(tool_name, tool_args, result)
+    if context is None:
+        return
+
+    # Check cache
+    cache = get_review_cache()
+    cached = cache.get(context["file_path"], context["content_hash"])
+    if cached is not None:
+        emit_review_approved(context["file_path"], "Already reviewed (cached)")
+        return
+
+    # Emit visibility: review started
+    emit_review_started(context["file_path"])
+
+    # Build prompt and call reviewer
+    prompt = _build_reviewer_prompt(context)
+    review = await _call_reviewer_llm(prompt)
+
+    if review is None:
+        emit_review_error(context["file_path"], "Reviewer LLM call failed")
+        return
+
+    # Cache and emit result
+    cache.set(context["file_path"], context["content_hash"], review)
+
+    verdict = review.get("verdict", "flagged")
+    summary = review.get("summary", "No summary provided")
+    issues = review.get("issues", [])
+    suggestion = review.get("suggestion")
+
+    if verdict == "approved":
+        if suggestion:
+            summary += f" — Suggestion: {suggestion}"
+        emit_review_approved(context["file_path"], summary)
+    elif verdict == "rejected":
+        emit_review_rejected(context["file_path"], summary, issues)
+    else:
+        emit_review_flagged(context["file_path"], summary, issues)
+
+
+# Tool: manual review request
+async def request_manual_review(file_path: str, reason: str | None = None) -> dict:
+    """Request a manual code review for a specific file.
+
+    This is registered as an agent tool so users can trigger review explicitly.
+    """
+    try:
+        # Read the file content directly
+        file_content = ""
+        try:
+            from pathlib import Path
+
+            p = Path(file_path).expanduser().resolve()
+            if p.exists() and p.is_file():
+                file_content = p.read_text(encoding="utf-8", errors="replace")
+        except Exception:
+            pass
+
+        context = {
+            "file_path": file_path,
+            "operation": "manual_review",
+            "diff": file_content[:5000],
+            "content_hash": _compute_content_hash(file_path, file_content[:5000]),
+        }
+
+        prompt = _build_reviewer_prompt(context)
+        if reason:
+            prompt += f"\n\nReview focus: {reason}"
+
+        emit_review_started(file_path)
+        review = await _call_reviewer_llm(prompt)
+
+        if review is None:
+            return {"error": "Reviewer LLM call failed", "file_path": file_path}
+
+        return {
+            "file_path": file_path,
+            "verdict": review.get("verdict", "flagged"),
+            "summary": review.get("summary", ""),
+            "issues": review.get("issues", []),
+            "suggestion": review.get("suggestion"),
+        }
+
+    except Exception as exc:
+        logger.error("Manual review failed: %s", exc, exc_info=True)
+        return {"error": str(exc), "file_path": file_path}

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

@@ -0,0 +1,45 @@
+"""Visibility helpers for auto-review — emit visible status messages."""
+
+import logging
+
+from code_muse.messaging import emit_info, emit_success, emit_warning
+
+logger = logging.getLogger(__name__)
+
+
+def emit_review_started(file_path: str) -> None:
+    """Emit a visible message that review is starting."""
+    emit_info(f"🔍 Auto-review in progress... ({file_path})")
+
+
+def emit_review_approved(file_path: str, summary: str) -> None:
+    """Emit a success message when review passes."""
+    emit_success(f"✅ Auto-review passed: {summary}")
+
+
+def emit_review_flagged(file_path: str, summary: str, issues: list[str]) -> None:
+    """Emit a warning when review flags issues."""
+    msg = f"⚠️ Auto-review: {summary}"
+    for issue in issues:
+        msg += f"\n  • {issue}"
+    emit_warning(msg)
+
+
+def emit_review_rejected(file_path: str, summary: str, issues: list[str]) -> None:
+    """Emit an error when review rejects the change."""
+    from code_muse.messaging import emit_error
+
+    msg = f"❌ Auto-review rejected: {summary}"
+    for issue in issues:
+        msg += f"\n  • {issue}"
+    emit_error(msg)
+
+
+def emit_review_skipped(reason: str) -> None:
+    """Emit info when review is skipped."""
+    emit_info(f"⏭️ Auto-review skipped: {reason}")
+
+
+def emit_review_error(file_path: str, error_msg: str) -> None:
+    """Emit warning when the review itself fails."""
+    emit_warning(f"⚠️ Auto-review error for {file_path}: {error_msg}")

{code_muse-0.1.0 → code_muse-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-muse"
-version = "0.1.0"
+version = "0.1.2"
 description = "Muse — eternal guide of creators in the arts and sciences. An elegant AI coding assistant."
 readme = "README.md"
 requires-python = ">=3.14,<3.16"