claude-mpm 3.4.26__py3-none-any.whl → 3.5.0__py3-none-any.whl

claude_mpm/services/response_tracker.py

@@ -0,0 +1,237 @@
+"""
+Response Tracker Service
+
+Wraps the ClaudeSessionLogger to provide compatibility with the hook_handler.py
+response tracking integration. This service acts as a bridge between the hook
+system and the session logging system.
+
+WHY: The hook_handler expects a ResponseTracker class with specific methods,
+but we already have ClaudeSessionLogger that does the actual work. This wrapper
+ensures compatibility while respecting configuration settings.
+
+DESIGN DECISIONS:
+- Wraps ClaudeSessionLogger instead of duplicating code
+- Properly checks configuration to respect enabled/disabled state
+- Provides the expected interface for hook_handler.py
+- Handles agent name normalization for consistent tracking
+"""
+
+import logging
+from pathlib import Path
+from typing import Dict, Any, Optional
+from datetime import datetime
+
+from claude_mpm.services.claude_session_logger import ClaudeSessionLogger
+from claude_mpm.core.config import Config
+
+logger = logging.getLogger(__name__)
+
+
+class ResponseTracker:
+    """Response tracker that wraps ClaudeSessionLogger for hook compatibility.
+    
+    WHY: This class provides the interface expected by hook_handler.py while
+    delegating actual logging to the proven ClaudeSessionLogger implementation.
+    This avoids code duplication and maintains consistency.
+    
+    DESIGN: The tracker checks configuration settings on initialization and
+    respects the enabled/disabled state. It provides the track_response method
+    expected by the hook handler.
+    """
+    
+    def __init__(self, config: Optional[Config] = None):
+        """Initialize the response tracker.
+        
+        Args:
+            config: Optional configuration instance
+        """
+        # Load configuration if not provided
+        if config is None:
+            config = Config()
+        self.config = config
+        
+        # Check if response tracking is enabled
+        response_tracking_config = self.config.get('response_tracking', {})
+        response_logging_config = self.config.get('response_logging', {})
+        
+        # Check both configurations - explicit False takes precedence
+        if 'enabled' in response_tracking_config:
+            self.enabled = response_tracking_config.get('enabled', False)
+        elif 'enabled' in response_logging_config:
+            self.enabled = response_logging_config.get('enabled', False)
+        else:
+            self.enabled = False  # Default to disabled if not configured
+        
+        # Initialize the session logger only if enabled
+        self.session_logger = None
+        if self.enabled:
+            try:
+                # Get base directory from configuration
+                base_dir = response_tracking_config.get('base_dir')
+                if not base_dir:
+                    base_dir = response_logging_config.get('session_directory', '.claude-mpm/responses')
+                
+                # Create session logger with proper configuration
+                self.session_logger = ClaudeSessionLogger(
+                    base_dir=Path(base_dir),
+                    config=config
+                )
+                logger.info(f"Response tracker initialized with base directory: {base_dir}")
+            except Exception as e:
+                logger.error(f"Failed to initialize session logger: {e}")
+                self.enabled = False
+        else:
+            logger.info("Response tracking is disabled in configuration")
+    
+    def track_response(
+        self,
+        agent_name: str,
+        request: str,
+        response: str,
+        session_id: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> Optional[Path]:
+        """Track an agent response.
+        
+        WHY: This method provides the interface expected by hook_handler.py
+        while delegating to ClaudeSessionLogger for actual storage.
+        
+        Args:
+            agent_name: Name of the agent that generated the response
+            request: The original request/prompt
+            response: The agent's response
+            session_id: Optional session ID (will use logger's if not provided)
+            metadata: Optional additional metadata
+            
+        Returns:
+            Path to the saved response file, or None if disabled/failed
+        """
+        # Check if tracking is enabled
+        if not self.enabled or not self.session_logger:
+            logger.debug(f"Response tracking disabled, skipping response from {agent_name}")
+            return None
+        
+        # Check excluded agents
+        response_tracking_config = self.config.get('response_tracking', {})
+        excluded_agents = response_tracking_config.get('excluded_agents', [])
+        
+        # Normalize agent name for comparison
+        normalized_agent = agent_name.lower().replace('-', '_').replace(' ', '_')
+        
+        # Check if agent is excluded
+        for excluded in excluded_agents:
+            excluded_normalized = excluded.lower().replace('-', '_').replace(' ', '_')
+            if normalized_agent == excluded_normalized:
+                logger.debug(f"Agent {agent_name} is in excluded list, skipping response tracking")
+                return None
+        
+        # Set session ID if provided
+        if session_id and session_id != self.session_logger.session_id:
+            self.session_logger.set_session_id(session_id)
+        
+        # Prepare enhanced metadata
+        enhanced_metadata = metadata or {}
+        enhanced_metadata.update({
+            'agent': agent_name,
+            'tracked_by': 'ResponseTracker',
+            'tracking_timestamp': datetime.now().isoformat()
+        })
+        
+        # Check if metadata tracking is enabled and add additional fields
+        metadata_tracking = response_tracking_config.get('metadata_tracking', {})
+        if metadata_tracking.get('track_model', True):
+            enhanced_metadata['model'] = enhanced_metadata.get('model', 'claude-3')
+        if metadata_tracking.get('track_duration', True) and 'duration_ms' in enhanced_metadata:
+            enhanced_metadata['duration_ms'] = enhanced_metadata.get('duration_ms')
+        if metadata_tracking.get('track_tools', True) and 'tool_name' in enhanced_metadata:
+            enhanced_metadata['tools_used'] = [enhanced_metadata.get('tool_name')]
+        
+        # Log the response using the session logger
+        try:
+            file_path = self.session_logger.log_response(
+                request_summary=request,
+                response_content=response,
+                metadata=enhanced_metadata,
+                agent=agent_name
+            )
+            
+            if file_path:
+                logger.debug(f"Successfully tracked response from {agent_name} to {file_path}")
+            else:
+                logger.warning(f"Failed to track response from {agent_name}")
+            
+            return file_path
+            
+        except Exception as e:
+            logger.error(f"Error tracking response from {agent_name}: {e}")
+            return None
+    
+    def is_enabled(self) -> bool:
+        """Check if response tracking is enabled.
+        
+        Returns:
+            True if tracking is enabled, False otherwise
+        """
+        return self.enabled and self.session_logger is not None
+    
+    def get_session_path(self) -> Optional[Path]:
+        """Get the current session directory path.
+        
+        Returns:
+            Path to the session directory, or None if not available
+        """
+        if self.session_logger:
+            return self.session_logger.get_session_path()
+        return None
+    
+    def set_session_id(self, session_id: str) -> None:
+        """Set a specific session ID for tracking.
+        
+        Args:
+            session_id: The session ID to use
+        """
+        if self.session_logger:
+            self.session_logger.set_session_id(session_id)
+            logger.info(f"Response tracker session ID set to: {session_id}")
+
+
+# Singleton instance for consistency
+_tracker_instance = None
+
+
+def get_response_tracker(config: Optional[Config] = None) -> ResponseTracker:
+    """Get the singleton response tracker instance.
+    
+    Args:
+        config: Optional configuration instance
+        
+    Returns:
+        The shared ResponseTracker instance
+    """
+    global _tracker_instance
+    if _tracker_instance is None:
+        _tracker_instance = ResponseTracker(config=config)
+    return _tracker_instance
+
+
+def track_response(
+    agent_name: str,
+    request: str,
+    response: str,
+    session_id: Optional[str] = None,
+    metadata: Optional[Dict[str, Any]] = None
+) -> Optional[Path]:
+    """Convenience function to track a response.
+    
+    Args:
+        agent_name: Name of the agent
+        request: The original request
+        response: The agent's response
+        session_id: Optional session ID
+        metadata: Optional metadata
+        
+    Returns:
+        Path to the saved response file
+    """
+    tracker = get_response_tracker()
+    return tracker.track_response(agent_name, request, response, session_id, metadata)

claude_mpm/services/ticketing_service_original.py

@@ -44,6 +44,8 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
+from claude_mpm.core.config_paths import ConfigPaths
+
 # Import ai-trackdown-pytools
 try:
     from ai_trackdown_pytools import Task, Project
@@ -147,8 +149,8 @@ class TicketingService:
         if tickets_path.exists():
             return tickets_path
         
-        # Check for .claude-pm directory
-        claude_pm_dir = current_dir / ".claude-pm"
+        # Check for .claude-mpm directory
+        claude_pm_dir = current_dir / ConfigPaths.CONFIG_DIR
         if claude_pm_dir.exists():
             tickets_path = claude_pm_dir / "tickets"
             tickets_path.mkdir(exist_ok=True)

claude_mpm/services/version_control/branch_strategy.py

@@ -17,6 +17,8 @@ from dataclasses import dataclass, field
 import logging
 import re
 
+from claude_mpm.core.config_paths import ConfigPaths
+
 
 class BranchStrategyType(Enum):
     """Types of branch strategies."""
@@ -303,7 +305,7 @@ class BranchStrategyManager:
         """Load strategy configuration from project files."""
         # Try to load from configuration files
         config_files = [
-            ".claude-pm/config.json",
+            f"{ConfigPaths.CONFIG_DIR}/config.json",
             "workflow.md",
             ".github/workflows/branch-strategy.yml",
             "branch-strategy.json",

claude_mpm/utils/paths.py

@@ -10,6 +10,8 @@ from typing import Optional, Union, List
 from functools import lru_cache
 import logging
 
+from claude_mpm.core.config_paths import ConfigPaths
+
 logger = logging.getLogger(__name__)
 
 
@@ -109,7 +111,7 @@ class PathResolver:
         """
         # Project root markers in order of preference
         markers = ['.git', 'pyproject.toml', 'package.json', 'Cargo.toml', 
-                   'go.mod', 'pom.xml', 'build.gradle', '.claude-pm']
+                   'go.mod', 'pom.xml', 'build.gradle', ConfigPaths.CONFIG_DIR]
         
         current = Path.cwd()
         while current != current.parent:
@@ -139,22 +141,22 @@ class PathResolver:
             FileNotFoundError: If directory cannot be determined
         """
         if scope == 'project':
-            return cls.get_project_root() / '.claude-pm'
+            return cls.get_project_root() / ConfigPaths.CONFIG_DIR
         elif scope == 'user':
             # Support XDG_CONFIG_HOME if set
             xdg_config = os.environ.get('XDG_CONFIG_HOME')
             if xdg_config:
-                return Path(xdg_config) / 'claude-pm'
-            return Path.home() / '.config' / 'claude-pm'
+                return Path(xdg_config) / 'claude-mpm'
+            return Path.home() / '.config' / 'claude-mpm'
         elif scope == 'system':
             # System-wide configuration
             if os.name == 'posix':
-                return Path('/etc/claude-pm')
+                return Path('/etc/claude-mpm')
             else:
                 # Windows: Use ProgramData
-                return Path(os.environ.get('ProgramData', 'C:\\ProgramData')) / 'claude-pm'
+                return Path(os.environ.get('ProgramData', 'C:\\ProgramData')) / 'claude-mpm'
         elif scope == 'framework':
-            return cls.get_framework_root() / '.claude-pm'
+            return cls.get_framework_root() / ConfigPaths.CONFIG_DIR
         else:
             raise ValueError(f"Invalid scope: {scope}. Must be one of: project, user, system, framework")
     
@@ -186,15 +188,15 @@ class PathResolver:
     @classmethod
     @lru_cache(maxsize=8)
     def get_claude_pm_dir(cls, base_path: Optional[Path] = None) -> Optional[Path]:
-        """Find .claude-pm directory starting from base_path.
+        """Find .claude-mpm directory starting from base_path.
         
         Args:
             base_path: Starting directory (defaults to current directory)
             
         Returns:
-            Path: The .claude-pm directory, or None if not found
+            Path: The .claude-mpm directory, or None if not found
         """
-        result = cls.find_file_upwards('.claude-pm', base_path)
+        result = cls.find_file_upwards(ConfigPaths.CONFIG_DIR, base_path)
         return result if result and result.is_dir() else None
     
     @classmethod

claude_mpm/utils/session_logging.py

@@ -0,0 +1,114 @@
+"""
+Session Logging Utilities
+
+Convenience functions for session-based response logging.
+"""
+
+import os
+from typing import Optional, Dict, Any
+from pathlib import Path
+import logging
+
+from claude_mpm.services.claude_session_logger import get_session_logger
+
+logger = logging.getLogger(__name__)
+
+
+def is_session_logging_enabled() -> bool:
+    """
+    Check if session logging is enabled.
+    
+    Returns:
+        True if session logging is enabled and configured
+    """
+    # Check environment variable to disable
+    if os.environ.get('CLAUDE_MPM_NO_SESSION_LOGGING', '').lower() in ('1', 'true', 'yes'):
+        return False
+    
+    # Check if session logger has a valid session ID
+    session_logger = get_session_logger()
+    return session_logger.is_enabled()
+
+
+def log_agent_response(
+    agent_name: str,
+    request: str,
+    response: str,
+    metadata: Optional[Dict[str, Any]] = None
+) -> Optional[Path]:
+    """
+    Log an agent response to the current session.
+    
+    Args:
+        agent_name: Name of the agent
+        request: The request/prompt sent to the agent
+        response: The agent's response
+        metadata: Optional additional metadata
+        
+    Returns:
+        Path to the logged file, or None if logging is disabled
+    """
+    if not is_session_logging_enabled():
+        return None
+    
+    # Create request summary
+    request_summary = f"[{agent_name}] {request[:100]}..." if len(request) > 100 else f"[{agent_name}] {request}"
+    
+    # Add agent name to metadata
+    if metadata is None:
+        metadata = {}
+    metadata['agent'] = agent_name
+    
+    # Log the response
+    session_logger = get_session_logger()
+    return session_logger.log_response(
+        request_summary=request_summary,
+        response_content=response,
+        metadata=metadata
+    )
+
+
+def get_current_session_id() -> Optional[str]:
+    """
+    Get the current session ID.
+    
+    Returns:
+        Current session ID, or None if not available
+    """
+    session_logger = get_session_logger()
+    return session_logger.session_id
+
+
+def get_session_directory() -> Optional[Path]:
+    """
+    Get the directory for the current session.
+    
+    Returns:
+        Path to session directory, or None if not available
+    """
+    session_logger = get_session_logger()
+    return session_logger.get_session_path()
+
+
+def set_session_id(session_id: str) -> None:
+    """
+    Manually set the session ID.
+    
+    Args:
+        session_id: The session ID to use
+    """
+    session_logger = get_session_logger()
+    session_logger.set_session_id(session_id)
+    logger.info(f"Session ID set to: {session_id}")
+
+
+# Environment variable helpers
+def enable_session_logging() -> None:
+    """Enable session logging by removing disable flag."""
+    if 'CLAUDE_MPM_NO_SESSION_LOGGING' in os.environ:
+        del os.environ['CLAUDE_MPM_NO_SESSION_LOGGING']
+
+
+def disable_session_logging() -> None:
+    """Disable session logging via environment variable."""
+    os.environ['CLAUDE_MPM_NO_SESSION_LOGGING'] = '1'

claude_mpm/validation/agent_validator.py

@@ -27,6 +27,7 @@ from dataclasses import dataclass, field
 from datetime import datetime
 import jsonschema
 from jsonschema import validate, ValidationError, Draft7Validator
+from claude_mpm.config.paths import paths
 
 logger = logging.getLogger(__name__)
 
@@ -55,7 +56,7 @@ class AgentValidator:
     def __init__(self, schema_path: Optional[Path] = None):
         """Initialize the validator with the agent schema."""
         if schema_path is None:
-            schema_path = Path(__file__).parent.parent / "schemas" / "agent_schema.json"
+            schema_path = paths.schemas_dir / "agent_schema.json"
         
         self.schema_path = schema_path
         self.schema = self._load_schema()

{claude_mpm-3.4.26.dist-info → claude_mpm-3.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 3.4.26
+Version: 3.5.0
 Summary: Claude Multi-agent Project Manager - Clean orchestration with ticket management
 Home-page: https://github.com/bobmatnyc/claude-mpm
 Author: Claude MPM Team
@@ -22,7 +22,6 @@ License-File: LICENSE
 Requires-Dist: ai-trackdown-pytools>=1.4.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: python-dotenv>=0.19.0
-Requires-Dist: rich>=13.0.0
 Requires-Dist: click>=8.0.0
 Requires-Dist: pexpect>=4.8.0
 Requires-Dist: psutil>=5.9.0
@@ -36,7 +35,6 @@ Requires-Dist: python-socketio>=5.11.0
 Requires-Dist: aiohttp>=3.9.0
 Requires-Dist: aiohttp-cors>=0.8.0
 Requires-Dist: python-engineio>=4.8.0
-Requires-Dist: urwid>=2.1.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-asyncio; extra == "dev"
@@ -58,7 +56,7 @@ A powerful orchestration framework for Claude Code that enables multi-agent work
 
 ## Features
 
-- 🤖 **Multi-Agent System**: Automatically delegates tasks to specialized agents (PM, Research, Engineer, QA, Documentation, Security, Ops, Data Engineer)
+- 🤖 **Multi-Agent System**: Automatically delegates tasks to specialized agents (PM, Research, Engineer, QA, Documentation, Security, Ops, Data Engineer, Test Integration, Version Control)
 - 🧠 **Agent Memory System**: Persistent learning with project-specific knowledge retention
 - 🔄 **Session Management**: Resume previous sessions with `--resume` 
 - 📊 **Real-Time Monitoring**: Live dashboard with `--monitor` flag
@@ -72,8 +70,8 @@ A powerful orchestration framework for Claude Code that enables multi-agent work
 # Install from PyPI
 pip install claude-mpm
 
-# Or with monitoring support
-pip install "claude-mpm[monitor]"
+# Install with development dependencies
+pip install "claude-mpm[dev]"
 ```
 
 ## Basic Usage
@@ -104,6 +102,9 @@ The PM agent automatically delegates work to specialized agents:
 - **Documentation**: Docs and guides
 - **Security**: Security analysis
 - **Ops**: Deployment and infrastructure
+- **Data Engineer**: Data pipelines and AI integrations
+- **Test Integration**: E2E testing and cross-system validation
+- **Version Control**: Git workflows and release management
 
 ### Session Management
 - All work is tracked in persistent sessions
@@ -127,6 +128,9 @@ claude-mpm memory status
 
 # Add specific learning
 claude-mpm memory add engineer pattern "Always use async/await for I/O"
+
+# Start with monitoring dashboard
+claude-mpm run --monitor
 ```
 
 See [docs/MEMORY.md](docs/MEMORY.md) for comprehensive memory system documentation.
@@ -138,39 +142,41 @@ The `--monitor` flag opens a web dashboard showing:
 - Tool usage and results
 - Session management UI
 
-See [docs/monitoring.md](docs/monitoring.md) for full monitoring guide.
+See [docs/developer/monitoring.md](docs/developer/monitoring.md) for full monitoring guide.
 
 
 ## Documentation
 
 - **[Quick Start Guide](QUICKSTART.md)** - Get running in 5 minutes
 - **[Agent Memory System](docs/MEMORY.md)** - Comprehensive memory documentation
-- **[Monitoring Dashboard](docs/monitoring.md)** - Real-time monitoring features
+- **[Monitoring Dashboard](docs/developer/monitoring.md)** - Real-time monitoring features
 - **[Project Structure](docs/STRUCTURE.md)** - Codebase organization
 - **[Deployment Guide](docs/DEPLOY.md)** - Publishing and versioning
 - **[User Guide](docs/user/)** - Detailed usage documentation
 - **[Developer Guide](docs/developer/)** - Architecture and API reference
 
-## Recent Updates (v3.4.0)
+## Recent Updates (v3.4.27)
 
-### Agent Memory System
-- **Project-Specific Memory Generation**: Automatic analysis of project characteristics
-- **Memory Initialization Command**: New `/mpm memory init` for quick project onboarding
-- **Enhanced Documentation Processing**: Dynamic file discovery based on project type
-- **Improved Memory Templates**: Clean section headers with programmatic limit enforcement
+### Core System Enhancements
+- **Project Structure Reorganization**: Centralized path management with ClaudeMPMPaths enum
+- **Agent Services Hierarchy**: Reorganized agent and memory services into hierarchical structures  
+- **Response Logging Improvements**: Flat structure logging without session_ prefix
+- **Memory System Expansion**: Added data_engineer and test_integration agents with specialized keywords
+- **Path Management System**: Implemented centralized configuration path handling
 
-### Project Organization
-- **Deep Clean**: Comprehensive project structure cleanup for publishing readiness
-- **Documentation Archives**: Historical reports organized in docs/archive/
-- **Test Organization**: All tests properly relocated to /tests/ directory
-- **Enhanced .gitignore**: Prevents temporary and debug file commits
+### Project Cleanup & Organization
+- **Test File Migration**: Moved 66 test files from scripts/ to tests/ directory
+- **Documentation Archives**: Archived 35+ QA reports to docs/archive/
+- **Obsolete Directory Removal**: Cleaned up orchestration, docker, security, and terminal_wrapper directories
+- **Agent Registry Caching**: Enhanced performance with intelligent caching mechanisms
+- **Improved TodoWrite Integration**: Enhanced agent prefix guidelines across all agent templates
 
 See [CHANGELOG.md](CHANGELOG.md) for full history.
 
 ## Development
 
 ### Contributing
-See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+Contributions are welcome! Please see our [project structure guide](docs/STRUCTURE.md) and follow the established patterns.
 
 ### Project Structure
 See [docs/STRUCTURE.md](docs/STRUCTURE.md) for codebase organization.