claude-mpm 4.4.0__py3-none-any.whl → 4.4.4__py3-none-any.whl

claude_mpm/core/log_manager.py

@@ -23,10 +23,11 @@ from queue import Full, Queue
 from threading import Lock, Thread
 from typing import Any, Dict, Optional
 
+from claude_mpm.core.logging_utils import get_logger
+
 from ..core.config import Config
 from ..core.constants import SystemLimits
 
-from claude_mpm.core.logging_utils import get_logger
 logger = get_logger(__name__)
 
 # Import cleanup utility for automatic cleanup

claude_mpm/core/tool_access_control.py

@@ -3,6 +3,7 @@
 from typing import Dict, List, Set
 
 from claude_mpm.core.logging_utils import get_logger
+
 logger = get_logger(__name__)
 
 

claude_mpm/core/unified_agent_registry.py

@@ -34,9 +34,10 @@ from enum import Enum
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Set, Union
 
+from claude_mpm.core.logging_utils import get_logger
+
 from .unified_paths import get_path_manager
 
-from claude_mpm.core.logging_utils import get_logger
 logger = get_logger(__name__)
 
 

claude_mpm/core/unified_paths.py

@@ -32,6 +32,7 @@ from pathlib import Path
 from typing import Optional, Union
 
 from claude_mpm.core.logging_utils import get_logger
+
 logger = get_logger(__name__)
 
 

claude_mpm/experimental/cli_enhancements.py

@@ -54,6 +54,7 @@ class CLIContext:
     def setup_logging(self, debug: bool = False) -> None:
         """Setup logging based on debug flag."""
         import logging
+
         level = logging.DEBUG if debug else logging.INFO
         format_str = (
             "%(asctime)s - %(name)s - %(levelname)s - %(message)s"

claude_mpm/hooks/__init__.py

@@ -1,5 +1,13 @@
 """Hook system for claude-mpm."""
 
 from .base_hook import BaseHook, HookContext, HookResult, HookType
+from .kuzu_memory_hook import KuzuMemoryHook, get_kuzu_memory_hook
 
-__all__ = ["BaseHook", "HookContext", "HookResult", "HookType"]
+__all__ = [
+    "BaseHook",
+    "HookContext",
+    "HookResult",
+    "HookType",
+    "KuzuMemoryHook",
+    "get_kuzu_memory_hook",
+]

claude_mpm/hooks/base_hook.py

@@ -8,6 +8,7 @@ from enum import Enum
 from typing import Any, Dict, Optional
 
 from claude_mpm.core.logging_utils import get_logger
+
 logger = get_logger(__name__)
 
 

claude_mpm/hooks/instruction_reinforcement.py

@@ -11,6 +11,7 @@ from enum import Enum
 from typing import Dict, List, Optional, Tuple
 
 from claude_mpm.core.logging_utils import get_logger
+
 logger = get_logger(__name__)
 
 

claude_mpm/hooks/kuzu_memory_hook.py

@@ -0,0 +1,359 @@
+"""
+Kuzu-Memory Integration Hook
+============================
+
+Integrates kuzu-memory knowledge graph with Claude MPM for persistent memory
+across conversations. This hook intercepts user prompts to enrich them with
+relevant memories and stores new learnings after responses.
+
+WHY: Claude MPM needs a way to persistently remember information across
+different conversations and sessions. Kuzu-memory provides a graph database
+for structured memory storage with semantic search capabilities.
+
+DESIGN DECISIONS:
+- Priority 10 for early execution to enrich prompts before other hooks
+- Uses subprocess to call kuzu-memory directly for maximum compatibility
+- Graceful degradation if kuzu-memory is not installed
+- Automatic extraction and storage of important information
+"""
+
+import json
+import re
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from claude_mpm.core.logging_utils import get_logger
+from claude_mpm.hooks.base_hook import HookContext, HookResult, SubmitHook
+
+logger = get_logger(__name__)
+
+
+class KuzuMemoryHook(SubmitHook):
+    """
+    Hook that integrates kuzu-memory for persistent knowledge management.
+
+    This hook:
+    1. Checks if kuzu-memory is installed via pipx
+    2. Enriches user prompts with relevant memories
+    3. Stores important information from conversations
+    4. Provides context-aware memory retrieval
+    """
+
+    def __init__(self):
+        """Initialize the kuzu-memory integration hook."""
+        super().__init__(name="kuzu_memory_integration", priority=10)
+
+        # Check if kuzu-memory is available
+        self.kuzu_memory_cmd = self._detect_kuzu_memory()
+        self.enabled = self.kuzu_memory_cmd is not None
+
+        if not self.enabled:
+            logger.info("Kuzu-memory not found. Install with: pipx install kuzu-memory")
+        else:
+            logger.info(f"Kuzu-memory integration enabled: {self.kuzu_memory_cmd}")
+
+        # Use current project directory (kuzu-memory works with project-specific databases)
+        self.project_path = Path.cwd()
+
+        # Memory extraction patterns
+        self.memory_patterns = [
+            r"#\s*(?:Remember|Memorize|Store):\s*(.+?)(?:#|$)",
+            r"(?:Important|Note|Key point):\s*(.+?)(?:\n|$)",
+            r"(?:Learned|Discovered|Found that):\s*(.+?)(?:\n|$)",
+        ]
+
+    def _detect_kuzu_memory(self) -> Optional[str]:
+        """
+        Detect if kuzu-memory is installed and return its command path.
+
+        Priority:
+        1. Check pipx installation
+        2. Check system PATH
+        3. Return None if not found
+        """
+        # Check pipx installation
+        pipx_path = (
+            Path.home()
+            / ".local"
+            / "pipx"
+            / "venvs"
+            / "kuzu-memory"
+            / "bin"
+            / "kuzu-memory"
+        )
+        if pipx_path.exists():
+            return str(pipx_path)
+
+        # Check system PATH
+        kuzu_cmd = shutil.which("kuzu-memory")
+        if kuzu_cmd:
+            return kuzu_cmd
+
+        return None
+
+    def execute(self, context: HookContext) -> HookResult:
+        """
+        Process user prompts with kuzu-memory integration.
+
+        This method:
+        1. Retrieves relevant memories for the prompt
+        2. Enriches the prompt with memory context
+        3. Stores new memories after processing
+        """
+        if not self.enabled:
+            return HookResult(success=True, data=context.data, modified=False)
+
+        try:
+            # Extract user prompt
+            prompt = context.data.get("prompt", "")
+            if not prompt:
+                return HookResult(success=True, data=context.data, modified=False)
+
+            # Retrieve relevant memories
+            memories = self._retrieve_memories(prompt)
+
+            if memories:
+                # Enrich prompt with memories
+                enriched_data = self._enrich_prompt(context.data, prompt, memories)
+
+                logger.info(f"Enriched prompt with {len(memories)} memories")
+
+                # Store the original prompt for later processing
+                enriched_data["_original_prompt"] = prompt
+                enriched_data["_memory_enriched"] = True
+
+                return HookResult(
+                    success=True,
+                    data=enriched_data,
+                    modified=True,
+                    metadata={
+                        "memories_added": len(memories),
+                        "memory_source": "kuzu",
+                    },
+                )
+
+            return HookResult(success=True, data=context.data, modified=False)
+
+        except Exception as e:
+            logger.error(f"Kuzu-memory hook failed: {e}")
+            # Don't fail the request if memory integration fails
+            return HookResult(
+                success=True,
+                data=context.data,
+                modified=False,
+                error=f"Memory integration failed: {e}",
+            )
+
+    def _retrieve_memories(self, query: str) -> List[Dict[str, Any]]:
+        """
+        Retrieve relevant memories for the given query.
+
+        Args:
+            query: The user prompt to find memories for
+
+        Returns:
+            List of relevant memory dictionaries
+        """
+        try:
+            # Use kuzu-memory recall command
+            result = subprocess.run(
+                [self.kuzu_memory_cmd, "recall", query, "--format", "json"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                cwd=str(self.project_path), check=False,
+            )
+
+            if result.returncode == 0 and result.stdout:
+                memories = json.loads(result.stdout)
+                return memories if isinstance(memories, list) else []
+
+        except (subprocess.TimeoutExpired, json.JSONDecodeError, Exception) as e:
+            logger.debug(f"Memory retrieval failed: {e}")
+
+        return []
+
+    def _enrich_prompt(
+        self, original_data: Dict[str, Any], prompt: str, memories: List[Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        """
+        Enrich the user prompt with relevant memories.
+
+        Args:
+            original_data: Original hook context data
+            prompt: User prompt
+            memories: Retrieved memories
+
+        Returns:
+            Enriched context data
+        """
+        # Format memories for context
+        memory_context = self._format_memories(memories)
+
+        # Create enriched prompt
+        enriched_prompt = f"""
+## RELEVANT MEMORIES FROM KUZU KNOWLEDGE GRAPH
+
+{memory_context}
+
+## USER REQUEST
+
+{prompt}
+
+Note: Use the memories above to provide more informed and contextual responses.
+"""
+
+        # Create new data with enriched prompt
+        enriched_data = original_data.copy()
+        enriched_data["prompt"] = enriched_prompt
+
+        return enriched_data
+
+    def _format_memories(self, memories: List[Dict[str, Any]]) -> str:
+        """
+        Format memories into a readable context string.
+
+        Args:
+            memories: List of memory dictionaries
+
+        Returns:
+            Formatted memory context
+        """
+        if not memories:
+            return "No relevant memories found."
+
+        formatted = []
+        for i, memory in enumerate(memories, 1):
+            # Extract memory content and metadata
+            content = memory.get("content", "")
+            tags = memory.get("tags", [])
+            timestamp = memory.get("timestamp", "")
+            relevance = memory.get("relevance", 0.0)
+
+            # Format memory entry
+            entry = f"{i}. {content}"
+            if tags:
+                entry += f" [Tags: {', '.join(tags)}]"
+            if relevance > 0:
+                entry += f" (Relevance: {relevance:.2f})"
+
+            formatted.append(entry)
+
+        return "\n".join(formatted)
+
+    def store_memory(self, content: str, tags: Optional[List[str]] = None) -> bool:
+        """
+        Store a memory using kuzu-memory.
+
+        Args:
+            content: The memory content to store
+            tags: Optional tags for categorization
+
+        Returns:
+            True if storage was successful
+        """
+        if not self.enabled:
+            return False
+
+        try:
+            # Use kuzu-memory remember command (synchronous)
+            cmd = [self.kuzu_memory_cmd, "remember", content]
+
+            # Execute store command in project directory
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=5,
+                cwd=str(self.project_path), check=False,
+            )
+
+            if result.returncode == 0:
+                logger.debug(f"Stored memory: {content[:50]}...")
+                return True
+
+        except Exception as e:
+            logger.error(f"Failed to store memory: {e}")
+
+        return False
+
+    def extract_and_store_learnings(self, text: str) -> int:
+        """
+        Extract learnings from text and store them as memories.
+
+        Args:
+            text: Text to extract learnings from
+
+        Returns:
+            Number of learnings stored
+        """
+        if not self.enabled:
+            return 0
+
+        stored_count = 0
+
+        # Extract learnings using patterns
+        for pattern in self.memory_patterns:
+            matches = re.finditer(pattern, text, re.IGNORECASE | re.MULTILINE)
+            for match in matches:
+                learning = match.group(1).strip()
+                if learning and len(learning) > 10:  # Minimum length check
+                    # Determine tags based on content
+                    tags = self._infer_tags(learning)
+
+                    # Store the learning
+                    if self.store_memory(learning, tags):
+                        stored_count += 1
+
+        return stored_count
+
+    def _infer_tags(self, content: str) -> List[str]:
+        """
+        Infer tags based on memory content.
+
+        Args:
+            content: Memory content
+
+        Returns:
+            List of inferred tags
+        """
+        tags = []
+        content_lower = content.lower()
+
+        # Technical tags
+        if any(
+            word in content_lower for word in ["code", "function", "class", "module"]
+        ):
+            tags.append("technical")
+        if any(word in content_lower for word in ["bug", "error", "fix", "issue"]):
+            tags.append("debugging")
+        if any(word in content_lower for word in ["pattern", "architecture", "design"]):
+            tags.append("architecture")
+        if any(word in content_lower for word in ["performance", "optimize", "speed"]):
+            tags.append("performance")
+
+        # Project context tags
+        if "claude-mpm" in content_lower or "mpm" in content_lower:
+            tags.append("claude-mpm")
+        if any(word in content_lower for word in ["hook", "agent", "service"]):
+            tags.append("framework")
+
+        # Default tag if no others found
+        if not tags:
+            tags.append("general")
+
+        return tags
+
+
+# Create a singleton instance
+_kuzu_memory_hook = None
+
+
+def get_kuzu_memory_hook() -> KuzuMemoryHook:
+    """Get the singleton kuzu-memory hook instance."""
+    global _kuzu_memory_hook
+    if _kuzu_memory_hook is None:
+        _kuzu_memory_hook = KuzuMemoryHook()
+    return _kuzu_memory_hook

claude_mpm/hooks/validation_hooks.py

@@ -10,9 +10,9 @@ from typing import Any, Callable, Dict, List, Optional
 
 import yaml
 
+from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.validation import AgentValidator, ValidationResult
 
-from claude_mpm.core.logging_utils import get_logger
 logger = get_logger(__name__)
 
 

claude_mpm/scripts/mpm_doctor.py

@@ -52,6 +52,7 @@ def run_diagnostics(
         - message: str - optional error message if failed
     """
 from claude_mpm.core.logging_utils import get_logger
+
 logger = get_logger(__name__)
 
     # Create diagnostic runner

claude_mpm/services/agents/loading/agent_profile_loader.py

@@ -32,11 +32,11 @@ import yaml
 
 from claude_mpm.core.base_service import BaseService
 from claude_mpm.core.config import Config
+from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.core.unified_paths import get_path_manager
 from claude_mpm.services.agents.registry import AgentRegistry
 from claude_mpm.services.memory.cache.shared_prompt_cache import SharedPromptCache
 
-from claude_mpm.core.logging_utils import get_logger
 logger = get_logger(__name__)
 
 # ============================================================================

claude_mpm/services/agents/loading/base_agent_manager.py

@@ -14,10 +14,10 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 from claude_mpm.agents.base_agent_loader import clear_base_agent_cache
+from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.services.memory.cache.shared_prompt_cache import SharedPromptCache
 from claude_mpm.services.shared import ConfigServiceBase
 
-from claude_mpm.core.logging_utils import get_logger
 logger = get_logger(__name__)
 
 

claude_mpm/services/agents/loading/framework_agent_loader.py

@@ -19,9 +19,9 @@ from claude_mpm.agents.agent_loader import (
     AgentTier,
     list_agents_by_tier,
 )
+from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.core.unified_paths import get_path_manager
 
-from claude_mpm.core.logging_utils import get_logger
 logger = get_logger(__name__)
 
 

claude_mpm/services/agents/management/agent_capabilities_generator.py

@@ -9,6 +9,7 @@ from typing import Any, Dict, List
 from jinja2 import Template
 
 from claude_mpm.core.logging_utils import get_logger
+
 logger = get_logger(__name__)
 
 

claude_mpm/services/agents/management/agent_management_service.py

@@ -19,6 +19,7 @@ import frontmatter
 import mistune
 import yaml
 
+from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.core.unified_paths import get_path_manager
 from claude_mpm.models.agent_definition import (
     AgentDefinition,
@@ -32,7 +33,6 @@ from claude_mpm.services.memory.cache.shared_prompt_cache import SharedPromptCac
 
 from ..deployment.agent_versioning import AgentVersionManager
 
-from claude_mpm.core.logging_utils import get_logger
 logger = get_logger(__name__)
 
 

claude_mpm/services/agents/memory/memory_categorization_service.py

@@ -85,7 +85,6 @@ class MemoryCategorizationService:
 
     def __init__(self):
         """Initialize the categorization service."""
-        pass
 
     def categorize_learning(self, learning: str) -> str:
         """Categorize a learning item based on its content.

claude_mpm/services/agents/memory/memory_file_service.py

@@ -41,14 +41,18 @@ class MemoryFileService:
         old_file = directory / f"{normalized_id}_memory.md"
 
         # Also check for legacy hyphenated versions
-        hyphenated_file = directory / f"{agent_id}_memories.md" if "-" in agent_id else None
+        hyphenated_file = (
+            directory / f"{agent_id}_memories.md" if "-" in agent_id else None
+        )
 
         # Migration priority:
         # 1. If hyphenated version exists and normalized doesn't, migrate it
         if hyphenated_file and hyphenated_file.exists() and not new_file.exists():
             try:
                 hyphenated_file.rename(new_file)
-                self.logger.info(f"Migrated hyphenated memory file: {hyphenated_file} -> {new_file}")
+                self.logger.info(
+                    f"Migrated hyphenated memory file: {hyphenated_file} -> {new_file}"
+                )
             except Exception as e:
                 self.logger.warning(f"Could not migrate hyphenated memory file: {e}")
                 # Fall back to using the hyphenated version

claude_mpm/services/agents/memory/memory_format_service.py

@@ -15,7 +15,6 @@ class MemoryFormatService:
 
     def __init__(self):
         """Initialize the memory format service."""
-        pass
 
     def build_simple_memory_content(self, agent_id: str, items: List[str]) -> str:
         """Build memory content as a simple list with header and timestamp.

claude_mpm/services/agents/registry/deployed_agent_discovery.py

@@ -9,10 +9,10 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 from claude_mpm.core.agent_registry import AgentRegistryAdapter
+from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.core.unified_paths import get_path_manager
 from claude_mpm.services.shared import ConfigServiceBase
 
-from claude_mpm.core.logging_utils import get_logger
 logger = get_logger(__name__)
 
 

claude_mpm/services/async_session_logger.py

@@ -29,11 +29,11 @@ from threading import Lock, Thread
 from typing import Any, Dict, Optional
 
 from claude_mpm.core.constants import PerformanceConfig, SystemLimits, TimeoutConfig
+from claude_mpm.core.logging_utils import get_logger
 
 # Import configuration manager
 from ..core.config import Config
 
-from claude_mpm.core.logging_utils import get_logger
 logger = get_logger(__name__)
 
 

claude_mpm/services/claude_session_logger.py

@@ -31,6 +31,7 @@ except ImportError:
     ASYNC_AVAILABLE = False
 
 from claude_mpm.core.logging_utils import get_logger
+
 logger = get_logger(__name__)
 
 

claude_mpm/services/core/path_resolver.py

@@ -19,6 +19,7 @@ from pathlib import Path
 from typing import Dict, Optional, Tuple
 
 from claude_mpm.core.logging_utils import get_logger
+
 from .service_interfaces import ICacheManager, IPathResolver
 
 logger = get_logger(__name__)
@@ -50,6 +51,7 @@ class PathResolver(IPathResolver):
         Args:
             cache_manager: Optional cache manager for caching resolved paths
         """
+        self.logger = get_logger("path_resolver")
         self.cache_manager = cache_manager
         self._framework_path: Optional[Path] = None
         self._deployment_context: Optional[DeploymentContext] = None

claude_mpm/services/diagnostics/checks/__init__.py

@@ -14,6 +14,7 @@ from .filesystem_check import FilesystemCheck
 from .installation_check import InstallationCheck
 from .instructions_check import InstructionsCheck
 from .mcp_check import MCPCheck
+from .mcp_services_check import MCPServicesCheck
 from .monitor_check import MonitorCheck
 from .startup_log_check import StartupLogCheck
 
@@ -27,6 +28,7 @@ __all__ = [
     "InstallationCheck",
     "InstructionsCheck",
     "MCPCheck",
+    "MCPServicesCheck",
     "MonitorCheck",
     "StartupLogCheck",
 ]