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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-muse
-Version: 0.1.0
+Version: 0.1.3
 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.3/code_muse/__init__.py

@@ -0,0 +1,87 @@
+import importlib.metadata
+import logging
+import os
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# Biscuit was here.
+try:
+    _detected_version = importlib.metadata.version("code-muse")
+    # Ensure we never end up with None or empty string
+    __version__ = _detected_version if _detected_version else "0.0.0-dev"
+except Exception:
+    # Fallback for dev environments where metadata might not be available
+    __version__ = "0.0.0-dev"
+
+
+def _rebuild_stale_cython_modules(package_root: Path) -> None:
+    """Delete stale compiled extensions so pyximport rebuilds them.
+
+    Checks both file mtime AND embedded module name to catch extensions
+    compiled from an older package version (e.g. after a rename from
+    ``code_puppy`` to ``code_muse``).
+
+    Safe no-op when no ``.pyx`` files exist or no stale extensions found.
+    """
+    if not list(package_root.rglob("*.pyx")):
+        return
+
+    import importlib.util
+
+    # Read first 4 KB of each .so to check for old module names.
+    # Compiled Cython modules embed their source package path (e.g.
+    # ``code_puppy.plugins.…``) in the binary.
+    _OLD_NAMES = [b"code_puppy", b"code.puppy"]
+
+    stale_count = 0
+    for pyx_file in package_root.rglob("*.pyx"):
+        pyx_mtime = pyx_file.stat().st_mtime
+        parent = pyx_file.parent
+        stem = pyx_file.stem
+
+        for so_file in parent.glob(f"{stem}*.so"):
+            if not so_file.is_file():
+                continue
+
+            # 1. Mtime check: .so is older than .pyx source
+            # 2. Content check: .so still references old package name
+            is_stale = so_file.stat().st_mtime < pyx_mtime
+            if not is_stale:
+                try:
+                    header = so_file.read_bytes()[:4096]
+                    is_stale = any(old in header for old in _OLD_NAMES)
+                except OSError:
+                    pass
+
+            if is_stale:
+                try:
+                    so_file.unlink()
+                    stale_count += 1
+                    logger.debug("Removed stale extension: %s", so_file)
+                except OSError:
+                    pass
+
+    if stale_count:
+        logger.info(
+            "Removed %d stale Cython extension(s) — will rebuild on next import",
+            stale_count,
+        )
+
+
+# Enable Cython JIT compilation for .pyx modules throughout the package.
+_CYTHON_AVAILABLE = False
+_PACKAGE_ROOT = Path(__file__).parent
+try:
+    import pyximport
+
+    pyximport.install(language_level=3, build_in_temp=True, inplace=True)
+    _CYTHON_AVAILABLE = True
+    _rebuild_stale_cython_modules(_PACKAGE_ROOT)
+except Exception:
+    pass  # Cython not available — .pyx modules will need pre-compiled extension files
+
+# Scan the package tree for .pyx modules and record Cython status.
+_pyx_files = list(_PACKAGE_ROOT.rglob("*.pyx"))
+PYX_MODULE_COUNT: int = len(_pyx_files)
+CYTHON_ENABLED: bool = _CYTHON_AVAILABLE and PYX_MODULE_COUNT > 0

{code_muse-0.1.0 → code_muse-0.1.3}/code_muse/agents/_compaction.py

@@ -21,6 +21,7 @@ from pydantic_ai.messages import (
     ModelResponse,
     TextPart,
     ThinkingPart,
+    ToolReturnPart,
 )
 
 from code_muse.agents._history import (
@@ -49,7 +50,8 @@ _SUMMARIZATION_INSTRUCTIONS = (
     " as well as user queries, etc. Summarize the contents of these steps."
     " The high level details should remain but the bulk of the content from tool-call"
     " responses should be compacted and summarized. For example if you see a tool-call"
-    " reading a file, and the file contents are large, then in your summary you might just"
+    " reading a file, and the file contents are large, then in your"
+    " summary you might just"
     " write: * used read_file on space_invaders.cpp - contents removed."
     "\n Make sure your result is a bulleted list of all steps and interactions."
     "\n\nNOTE: This summary represents older conversation history. "
@@ -147,7 +149,8 @@ def truncate(
     model_name: str | None = None,
     cache: CompactionCache | None = None,
 ) -> list[ModelMessage]:
-    """Drop middle messages, keeping system prompt, optional thinking, and recent tail."""
+    """Drop middle messages, keeping system prompt, optional thinking,
+    and recent tail."""
     import queue
 
     if not messages:
@@ -223,7 +226,8 @@ def _run_summarization_core(
 
     if not isinstance(new_messages, list):
         emit_warning(
-            "Summarization agent returned non-list output; wrapping into message request"
+            "Summarization agent returned non-list output;"
+            " wrapping into message request"
         )
         new_messages = [ModelRequest([TextPart(str(new_messages))])]
 
@@ -425,7 +429,7 @@ def make_history_processor(agent: Any) -> Callable[..., list[ModelMessage]]:
       1. Fires ``on_message_history_processor_start``.
       2. Merges any incoming messages not already in ``agent._message_history``
          (preserving the last-message regardless of compacted-hash collisions).
-      3. Runs ``compact(...)`` if we're over threshold.
+      3. Runs ``compact_with_tool_truncation(...)`` if we're over threshold — truncates older tool-result content first, then falls through to compact().
       4. Records dropped-message hashes in ``agent._compacted_message_hashes``.
       5. Strips empty ThinkingParts.
       6. Trims trailing ModelResponse messages so history ends with a ModelRequest.
@@ -467,7 +471,7 @@ def make_history_processor(agent: Any) -> Callable[..., list[ModelMessage]]:
                 history.append(msg)
                 messages_added += 1
 
-        new_history, dropped = compact(
+        new_history, dropped = compact_with_tool_truncation(
             agent,
             history,
             agent._get_model_context_length(),
@@ -504,3 +508,110 @@ def make_history_processor(agent: Any) -> Callable[..., list[ModelMessage]]:
         return cleaned
 
     return history_processor
+
+
+# --- Phase 3: Enhanced History Compression ---
+PROTECTION_ZONE_MESSAGES = 6  # Last N messages never pruned
+RECENT_TOOL_RESULTS_TO_KEEP = 7  # Keep last N tool results in full
+
+
+def _truncate_tool_result_content(
+    messages: list[ModelMessage],
+    keep_count: int = RECENT_TOOL_RESULTS_TO_KEEP,
+) -> list[ModelMessage]:
+    """Replace older tool result content with a truncation marker.
+
+    Keeps the last `keep_count` tool results in full.
+    Older tool results get their content replaced with a short notice.
+    The structural pairing (tool_call ↔ tool_return) stays intact.
+
+    Only affects ToolReturnPart content — all other parts preserved.
+    """
+    # Reverse-scan: collect tool_call_ids of the most recent N tool results
+    protected_ids: set[str] = set()
+    seen = 0
+    for i in range(len(messages) - 1, -1, -1):
+        msg = messages[i]
+        if isinstance(msg, ModelRequest):
+            for part in msg.parts:
+                if isinstance(part, ToolReturnPart):
+                    seen += 1
+                    if seen <= keep_count:
+                        protected_ids.add(part.tool_call_id)
+
+    # Forward-pass: truncate old results
+    result: list[ModelMessage] = []
+    TRUNCATION_MSG = "[Result truncated — re-call tool if full output is needed]"
+
+    for msg in messages:
+        if not isinstance(msg, ModelRequest):
+            result.append(msg)
+            continue
+        new_parts = []
+        for part in msg.parts:
+            if (
+                isinstance(part, ToolReturnPart)
+                and part.tool_call_id not in protected_ids
+            ):
+                # Replace content, keep structure
+                try:
+                    if hasattr(part, "model_copy"):
+                        new_parts.append(
+                            part.model_copy(update={"content": TRUNCATION_MSG})
+                        )
+                    else:
+                        new_parts.append(part)
+                except Exception:
+                    new_parts.append(part)
+            else:
+                new_parts.append(part)
+        result.append(ModelRequest(parts=new_parts))
+
+    return result
+
+
+def compact_with_tool_truncation(
+    agent: Any,
+    messages: list[ModelMessage],
+    model_max: int,
+    context_overhead: int,
+) -> tuple[list[ModelMessage], list[ModelMessage]]:
+    """Enhanced compact() that first truncates old tool results,
+    then runs normal compaction.
+
+    This is the Phase 3 replacement for compact(). It:
+    1. Truncates old tool result content first (always reduces tokens)
+    2. Then runs the existing compact() logic on the cleaner history
+    3. Falls through to summarization/truncation if still over threshold
+
+    Returns: (new_messages, dropped_messages_for_hash_tracking)
+    """
+    # Step 1: Truncate old tool results (always safe, always reduces tokens)
+    truncated = _truncate_tool_result_content(messages)
+
+    # Step 2: Run existing compaction on the already-trimmed history
+    # The existing compact() handles summarization or truncation if still over threshold
+    return compact(agent, truncated, model_max, context_overhead)
+
+
+def _protect_zone_messages(
+    messages: list[ModelMessage],
+    zone_size: int = PROTECTION_ZONE_MESSAGES,
+) -> tuple[list[ModelMessage], list[ModelMessage]]:
+    """Split messages into (middle_for_summarization, protected_tail).
+
+    The last `zone_size` messages (or fewer if history is short) are protected
+    and never summarized/truncated. Returns (middle, protected).
+
+    System message (index 0) is always protected.
+    """
+    if len(messages) <= zone_size + 1:
+        return [], messages
+
+    split_idx = max(1, len(messages) - zone_size)
+    # Adjust split to not sever tool_call/tool_return pairs (use existing logic)
+    adjusted_idx = _find_safe_split_index(messages, split_idx)
+
+    middle = messages[1:adjusted_idx]
+    protected = messages[:1] + messages[adjusted_idx:]
+    return middle, protected

{code_muse-0.1.0 → code_muse-0.1.3}/code_muse/agents/_history.py

@@ -20,7 +20,7 @@ from typing import Any
 
 import pydantic
 from pydantic_ai import BinaryContent
-from pydantic_ai.messages import ModelMessage
+from pydantic_ai.messages import ModelMessage, ModelRequest, ToolReturnPart
 
 
 def _json_safe(obj):
@@ -380,3 +380,10 @@ class CompactionCache:
     ) -> int:
         """Sum estimated tokens across all messages using the cache."""
         return sum(self.estimate_tokens(m, model_name) for m in messages)
+
+
+def is_tool_result_message(msg: ModelMessage) -> bool:
+    """Check if a message contains tool return parts."""
+    if isinstance(msg, ModelRequest):
+        return any(isinstance(p, ToolReturnPart) for p in msg.parts)
+    return False

{code_muse-0.1.0 → code_muse-0.1.3}/code_muse/hook_engine/registry.py

@@ -56,7 +56,7 @@ def build_registry_from_config(
             if not isinstance(group, dict):
                 continue
 
-            matcher = group.get("matcher", "*")
+            matcher = group.get("matcher") or "*"
             hooks_data = group.get("hooks", [])
 
             for hook_data in hooks_data:

{code_muse-0.1.0 → code_muse-0.1.3}/code_muse/hook_engine/validator.py

@@ -60,6 +60,8 @@ def validate_hooks_config(config: dict[str, Any]) -> tuple[bool, list[str]]:
 
             if "matcher" not in group:
                 errors.append(f"'{event_type}[{i}]' missing required field 'matcher'")
+            elif not group["matcher"]:
+                errors.append(f"'{event_type}[{i}]' matcher cannot be empty string — use '*' to match all events")
 
             if "hooks" not in group:
                 errors.append(f"'{event_type}[{i}]' missing required field 'hooks'")

code_muse-0.1.3/code_muse/models.json

@@ -0,0 +1 @@
+{}

{code_muse-0.1.0 → code_muse-0.1.3}/code_muse/plugins/__init__.py

@@ -28,6 +28,30 @@ USER_PLUGINS_DIR = Path.home() / ".muse" / "plugins"
 # Track if plugins have already been loaded to prevent duplicate registration
 _PLUGINS_LOADED = False
 
+def _clean_stale_pycache(root_dir: Path) -> None:
+    """Remove stale __pycache__ directories to prevent import ghosts.
+
+    Deletes any __pycache__ directory whose containing .py file no longer
+    exists.  This prevents stale bytecode from old package names (e.g.
+    after a rename) from causing ``No module named X`` errors.
+    """
+    import shutil
+
+    for pycache_dir in list(root_dir.rglob("__pycache__")):
+        if not pycache_dir.is_dir():
+            continue
+        # Check if any .py file in parent directory still exists
+        parent = pycache_dir.parent
+        has_py_files = any(parent.glob("*.py"))
+        if not has_py_files:
+            # Parent dir has no .py files anymore — likely a removed module
+            try:
+                shutil.rmtree(pycache_dir)
+                logger.debug("Cleaned stale __pycache__: %s", pycache_dir)
+            except OSError:
+                pass
+
+
 # ---------------------------------------------------------------------------
 # Trust manifest helpers
 # ---------------------------------------------------------------------------
@@ -420,6 +444,9 @@ def load_plugin_callbacks() -> dict[str, list[str]]:
     NOTE: This function is idempotent - calling it multiple times will only
     load plugins once. Subsequent calls return empty lists.
     """
+    # Clean stale __pycache__ to prevent import ghosts from renames
+    _clean_stale_pycache(Path(__file__).parent)
+
     global _PLUGINS_LOADED
 
     # Prevent duplicate loading - plugins register callbacks at import time,

code_muse-0.1.3/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.3/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.3/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.3/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.3/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"
+}
+"""