claude-mpm 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

claude_mpm/_version.py

@@ -6,10 +6,10 @@ try:
     try:
         __version__ = version("claude-mpm")
     except PackageNotFoundError:
-        __version__ = "1.0.0"
+        __version__ = "1.1.0"
 except ImportError:
     # Fallback for older Python versions
-    __version__ = "1.0.0"
+    __version__ = "1.1.0"
 
 # This file may be overwritten by setuptools-scm during build
 # The try/except ensures we always have a version available
@@ -25,6 +25,7 @@ def get_version_tuple():
 __version_info__ = get_version_tuple()
 
 # Version history
+# 1.1.0 - BREAKING: Removed JSON-RPC hooks, enhanced Claude Code hooks with project-specific logging
 # 1.0.0 - BREAKING: Architecture simplification, TodoWrite hooks, enhanced CLI, terminal UI
 # 0.5.0 - Comprehensive deployment support for PyPI, npm, and local installation
 # 0.3.0 - Added hook service architecture for context filtering and ticket automation

claude_mpm/agents/__init__.py

@@ -4,8 +4,8 @@ Claude PM Framework Agents Package
 System-level agent implementations with Task Tool integration.
 These agents provide specialized prompts and capabilities for PM orchestration.
 
-Uses unified agent loader to load prompts from framework/agent-roles/*.md files
-with fallback to Python constants for backward compatibility.
+Uses unified agent loader to load prompts from JSON templates in agents/templates/
+for better structure and maintainability.
 """
 
 # Import from unified agent loader

claude_mpm/agents/agent-template.yaml

@@ -0,0 +1,83 @@
+# Agent Profile Template Configuration
+# Inspired by awesome-claude-code's template system
+
+profile:
+  name: "{{AGENT_NAME}}"
+  version: "{{VERSION}}"
+  description: "{{DESCRIPTION}}"
+  author: "{{AUTHOR}}"
+  created: "{{CREATED_DATE}}"
+  
+  # Categories for organizing agents
+  categories:
+    - id: analysis
+      title: "Code Analysis Agents"
+      description: |
+        > Agents specialized in analyzing codebases, identifying patterns, and providing insights
+      icon: "🔍"
+    
+    - id: implementation
+      title: "Implementation Agents"
+      description: |
+        > Agents focused on writing and modifying code
+      icon: "🛠️"
+    
+    - id: testing
+      title: "Testing & QA Agents"
+      description: |
+        > Agents dedicated to testing, quality assurance, and validation
+      icon: "🧪"
+    
+    - id: security
+      title: "Security Agents"
+      description: |
+        > Agents specialized in security analysis and vulnerability detection
+      icon: "🔒"
+
+agents:
+  - name: "{{AGENT_ID}}"
+    category: "{{CATEGORY}}"
+    role: "{{ROLE}}"
+    description: "{{AGENT_DESCRIPTION}}"
+    
+    capabilities:
+      - "{{CAPABILITY_1}}"
+      - "{{CAPABILITY_2}}"
+      - "{{CAPABILITY_3}}"
+    
+    constraints:
+      - "{{CONSTRAINT_1}}"
+      - "{{CONSTRAINT_2}}"
+    
+    tools:
+      - name: "{{TOOL_NAME}}"
+        description: "{{TOOL_DESCRIPTION}}"
+        required: true
+    
+    prompt_template: |
+      You are a {{ROLE}} agent specializing in {{SPECIALIZATION}}.
+      
+      ## Your Capabilities:
+      {{CAPABILITIES_LIST}}
+      
+      ## Your Constraints:
+      {{CONSTRAINTS_LIST}}
+      
+      ## Context:
+      {context}
+      
+      ## Task:
+      {task}
+      
+      ## Additional Instructions:
+      {{ADDITIONAL_INSTRUCTIONS}}
+    
+    examples:
+      - scenario: "{{EXAMPLE_SCENARIO}}"
+        input: "{{EXAMPLE_INPUT}}"
+        expected_output: "{{EXAMPLE_OUTPUT}}"
+    
+    best_practices:
+      - "{{BEST_PRACTICE_1}}"
+      - "{{BEST_PRACTICE_2}}"
+      - "{{BEST_PRACTICE_3}}"

claude_mpm/agents/agent_loader.py

@@ -3,11 +3,11 @@
 Unified Agent Loader System
 ==========================
 
-Provides unified loading of agent prompts from framework markdown files.
+Provides unified loading of agent prompts from JSON template files.
 Integrates with SharedPromptCache for performance optimization.
 
 Key Features:
-- Loads agent prompts from framework/agent-roles/*.md files
+- Loads agent prompts from src/claude_mpm/agents/templates/*.json files
 - Handles base_agent.md prepending
 - Provides backward-compatible get_*_agent_prompt() functions
 - Uses SharedPromptCache for performance
@@ -20,7 +20,7 @@ For advanced agent management features (CRUD, versioning, section updates), use:
 Usage:
     from claude_pm.agents.agent_loader import get_documentation_agent_prompt
     
-    # Get agent prompt from MD file
+    # Get agent prompt from JSON template
     prompt = get_documentation_agent_prompt()
 """
 
@@ -49,64 +49,29 @@ class ModelType:
 logger = logging.getLogger(__name__)
 
 
-def _get_framework_agent_roles_dir() -> Path:
-    """Get the framework agent-roles directory dynamically."""
-    # Use PathResolver for consistent path discovery
-    try:
-        framework_root = PathResolver.get_framework_root()
-        
-        # Check if we're running from a wheel installation
-        try:
-            import claude_pm
-            package_path = Path(claude_pm.__file__).parent
-            path_str = str(package_path.resolve())
-            if 'site-packages' in path_str or 'dist-packages' in path_str:
-                # For wheel installations, check data directory
-                data_agent_roles = package_path / "data" / "framework" / "agent-roles"
-                if data_agent_roles.exists():
-                    logger.debug(f"Using wheel installation agent-roles: {data_agent_roles}")
-                    return data_agent_roles
-        except Exception:
-            pass
-        
-        # Check framework structure
-        agent_roles_dir = framework_root / "framework" / "agent-roles"
-        if agent_roles_dir.exists():
-            logger.debug(f"Using framework agent-roles: {agent_roles_dir}")
-            return agent_roles_dir
-        
-        # Try agents directory as fallback
-        agents_dir = PathResolver.get_agents_dir()
-        logger.debug(f"Using agents directory: {agents_dir}")
-        return agents_dir
-        
-    except FileNotFoundError as e:
-        # Ultimate fallback
-        logger.warning(f"PathResolver could not find framework root: {e}")
-        fallback = Path(__file__).parent.parent.parent / "framework" / "agent-roles"
-        logger.warning(f"Using fallback agent-roles path: {fallback}")
-        return fallback
+def _get_agent_templates_dir() -> Path:
+    """Get the agent templates directory."""
+    # Agent templates are now in the agents/templates directory
+    return Path(__file__).parent / "templates"
 
 
-# Framework agent-roles directory (dynamically determined)
-FRAMEWORK_AGENT_ROLES_DIR = _get_framework_agent_roles_dir()
+# Agent templates directory
+AGENT_TEMPLATES_DIR = _get_agent_templates_dir()
 
 # Cache prefix for agent prompts
 AGENT_CACHE_PREFIX = "agent_prompt:"
 
-# Agent name mappings (agent name -> MD file name)
+# Agent name mappings (agent name -> JSON file name)
 AGENT_MAPPINGS = {
-    "documentation": "documentation-agent.md",
-    "version_control": "version-control-agent.md",
-    "qa": "qa-agent.md",
-    "research": "research-agent.md",
-    "ops": "ops-agent.md",
-    "security": "security-agent.md",
-    "engineer": "engineer-agent.md",
-    "data_engineer": "data-agent.md",  # Note: data-agent.md maps to data_engineer
-    "pm": "pm-orchestrator-agent.md",
-    "orchestrator": "pm-orchestrator-agent.md",
-    "pm_orchestrator": "pm-orchestrator-agent.md"
+    "documentation": "documentation_agent.json",
+    "version_control": "version_control_agent.json",
+    "qa": "qa_agent.json",
+    "research": "research_agent.json",
+    "ops": "ops_agent.json",
+    "security": "security_agent.json",
+    "engineer": "engineer_agent.json",
+    "data_engineer": "data_engineer_agent.json"
+    # Note: pm, orchestrator, and pm_orchestrator agents are handled separately
 }
 
 # Model configuration thresholds
@@ -142,19 +107,19 @@ MODEL_NAME_MAPPINGS = {
 
 def load_agent_prompt_from_md(agent_name: str, force_reload: bool = False) -> Optional[str]:
     """
-    Load agent prompt from framework markdown file.
+    Load agent prompt from JSON template file.
     
     Args:
         agent_name: Agent name (e.g., 'documentation', 'ticketing')
         force_reload: Force reload from file, bypassing cache
         
     Returns:
-        str: Agent prompt content from MD file, or None if not found
+        str: Agent prompt content from JSON template, or None if not found
     """
     try:
         # Get cache instance
         cache = SharedPromptCache.get_instance()
-        cache_key = f"{AGENT_CACHE_PREFIX}{agent_name}:md"
+        cache_key = f"{AGENT_CACHE_PREFIX}{agent_name}:json"
         
         # Check cache first (unless force reload)
         if not force_reload:
@@ -163,23 +128,40 @@ def load_agent_prompt_from_md(agent_name: str, force_reload: bool = False) -> Op
                 logger.debug(f"Agent prompt for '{agent_name}' loaded from cache")
                 return str(cached_content)
         
-        # Get MD file path
-        md_filename = AGENT_MAPPINGS.get(agent_name)
-        if not md_filename:
-            logger.warning(f"No MD file mapping found for agent: {agent_name}")
+        # Get JSON file path
+        json_filename = AGENT_MAPPINGS.get(agent_name)
+        if not json_filename:
+            logger.warning(f"No JSON file mapping found for agent: {agent_name}")
             return None
         
-        # Always get fresh framework directory path to ensure we're using the right location
-        framework_agent_roles_dir = _get_framework_agent_roles_dir()
-        md_path = framework_agent_roles_dir / md_filename
+        json_path = AGENT_TEMPLATES_DIR / json_filename
         
         # Check if file exists
-        if not md_path.exists():
-            logger.warning(f"Agent MD file not found: {md_path}")
+        if not json_path.exists():
+            logger.warning(f"Agent JSON file not found: {json_path}")
             return None
             
-        logger.debug(f"Loading agent prompt from: {md_path}")
-        content = md_path.read_text(encoding='utf-8')
+        logger.debug(f"Loading agent prompt from: {json_path}")
+        
+        # Load and parse JSON
+        import json
+        with open(json_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        # Extract prompt content from JSON
+        # Check multiple possible locations for instructions/content
+        # Following the same pattern as AgentDeploymentService
+        content = (
+            data.get('instructions') or
+            data.get('narrative_fields', {}).get('instructions') or
+            data.get('content') or
+            ''
+        )
+        
+        if not content:
+            logger.warning(f"No content/instructions found in JSON template: {json_path}")
+            logger.debug(f"Checked fields: instructions, narrative_fields.instructions, content")
+            return None
         
         # Cache the content with 1 hour TTL
         cache.set(cache_key, content, ttl=3600)
@@ -188,7 +170,7 @@ def load_agent_prompt_from_md(agent_name: str, force_reload: bool = False) -> Op
         return content
         
     except Exception as e:
-        logger.error(f"Error loading agent prompt from MD for '{agent_name}': {e}")
+        logger.error(f"Error loading agent prompt from JSON for '{agent_name}': {e}")
         return None
 
 
@@ -289,7 +271,7 @@ def _get_model_config(agent_name: str, complexity_analysis: Optional[Dict[str, A
 
 def get_agent_prompt(agent_name: str, force_reload: bool = False, return_model_info: bool = False, **kwargs: Any) -> Union[str, Tuple[str, str, Dict[str, Any]]]:
     """
-    Get agent prompt from MD file with optional dynamic model selection.
+    Get agent prompt from JSON template with optional dynamic model selection.
     
     Args:
         agent_name: Agent name (e.g., 'documentation', 'ticketing')
@@ -305,11 +287,11 @@ def get_agent_prompt(agent_name: str, force_reload: bool = False, return_model_i
         str or tuple: Complete agent prompt with base instructions prepended,
                       or tuple of (prompt, selected_model, model_config) if return_model_info=True
     """
-    # Load from MD file
+    # Load from JSON template
     prompt = load_agent_prompt_from_md(agent_name, force_reload)
     
     if prompt is None:
-        raise ValueError(f"No agent prompt MD file found for: {agent_name}")
+        raise ValueError(f"No agent prompt JSON template found for: {agent_name}")
     
     # Analyze task complexity if task description is provided
     complexity_analysis = None
@@ -452,20 +434,17 @@ def list_available_agents() -> Dict[str, Dict[str, Any]]:
     List all available agents with their sources.
     
     Returns:
-        dict: Agent information including MD file path
+        dict: Agent information including JSON template path
     """
     agents = {}
     
-    # Get fresh framework directory path
-    framework_agent_roles_dir = _get_framework_agent_roles_dir()
-    
-    for agent_name, md_filename in AGENT_MAPPINGS.items():
-        md_path = framework_agent_roles_dir / md_filename
+    for agent_name, json_filename in AGENT_MAPPINGS.items():
+        json_path = AGENT_TEMPLATES_DIR / json_filename
         
         agents[agent_name] = {
-            "md_file": md_filename if md_path.exists() else None,
-            "md_path": str(md_path) if md_path.exists() else None,
-            "has_md": md_path.exists(),
+            "json_file": json_filename if json_path.exists() else None,
+            "json_path": str(json_path) if json_path.exists() else None,
+            "has_template": json_path.exists(),
             "default_model": DEFAULT_AGENT_MODELS.get(agent_name, 'claude-sonnet-4-20250514')
         }
     
@@ -483,13 +462,13 @@ def clear_agent_cache(agent_name: Optional[str] = None) -> None:
         cache = SharedPromptCache.get_instance()
         
         if agent_name:
-            cache_key = f"{AGENT_CACHE_PREFIX}{agent_name}:md"
+            cache_key = f"{AGENT_CACHE_PREFIX}{agent_name}:json"
             cache.invalidate(cache_key)
             logger.debug(f"Cache cleared for agent: {agent_name}")
         else:
             # Clear all agent caches
             for name in AGENT_MAPPINGS:
-                cache_key = f"{AGENT_CACHE_PREFIX}{name}:md"
+                cache_key = f"{AGENT_CACHE_PREFIX}{name}:json"
                 cache.invalidate(cache_key)
             logger.debug("All agent caches cleared")
             
@@ -506,14 +485,11 @@ def validate_agent_files() -> Dict[str, Dict[str, Any]]:
     """
     results = {}
     
-    # Get fresh framework directory path
-    framework_agent_roles_dir = _get_framework_agent_roles_dir()
-    
-    for agent_name, md_filename in AGENT_MAPPINGS.items():
-        md_path = framework_agent_roles_dir / md_filename
+    for agent_name, json_filename in AGENT_MAPPINGS.items():
+        json_path = AGENT_TEMPLATES_DIR / json_filename
         results[agent_name] = {
-            "md_exists": md_path.exists(),
-            "md_path": str(md_path)
+            "template_exists": json_path.exists(),
+            "template_path": str(json_path)
         }
     
     return results

claude_mpm/agents/base_agent_loader.py

@@ -36,7 +36,7 @@ logger = logging.getLogger(__name__)
 BASE_AGENT_CACHE_KEY = "base_agent:instructions"
 
 def _get_base_agent_file() -> Path:
-    """Get the base agent file path dynamically."""
+    """Get the base agent file path."""
     # Check if we're running from a wheel installation
     try:
         import claude_pm
@@ -44,27 +44,22 @@ def _get_base_agent_file() -> Path:
         path_str = str(package_path.resolve())
         if 'site-packages' in path_str or 'dist-packages' in path_str:
             # For wheel installations, check data directory
-            data_base_agent = package_path / "data" / "framework" / "agent-roles" / "base_agent.md"
+            data_base_agent = package_path / "data" / "agents" / "BASE_AGENT_TEMPLATE.md"
             if data_base_agent.exists():
                 logger.debug(f"Using wheel installation base_agent: {data_base_agent}")
                 return data_base_agent
     except Exception:
         pass
     
-    # For development, find framework directory
-    current = Path.cwd()
+    # Use the BASE_AGENT_TEMPLATE.md in the agents directory
+    base_agent_path = Path(__file__).parent / "BASE_AGENT_TEMPLATE.md"
+    if base_agent_path.exists():
+        logger.debug(f"Using base agent template: {base_agent_path}")
+        return base_agent_path
     
-    # Check current directory and parents
-    for path in [current] + list(current.parents):
-        framework_base_agent = path / "framework" / "agent-roles" / "base_agent.md"
-        if framework_base_agent.exists():
-            logger.debug(f"Using development base_agent: {framework_base_agent}")
-            return framework_base_agent
-    
-    # Fallback to old behavior (though this shouldn't happen)
-    fallback = Path(__file__).parent.parent.parent / "framework" / "agent-roles" / "base_agent.md"
-    logger.warning(f"Using fallback base_agent path: {fallback}")
-    return fallback
+    # Fallback error
+    logger.error("Base agent template file not found")
+    raise FileNotFoundError("BASE_AGENT_TEMPLATE.md not found in agents directory")
 
 
 # Base agent file path (dynamically determined)

claude_mpm/cli.py

@@ -1,6 +1,7 @@
 """Command-line interface for Claude MPM."""
 
 import argparse
+import subprocess
 import sys
 from pathlib import Path
 from typing import Optional
@@ -9,13 +10,11 @@ try:
     # Try relative imports first (when used as package)
     from ._version import __version__
     from .core.logger import get_logger, setup_logging
-    from .services.json_rpc_hook_manager import JSONRPCHookManager
     from .constants import CLICommands, CLIPrefix, AgentCommands, LogLevel, CLIFlags
 except ImportError:
     # Fall back to absolute imports (when run directly)
     from claude_mpm._version import __version__
     from core.logger import get_logger, setup_logging
-    from services.json_rpc_hook_manager import JSONRPCHookManager
     from constants import CLICommands, CLIPrefix, AgentCommands, LogLevel, CLIFlags
 
 
@@ -99,6 +98,12 @@ def main(argv: Optional[list] = None):
         help="Disable hook service (runs without hooks)"
     )
     
+    parser.add_argument(
+        "--intercept-commands",
+        action="store_true",
+        help="Enable command interception in interactive mode (intercepts /mpm: commands)"
+    )
+    
     # Add run-specific arguments at top level (for default behavior)
     parser.add_argument(
         "--no-tickets",
@@ -139,6 +144,11 @@ def main(argv: Optional[list] = None):
         action="store_true",
         help="Disable automatic ticket creation"
     )
+    run_parser.add_argument(
+        "--intercept-commands",
+        action="store_true",
+        help="Enable command interception in interactive mode (intercepts /mpm: commands)"
+    )
     run_parser.add_argument(
         "-i", "--input",
         type=str,
@@ -244,31 +254,10 @@ def main(argv: Optional[list] = None):
         logger = logging.getLogger("cli")
         logger.setLevel(logging.WARNING)
     
-    # Initialize hook service manager (unless disabled)
-    hook_manager = None
-    if not getattr(args, 'no_hooks', False):
-        try:
-            # Check if hooks are enabled via config
-            try:
-                from .config.hook_config import HookConfig
-            except ImportError:
-                from config.hook_config import HookConfig
-            if HookConfig.is_hooks_enabled():
-                hook_manager = JSONRPCHookManager(log_dir=args.log_dir)
-                if hook_manager.start_service():
-                    logger.info("JSON-RPC hook system initialized")
-                    if args.logging != LogLevel.OFF.value:
-                        print("✓ JSON-RPC hook system initialized")
-                else:
-                    logger.warning("Failed to initialize JSON-RPC hooks, continuing without hooks")
-                    if args.logging != LogLevel.OFF.value:
-                        print("⚠️  Failed to initialize JSON-RPC hooks, continuing without hooks")
-                    hook_manager = None
-            else:
-                logger.info("Hooks disabled via configuration")
-        except Exception as e:
-            logger.warning(f"Hook service initialization failed: {e}, continuing without hooks")
-            hook_manager = None
+    # Hook system note: Claude Code hooks are handled externally via the
+    # hook_handler.py script installed in ~/.claude/settings.json
+    # The --no-hooks flag is kept for backward compatibility but doesn't affect
+    # Claude Code hooks which are configured separately.
     
     # Default to run command
     if not args.command:
@@ -289,11 +278,11 @@ def main(argv: Optional[list] = None):
     
     try:
         if command in [CLICommands.RUN.value, None]:
-            run_session(args, hook_manager)
+            run_session(args)
         elif command == CLICommands.TICKETS.value:
             list_tickets(args)
         elif command == CLICommands.INFO.value:
-            show_info(args, hook_manager)
+            show_info(args)
         elif command == CLICommands.AGENTS.value:
             manage_agents(args)
         elif command == CLICommands.UI.value:
@@ -311,9 +300,8 @@ def main(argv: Optional[list] = None):
             traceback.print_exc()
         return 1
     finally:
-        # Clean up hook service
-        if hook_manager:
-            hook_manager.stop_service()
+        # Cleanup handled by individual components
+        pass
     
     return 0
 
@@ -337,7 +325,7 @@ def _get_user_input(args, logger):
 
 
 
-def run_session(args, hook_manager=None):
+def run_session(args):
     """Run a simplified Claude session."""
     logger = get_logger("cli")
     if args.logging != LogLevel.OFF.value:
@@ -368,7 +356,17 @@ def run_session(args, hook_manager=None):
             logger.error("Session failed")
     else:
         # Run interactive session
-        runner.run_interactive(context)
+        if getattr(args, 'intercept_commands', False):
+            # Use the interactive wrapper for command interception
+            wrapper_path = Path(__file__).parent.parent.parent / "scripts" / "interactive_wrapper.py"
+            if wrapper_path.exists():
+                print("Starting interactive session with command interception...")
+                subprocess.run([sys.executable, str(wrapper_path)])
+            else:
+                logger.warning("Interactive wrapper not found, falling back to normal mode")
+                runner.run_interactive(context)
+        else:
+            runner.run_interactive(context)
 
 
 def list_tickets(args):
@@ -579,7 +577,7 @@ def run_terminal_ui(args):
     return 0
 
 
-def show_info(args, hook_manager=None):
+def show_info(args):
     """Show framework and configuration information."""
     try:
         from .core.framework_loader import FrameworkLoader
@@ -636,19 +634,15 @@ def show_info(args, hook_manager=None):
     except ImportError:
         print("  ✗ ai-trackdown-pytools: Not installed")
     
-    # Check hook service
-    if hook_manager:
-        info = hook_manager.get_service_info()
-        if info['running']:
-            print(f"  ✓ Hook System: JSON-RPC ({info.get('hook_count', 0)} hooks)")
-            if 'discovered_hooks' in info and info['discovered_hooks']:
-                print(f"     Hooks: {', '.join(info['discovered_hooks'][:5])}")
-                if len(info['discovered_hooks']) > 5:
-                    print(f"     ... and {len(info['discovered_hooks']) - 5} more")
-        else:
-            print("  ✗ Hook System: Not running")
+    # Check Claude Code hooks
+    from pathlib import Path
+    claude_settings = Path.home() / ".claude" / "settings.json"
+    if claude_settings.exists():
+        print("  ✓ Claude Code Hooks: Installed")
+        print("     Use /mpm commands in Claude Code")
     else:
-        print("  ✗ Hook System: Disabled (--no-hooks)")
+        print("  ✗ Claude Code Hooks: Not installed")
+        print("     Run: python scripts/install_hooks.py")
 
 
 if __name__ == "__main__":