claude-mpm 4.7.5__tar.gz → 4.7.6__tar.gz

claude_mpm-4.7.6/BUILD_NUMBER

@@ -0,0 +1 @@
+433

{claude_mpm-4.7.5 → claude_mpm-4.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.7.5
+Version: 4.7.6
 Summary: Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking
 Author-email: Bob Matsuoka <bob@matsuoka.com>
 Maintainer: Claude MPM Team

claude_mpm-4.7.6/VERSION

@@ -0,0 +1 @@
+4.7.6

claude_mpm-4.7.6/claude-mpm

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+# clod-npm - Binary executable to load claude-mpm from this local project
+
+# Get the directory where this script is located, following symlinks
+SOURCE="${BASH_SOURCE[0]}"
+while [ -h "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symlink
+    DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
+    SOURCE="$(readlink "$SOURCE")"
+    [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE" # if $SOURCE was a relative symlink
+done
+SCRIPT_DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
+
+# Project root is where this script is located
+PROJECT_ROOT="$SCRIPT_DIR"
+
+# Use the existing claude-mpm script from this project
+CLAUDE_MPM_SCRIPT="$PROJECT_ROOT/scripts/claude-mpm"
+
+# Check if the claude-mpm script exists
+if [ ! -f "$CLAUDE_MPM_SCRIPT" ]; then
+    echo "Error: claude-mpm script not found at $CLAUDE_MPM_SCRIPT"
+    echo "Make sure you're running this from the claude-mpm project root"
+    exit 1
+fi
+
+# Make sure the script is executable
+chmod +x "$CLAUDE_MPM_SCRIPT"
+
+# Execute the claude-mpm script with all arguments
+exec "$CLAUDE_MPM_SCRIPT" "$@"

{claude_mpm-4.7.5 → claude_mpm-4.7.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-mpm"
-version = "4.7.5"
+version = "4.7.6"
 description = "Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -84,7 +84,7 @@ ignore-imports = false
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "4.7.5"
+version = "4.7.6"
 version_files = [ "VERSION", "src/claude_mpm/VERSION", "package.json:version",]
 tag_format = "v$version"
 update_changelog_on_bump = true

claude_mpm-4.7.6/src/claude_mpm/VERSION

@@ -0,0 +1 @@
+4.7.6

{claude_mpm-4.7.5 → claude_mpm-4.7.6}/src/claude_mpm/cli/commands/configure.py

@@ -374,7 +374,9 @@ class ConfigureCommand(BaseCommand):
         self.console.print(menu_panel)
         self.console.print()
 
-        return Prompt.ask("[bold cyan]Select an option[/bold cyan]", default="q")
+        choice = Prompt.ask("[bold cyan]Select an option[/bold cyan]", default="q")
+        # Strip whitespace to handle leading/trailing spaces
+        return choice.strip().lower()
 
     def _manage_agents(self) -> None:
         """Agent management interface."""
@@ -425,7 +427,7 @@ class ConfigureCommand(BaseCommand):
         table.add_column("ID", style="dim", width=3)
         table.add_column("Name", style="cyan", width=22)
         table.add_column("Status", width=12)
-        table.add_column("Description", style="white", width=45)
+        table.add_column("Description", style="bold cyan", width=45)
         table.add_column("Model/Tools", style="dim", width=20)
 
         for idx, agent in enumerate(agents, 1):
@@ -456,12 +458,11 @@ class ConfigureCommand(BaseCommand):
                 except Exception:
                     tools_display = "Default"
 
-            # Truncate description for table display
-            desc_display = (
-                agent.description[:42] + "..."
-                if len(agent.description) > 42
-                else agent.description
-            )
+            # Truncate description for table display with bright styling
+            if len(agent.description) > 42:
+                desc_display = f"[cyan]{agent.description[:42]}[/cyan][dim]...[/dim]"
+            else:
+                desc_display = f"[cyan]{agent.description}[/cyan]"
 
             table.add_row(str(idx), agent.name, status, desc_display, tools_display)
 
@@ -821,6 +822,61 @@ class ConfigureCommand(BaseCommand):
         with self.console.pager():
             self.console.print(syntax)
 
+    def _reset_agent_defaults(self, agents: List[AgentConfig]) -> None:
+        """Reset an agent to default enabled state and remove custom template.
+
+        This method:
+        - Prompts for agent ID
+        - Resets agent to enabled state
+        - Removes any custom template overrides
+        - Shows success/error messages
+        """
+        agent_id = Prompt.ask("Enter agent ID to reset to defaults")
+
+        try:
+            idx = int(agent_id) - 1
+            if 0 <= idx < len(agents):
+                agent = agents[idx]
+
+                # Confirm the reset action
+                if not Confirm.ask(
+                    f"[yellow]Reset '{agent.name}' to defaults? This will:[/yellow]\n"
+                    "  - Enable the agent\n"
+                    "  - Remove custom template (if any)\n"
+                    "[yellow]Continue?[/yellow]"
+                ):
+                    self.console.print("[yellow]Reset cancelled.[/yellow]")
+                    Prompt.ask("Press Enter to continue")
+                    return
+
+                # Enable the agent
+                self.agent_manager.set_agent_enabled(agent.name, True)
+
+                # Remove custom template if exists
+                template_path = self._get_agent_template_path(agent.name)
+                if template_path.exists() and not str(template_path).startswith(
+                    str(self.agent_manager.templates_dir)
+                ):
+                    # This is a custom template, remove it
+                    template_path.unlink(missing_ok=True)
+                    self.console.print(
+                        f"[green]✓ Removed custom template for '{agent.name}'[/green]"
+                    )
+
+                self.console.print(
+                    f"[green]✓ Agent '{agent.name}' reset to defaults![/green]"
+                )
+                self.console.print(
+                    "[dim]Agent is now enabled with system template.[/dim]"
+                )
+            else:
+                self.console.print("[red]Invalid agent ID.[/red]")
+
+        except ValueError:
+            self.console.print("[red]Invalid input. Please enter a number.[/red]")
+
+        Prompt.ask("Press Enter to continue")
+
     def _view_agent_details(self, agents: List[AgentConfig]) -> None:
         """View detailed information about an agent."""
         agent_id = Prompt.ask("Enter agent ID to view")
@@ -1331,7 +1387,7 @@ class ConfigureCommand(BaseCommand):
             table.add_column("ID", style="dim", width=5)
             table.add_column("Agent", style="cyan", width=25)
             table.add_column("Status", width=15)
-            table.add_column("Description", style="white", width=45)
+            table.add_column("Description", style="bold cyan", width=45)
 
             for idx, agent in enumerate(agents, 1):
                 # Agent is ENABLED if NOT in disabled list
@@ -1341,11 +1397,13 @@ class ConfigureCommand(BaseCommand):
                     if is_enabled
                     else "[red]✗ Disabled[/red]"
                 )
-                desc_display = (
-                    agent.description[:42] + "..."
-                    if len(agent.description) > 42
-                    else agent.description
-                )
+                # Format description with bright styling
+                if len(agent.description) > 42:
+                    desc_display = (
+                        f"[cyan]{agent.description[:42]}[/cyan][dim]...[/dim]"
+                    )
+                else:
+                    desc_display = f"[cyan]{agent.description}[/cyan]"
                 table.add_row(str(idx), agent.name, status, desc_display)
 
             self.console.print(table)

{claude_mpm-4.7.5 → claude_mpm-4.7.6}/src/claude_mpm/hooks/__init__.py

@@ -1,13 +1,19 @@
 """Hook system for claude-mpm."""
 
 from .base_hook import BaseHook, HookContext, HookResult, HookType
+from .kuzu_enrichment_hook import KuzuEnrichmentHook, get_kuzu_enrichment_hook
 from .kuzu_memory_hook import KuzuMemoryHook, get_kuzu_memory_hook
+from .kuzu_response_hook import KuzuResponseHook, get_kuzu_response_hook
 
 __all__ = [
     "BaseHook",
     "HookContext",
     "HookResult",
     "HookType",
+    "KuzuEnrichmentHook",
     "KuzuMemoryHook",
+    "KuzuResponseHook",
+    "get_kuzu_enrichment_hook",
     "get_kuzu_memory_hook",
+    "get_kuzu_response_hook",
 ]

claude_mpm-4.7.6/src/claude_mpm/hooks/kuzu_enrichment_hook.py

@@ -0,0 +1,263 @@
+"""
+Kuzu-Memory Pre-Delegation Enrichment Hook
+==========================================
+
+Enriches agent delegation context with relevant memories from kuzu-memory
+before the agent receives the task. This is the READ side of bidirectional
+enrichment.
+
+WHY: Agents need access to relevant historical knowledge when performing tasks.
+This hook retrieves memories from kuzu-memory and injects them into the
+delegation context.
+
+DESIGN DECISIONS:
+- Priority 10 to run early, before other context modifications
+- Reuses KuzuMemoryHook's retrieval methods for consistency
+- Injects memories as a dedicated section in agent context
+- Falls back gracefully if kuzu-memory is not available
+"""
+
+import logging
+from typing import Any, Dict, Optional
+
+from claude_mpm.hooks.base_hook import HookContext, HookResult, PreDelegationHook
+from claude_mpm.hooks.kuzu_memory_hook import get_kuzu_memory_hook
+
+logger = logging.getLogger(__name__)
+
+
+class KuzuEnrichmentHook(PreDelegationHook):
+    """
+    Hook that enriches agent delegation context with kuzu-memory.
+
+    This hook:
+    1. Extracts the task/prompt from delegation context
+    2. Retrieves relevant memories from kuzu-memory
+    3. Injects memories into agent context
+    4. Formats memories for optimal agent understanding
+    """
+
+    def __init__(self):
+        """Initialize the kuzu-memory enrichment hook."""
+        super().__init__(name="kuzu_memory_enrichment", priority=10)
+
+        # Reuse the kuzu-memory hook instance for retrieval
+        self.kuzu_hook = get_kuzu_memory_hook()
+        self.enabled = self.kuzu_hook.enabled
+
+        if not self.enabled:
+            logger.info(
+                "Kuzu-memory enrichment hook disabled (kuzu-memory not available)"
+            )
+        else:
+            logger.info("Kuzu-memory enrichment hook enabled")
+
+    def validate(self, context: HookContext) -> bool:
+        """
+        Validate if hook should process this context.
+
+        Args:
+            context: Hook context to validate
+
+        Returns:
+            True if hook should execute
+        """
+        if not self.enabled:
+            return False
+
+        # Check base validation (enabled, correct hook type, has agent)
+        if not super().validate(context):
+            return False
+
+        # Must have agent and context data
+        if not context.data.get("agent"):
+            return False
+
+        return True
+
+    def execute(self, context: HookContext) -> HookResult:
+        """
+        Enrich delegation context with relevant memories.
+
+        Args:
+            context: Hook context containing delegation data
+
+        Returns:
+            HookResult with enriched context
+        """
+        if not self.enabled:
+            return HookResult(success=True, data=context.data, modified=False)
+
+        try:
+            # Extract query for memory retrieval
+            query = self._extract_query_from_context(context.data)
+
+            if not query:
+                logger.debug("No query extracted from context for memory retrieval")
+                return HookResult(success=True, data=context.data, modified=False)
+
+            # Retrieve relevant memories
+            memories = self.kuzu_hook._retrieve_memories(query)
+
+            if not memories:
+                logger.debug("No relevant memories found")
+                return HookResult(success=True, data=context.data, modified=False)
+
+            # Enrich context with memories
+            enriched_data = self._enrich_delegation_context(
+                context.data, memories, context.data.get("agent", "Agent")
+            )
+
+            logger.info(
+                f"Enriched delegation context with {len(memories)} memories for {context.data.get('agent')}"
+            )
+
+            return HookResult(
+                success=True,
+                data=enriched_data,
+                modified=True,
+                metadata={
+                    "memories_added": len(memories),
+                    "memory_source": "kuzu",
+                    "agent": context.data.get("agent"),
+                },
+            )
+
+        except Exception as e:
+            logger.error(f"Error in kuzu enrichment hook: {e}")
+            # Don't fail the delegation if memory enrichment fails
+            return HookResult(
+                success=True,
+                data=context.data,
+                modified=False,
+                error=f"Memory enrichment failed: {e}",
+            )
+
+    def _extract_query_from_context(self, data: Dict[str, Any]) -> Optional[str]:
+        """
+        Extract query text for memory retrieval.
+
+        Args:
+            data: Delegation context data
+
+        Returns:
+            Query string or None
+        """
+        # Try various context fields
+        delegation_context = data.get("context", {})
+
+        # Handle string context
+        if isinstance(delegation_context, str):
+            return delegation_context
+
+        # Handle dict context
+        if isinstance(delegation_context, dict):
+            # Try common fields
+            for field in ["prompt", "task", "query", "user_request", "description"]:
+                if field in delegation_context:
+                    value = delegation_context[field]
+                    if isinstance(value, str):
+                        return value
+
+            # If no specific field, join all string values
+            text_parts = [
+                str(v) for v in delegation_context.values() if isinstance(v, str)
+            ]
+            if text_parts:
+                return " ".join(text_parts)
+
+        # Fallback: try to get task or instruction directly
+        if "task" in data and isinstance(data["task"], str):
+            return data["task"]
+
+        if "instruction" in data and isinstance(data["instruction"], str):
+            return data["instruction"]
+
+        return None
+
+    def _enrich_delegation_context(
+        self, original_data: Dict[str, Any], memories: list, agent_name: str
+    ) -> Dict[str, Any]:
+        """
+        Enrich delegation context with memories.
+
+        Args:
+            original_data: Original delegation data
+            memories: Retrieved memories
+            agent_name: Name of the agent
+
+        Returns:
+            Enriched delegation data
+        """
+        # Format memories
+        memory_section = self._format_memory_section(memories, agent_name)
+
+        # Create enriched data
+        enriched_data = original_data.copy()
+
+        # Get existing context
+        delegation_context = enriched_data.get("context", {})
+        if isinstance(delegation_context, str):
+            delegation_context = {"prompt": delegation_context}
+
+        # Add memory section
+        if isinstance(delegation_context, dict):
+            # Prepend memory section to context
+            delegation_context["kuzu_memories"] = memory_section
+
+            # If there's a main prompt/task, prepend memory note
+            for field in ["prompt", "task", "instruction"]:
+                if field in delegation_context and isinstance(
+                    delegation_context[field], str
+                ):
+                    delegation_context[field] = (
+                        f"{memory_section}\n\n{delegation_context[field]}"
+                    )
+                    break
+        else:
+            # If context is not dict, create new dict with memory
+            delegation_context = {
+                "kuzu_memories": memory_section,
+                "original_context": delegation_context,
+            }
+
+        enriched_data["context"] = delegation_context
+        enriched_data["_kuzu_enriched"] = True
+
+        return enriched_data
+
+    def _format_memory_section(self, memories: list, agent_name: str) -> str:
+        """
+        Format memories into a readable section.
+
+        Args:
+            memories: List of memory dictionaries
+            agent_name: Name of the agent
+
+        Returns:
+            Formatted memory section
+        """
+        memory_text = self.kuzu_hook._format_memories(memories)
+
+        return f"""
+=== RELEVANT KNOWLEDGE FROM KUZU MEMORY ===
+{agent_name}, you have access to these relevant memories from the knowledge graph:
+
+{memory_text}
+
+INSTRUCTIONS: Review these memories before proceeding. Apply learned patterns and avoid known mistakes.
+Use this knowledge to provide more informed and contextual responses.
+===========================================
+"""
+
+
+# Create a singleton instance
+_kuzu_enrichment_hook = None
+
+
+def get_kuzu_enrichment_hook() -> KuzuEnrichmentHook:
+    """Get the singleton kuzu-memory enrichment hook instance."""
+    global _kuzu_enrichment_hook
+    if _kuzu_enrichment_hook is None:
+        _kuzu_enrichment_hook = KuzuEnrichmentHook()
+    return _kuzu_enrichment_hook

{claude_mpm-4.7.5 → claude_mpm-4.7.6}/src/claude_mpm/hooks/kuzu_memory_hook.py

@@ -157,9 +157,13 @@ class KuzuMemoryHook(SubmitHook):
             List of relevant memory dictionaries
         """
         try:
-            # Use kuzu-memory recall command
+            # Type narrowing: ensure kuzu_memory_cmd is not None before using
+            if self.kuzu_memory_cmd is None:
+                return []
+
+            # Use kuzu-memory recall command (v1.2.7+ syntax)
             result = subprocess.run(
-                [self.kuzu_memory_cmd, "recall", query, "--format", "json"],
+                [self.kuzu_memory_cmd, "memory", "recall", query, "--format", "json"],
                 capture_output=True,
                 text=True,
                 timeout=5,
@@ -168,10 +172,21 @@ class KuzuMemoryHook(SubmitHook):
             )
 
             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:
+                try:
+                    # Parse JSON with strict=False to handle control characters
+                    data = json.loads(result.stdout, strict=False)
+                    # v1.2.7 returns dict with 'memories' key, not array
+                    if isinstance(data, dict):
+                        memories = data.get("memories", [])
+                    else:
+                        memories = data if isinstance(data, list) else []
+                    return memories
+                except json.JSONDecodeError as e:
+                    logger.warning(f"Failed to parse kuzu-memory JSON output: {e}")
+                    logger.debug(f"Raw output: {result.stdout[:200]}")
+                    return []  # Graceful fallback
+
+        except (subprocess.TimeoutExpired, Exception) as e:
             logger.debug(f"Memory retrieval failed: {e}")
 
         return []
@@ -255,12 +270,12 @@ Note: Use the memories above to provide more informed and contextual responses.
         Returns:
             True if storage was successful
         """
-        if not self.enabled:
+        if not self.enabled or self.kuzu_memory_cmd is None:
             return False
 
         try:
-            # Use kuzu-memory remember command (synchronous)
-            cmd = [self.kuzu_memory_cmd, "remember", content]
+            # Use kuzu-memory store command (v1.2.7+ syntax)
+            cmd = [self.kuzu_memory_cmd, "memory", "store", content]
 
             # Execute store command in project directory
             result = subprocess.run(
@@ -273,8 +288,10 @@ Note: Use the memories above to provide more informed and contextual responses.
             )
 
             if result.returncode == 0:
-                logger.debug(f"Stored memory: {content[:50]}...")
+                logger.debug(f"Stored memory in kuzu: {content[:50]}...")
                 return True
+            logger.warning(f"Failed to store memory in kuzu: {result.stderr}")
+            return False
 
         except Exception as e:
             logger.error(f"Failed to store memory: {e}")