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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-muse
-Version: 0.1.2
+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.2 → 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.2 → 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.2 → 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.2 → 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.2 → 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/delegation_manager/__init__.py

@@ -0,0 +1,24 @@
+"""Multi-Agent Delegation Manager — supervisor agent with sub-agent delegation."""
+
+from code_muse.plugins.delegation_manager.delegation_manager import DelegationManager
+from code_muse.plugins.delegation_manager.supervisor_agent import SupervisorAgent
+
+
+def get_delegation_manager() -> DelegationManager:
+    """Get the singleton DelegationManager instance."""
+    from code_muse.plugins.delegation_manager.register_callbacks import _get_manager
+
+    return _get_manager()
+
+
+def get_supervisor_agent() -> SupervisorAgent:
+    """Get a fresh SupervisorAgent instance."""
+    return SupervisorAgent()
+
+
+__all__ = [
+    "DelegationManager",
+    "SupervisorAgent",
+    "get_delegation_manager",
+    "get_supervisor_agent",
+]

code_muse-0.1.3/code_muse/plugins/delegation_manager/delegation_manager.py

@@ -0,0 +1,183 @@
+"""Delegation Manager — creates isolated sub-agent runs with caching.
+
+The DelegationManager is the engine behind the Supervisor agent.  It:
+
+1. Dynamically builds delegation tool functions (one per available agent).
+2. Caches sub-agent results to avoid re-running identical tasks.
+3. Tracks active tasks and provides graceful error handling.
+
+Sub-agents are **fully isolated** — they receive only the task + context
+that the supervisor explicitly provides.  No conversation history is passed.
+"""
+
+import asyncio
+import hashlib
+import json
+import logging
+import threading
+from typing import Any, Callable
+
+from pydantic_ai import Agent, RunContext, UsageLimits
+
+from code_muse.config import get_message_limit
+from code_muse.tools.subagent_context import subagent_context
+
+logger = logging.getLogger(__name__)
+
+
+class DelegationManager:
+    """Manages creation, caching, and execution of delegation tools."""
+
+    def __init__(self) -> None:
+        self._result_cache: dict[str, str] = {}
+        self._active_tasks: dict[str, asyncio.Task] = {}
+        self._lock = threading.Lock()
+
+    def create_delegation_function(
+        self, agent_name: str, agent_config: Any
+    ) -> Callable:
+        """Create a delegation tool function for a sub-agent.
+
+        The returned function is suitable for registration as a pydantic-ai
+        tool via ``agent.tool(delegate_func)``.
+        """
+
+        async def delegate_to(
+            ctx: RunContext, task_description: str, context: str = ""
+        ) -> str:
+            """Delegate a task to a specialized sub-agent.
+
+            Sub-agents are ISOLATED — they receive ONLY this task + context.
+            They do NOT have access to your conversation history or prior tool
+            results.
+
+            Args:
+                task_description: Clear, detailed task for the sub-agent.
+                context: ALL context the sub-agent needs (file paths, code
+                    snippets, error messages, etc.) since they're isolated from
+                    conversation.
+            """
+            cache_key = self._make_cache_key(agent_name, task_description, context)
+
+            # Check cache first
+            cached = self._get_cached(cache_key)
+            if cached is not None:
+                return cached
+
+            # Execute sub-agent
+            result = await self._run_subagent(
+                agent_name, task_description, context, cache_key
+            )
+            return result
+
+        # Fix up metadata so pydantic-ai schema generation is clean
+        safe_name = agent_name.replace("-", "_")
+        delegate_to.__name__ = f"delegate_to_{safe_name}"
+        delegate_to.__doc__ = (
+            f"Delegate a task to the {agent_name} sub-agent. "
+            f"The sub-agent is isolated — it only receives the task + context you provide.\n\n"
+            f"Args:\n"
+            f"    task_description: The task to perform\n"
+            f"    context: All relevant context (file paths, code, errors, etc.)"
+        )
+        return delegate_to
+
+    # ------------------------------------------------------------------
+    # Cache helpers
+    # ------------------------------------------------------------------
+
+    def _make_cache_key(self, agent_name: str, task: str, context: str) -> str:
+        raw = f"{agent_name}:{task}:{context}"
+        return hashlib.sha256(raw.encode()).hexdigest()[:32]
+
+    def _get_cached(self, cache_key: str) -> str | None:
+        with self._lock:
+            return self._result_cache.get(cache_key)
+
+    def _cache_result(self, cache_key: str, result: str) -> None:
+        with self._lock:
+            self._result_cache[cache_key] = result
+
+    # ------------------------------------------------------------------
+    # Sub-agent execution
+    # ------------------------------------------------------------------
+
+    async def _run_subagent(
+        self, agent_name: str, task_desc: str, context: str, cache_key: str
+    ) -> str:
+        """Invoke the sub-agent using Muse's agent construction pattern.
+
+        Mimics ``code_muse/tools/agent_tools.py::invoke_agent`` but with
+        **full isolation**: no message history, no prior context, no
+        session persistence.
+        """
+        from code_muse.agents.agent_manager import load_agent
+        from code_muse.model_factory import ModelFactory, make_model_settings
+        from code_muse.tools import register_tools_for_agent
+
+        try:
+            # Load sub-agent config
+            sub_agent_config = load_agent(agent_name)
+
+            # Build prompt with full context (no history = isolated)
+            instructions = sub_agent_config.get_full_system_prompt()
+
+            # Load muse rules if available
+            try:
+                from code_muse.agents._builder import load_muse_rules
+
+                rules = load_muse_rules()
+                if rules:
+                    instructions += f"\n\n{rules}"
+            except ImportError:
+                pass
+
+            # Load prompt additions from plugins
+            try:
+                from code_muse import callbacks
+
+                prompt_additions = callbacks.on_load_prompt()
+                if prompt_additions:
+                    instructions += "\n" + "\n".join(prompt_additions)
+            except Exception:
+                pass
+
+            # Create temporary pydantic-ai agent
+            model_name = sub_agent_config.get_model_name()
+            models_config = ModelFactory.load_config()
+            model = ModelFactory.get_model(model_name, models_config)
+
+            model_settings = make_model_settings(model_name)
+
+            temp_agent = Agent(
+                model=model,
+                instructions=instructions,
+                output_type=str,
+                retries=2,
+                model_settings=model_settings,
+            )
+
+            # Register tools for the sub-agent
+            agent_tools = sub_agent_config.get_available_tools()
+            register_tools_for_agent(temp_agent, agent_tools, model_name=model_name)
+
+            # Build the combined prompt
+            prompt = f"## Task\n\n{task_desc}\n\n## Context\n\n{context}"
+
+            # Run the sub-agent with isolation
+            with subagent_context(agent_name):
+                result = await temp_agent.run(
+                    prompt,
+                    message_history=[],  # ISOLATED — no history!
+                    usage_limits=UsageLimits(request_limit=get_message_limit()),
+                )
+
+            response = result.output if result.output else ""
+            self._cache_result(cache_key, response)
+            return response
+
+        except Exception as e:
+            logger.warning(f"Sub-agent {agent_name} failed: {e}")
+            error_msg = f"Error in {agent_name} sub-agent: {type(e).__name__}: {e}"
+            self._cache_result(cache_key, error_msg)
+            return error_msg

code_muse-0.1.3/code_muse/plugins/delegation_manager/register_callbacks.py

@@ -0,0 +1,109 @@
+"""Register delegation manager callbacks.
+
+Registers:
+    - Supervisor agent via register_agents hook
+    - Delegation tools via register_tools hook
+    - /supervisor command for easy activation
+"""
+
+import logging
+from typing import Any
+
+from code_muse.callbacks import register_callback
+from code_muse.messaging import emit_info, emit_success
+
+logger = logging.getLogger(__name__)
+
+# Lazy manager singleton
+_manager = None
+
+
+def _get_manager():
+    global _manager
+    if _manager is None:
+        from code_muse.plugins.delegation_manager.delegation_manager import (
+            DelegationManager,
+        )
+
+        _manager = DelegationManager()
+    return _manager
+
+
+def _register_agents():
+    """Register the supervisor agent."""
+    from code_muse.plugins.delegation_manager.supervisor_agent import SupervisorAgent
+
+    return [{"name": "supervisor", "class": SupervisorAgent}]
+
+
+def _register_delegation_tools() -> list[dict[str, Any]]:
+    """Dynamically create delegation tools for all available agents."""
+    from code_muse.agents.agent_manager import load_agent
+    from code_muse.agents import get_available_agents
+
+    manager = _get_manager()
+
+    tools = []
+    agents = get_available_agents()
+
+    for agent_name in agents:
+        # Skip self
+        if agent_name == "supervisor":
+            continue
+        # Create delegation function using the manager
+        try:
+            agent_config = load_agent(agent_name)
+            delegate_func = manager.create_delegation_function(agent_name, agent_config)
+            tool_name = f"delegate_to_{agent_name.replace('-', '_')}"
+            tools.append(
+                {
+                    "name": tool_name,
+                    "register_func": lambda a, f=delegate_func: a.tool(f),
+                }
+            )
+        except Exception as e:
+            logger.warning(
+                f"Could not create delegation tool for {agent_name}: {e}"
+            )
+
+    return tools
+
+
+def _on_custom_command_help():
+    return [
+        (
+            "supervisor",
+            "Switch to Supervisor agent for multi-agent task orchestration",
+        ),
+    ]
+
+
+async def _on_custom_command(command: str, name: str):
+    if name != "supervisor":
+        return None
+
+    from code_muse.agents.agent_manager import set_current_agent
+
+    success = set_current_agent("supervisor")
+    if success:
+        emit_success(
+            "Switched to Supervisor agent. I can delegate tasks to specialized sub-agents!"
+        )
+    else:
+        emit_info("Could not find Supervisor agent.")
+    return True
+
+
+def _on_startup():
+    """Pre-warm the manager on startup."""
+    _get_manager()
+
+
+# Register all callbacks
+register_callback("startup", _on_startup)
+register_callback("register_agents", _register_agents)
+register_callback("register_tools", _register_delegation_tools)
+register_callback("custom_command_help", _on_custom_command_help)
+register_callback("custom_command", _on_custom_command)
+
+logger.debug("Delegation Manager plugin callbacks registered")