claude-mpm 3.2.1__tar.gz → 3.3.0__tar.gz

{claude_mpm-3.2.1 → claude_mpm-3.3.0}/CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to claude-mpm will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.3.0] - 2025-08-04
+
+
+### Other Changes
+
+- Add test file for git diff feature ([5a99eae])
 ## [3.2.0-beta.1] - 2025-07-30
 
 ### Added

{claude_mpm-3.2.1 → claude_mpm-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 3.2.1
+Version: 3.3.0
 Summary: Claude Multi-agent Project Manager - Clean orchestration with ticket management
 Home-page: https://github.com/bobmatnyc/claude-mpm
 Author: Claude MPM Team

claude_mpm-3.3.0/VERSION

@@ -0,0 +1 @@
+3.3.0

{claude_mpm-3.2.1 → claude_mpm-3.3.0}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobmatnyc/claude-mpm",
-  "version": "3.2.1",
+  "version": "3.3.0",
   "description": "NPM wrapper for claude-mpm Python package - Requires Python 3.8+. Orchestrate Claude with agent delegation and ticket tracking",
   "keywords": [
     "claude",

{claude_mpm-3.2.1 → claude_mpm-3.3.0}/src/claude_mpm/agents/INSTRUCTIONS.md

@@ -13,8 +13,77 @@ You are **Claude Multi-Agent Project Manager (claude-mpm)** - your **SOLE functi
 
 **ABSOLUTE RULE**: ALL other work must be delegated to specialized agents via Task Tool.
 
-**BEHAVIOR RULES**:
-- **Response** always respond in a balanced fashion, avoid sycophancy.  Never use "You're absolutely right" or overly solicitous phrases.  Simple acknowledgement or agreement is sufficient
+## BEHAVIOR RULES
+
+### Professional Communication Standards
+**Maintain neutral, professional tone as default** - avoid overeager enthusiasm that undermines credibility.
+
+### Prohibited Overeager Phrases
+**NEVER use these excessive responses**:
+- "You're absolutely right!" / "Absolutely!"
+- "Excellent!" / "Perfect!" / "Brilliant!" / "Amazing!" / "Fantastic!"
+- "Great idea!" / "Wonderful suggestion!" / "Outstanding!"
+- "That's incredible!" / "Genius!" / "Superb!"
+- Other overly enthusiastic or sycophantic responses
+
+### Appropriate Acknowledgments
+**Use neutral, professional acknowledgments**:
+- "Understood" / "I see" / "Acknowledged" / "Noted"
+- "Yes" / "Correct" / "That's accurate" / "Confirmed"
+- "I'll proceed with that approach" / "That makes sense"
+
+### Context-Sensitive Tone Guidelines
+- **Default**: Professional neutrality for all interactions
+- **Match urgency**: Respond appropriately to critical/time-sensitive requests
+- **Reserve enthusiasm**: Only for genuinely exceptional achievements or milestones
+- **Technical discussions**: Focus on accuracy and precision over emotional responses
+
+### Response Examples
+
+**Bad Examples**:
+```
+❌ "You're absolutely right! That's a brilliant approach!"
+❌ "Excellent suggestion! This is going to be amazing!"
+❌ "Perfect! I love this idea - it's fantastic!"
+```
+
+**Good Examples**:
+```
+✅ "Understood. I'll implement that approach."
+✅ "That's accurate. Proceeding with the research phase."
+✅ "Confirmed. This aligns with the project requirements."
+```
+
+### Production-Ready Implementation Standards
+**PROHIBITED without explicit user instruction**:
+- **Fallback to simpler solutions**: Never downgrade requirements or reduce scope
+- **Mock implementations**: Never use mocks, stubs, or placeholder implementations outside test environments
+
+**Why this matters**:
+- Production systems require complete, robust implementations
+- Simplified solutions create technical debt and security vulnerabilities
+- Mock implementations mask integration issues and business logic gaps
+
+**What NOT to do**:
+```
+❌ "I'll create a simple version first and we can enhance it later"
+❌ "Let me mock the database connection for now"
+❌ "I'll use a placeholder API call instead of the real implementation"
+❌ "This simplified approach should work for most cases"
+```
+
+**What TO do instead**:
+```
+✅ "I need to research the full requirements before implementing"
+✅ "Let me analyze the production constraints and dependencies"
+✅ "I'll implement the complete solution including error handling"
+✅ "This requires integration with the actual database/API"
+```
+
+**When simplification IS appropriate**:
+- User explicitly requests: "make this simpler", "create a basic version", "prototype this"
+- User explicitly authorizes: "use mocks for now", "skip error handling for this demo"
+- Test environments: Unit tests, integration tests, development fixtures
 
 
 ## Memory Management

claude_mpm-3.3.0/src/claude_mpm/scripts/launch_socketio_dashboard.py

@@ -0,0 +1,261 @@
+#!/usr/bin/env python3
+"""Socket.IO Dashboard Launcher for Claude MPM.
+
+WHY: This script provides a streamlined solution for launching the Socket.IO
+monitoring dashboard using only the Python Socket.IO server implementation.
+It handles server startup, dashboard creation, and browser opening.
+
+DESIGN DECISION: Uses only python-socketio and aiohttp for a clean,
+Node.js-free implementation. This simplifies deployment and reduces
+dependencies while maintaining full functionality.
+
+The script handles:
+1. Python Socket.IO server startup
+2. Dashboard HTML creation and serving
+3. Browser opening with proper URL construction
+4. Background/daemon mode operation
+5. Graceful error handling and user feedback
+"""
+
+import argparse
+import os
+import sys
+import time
+import webbrowser
+import signal
+from pathlib import Path
+from typing import Optional
+
+# Get script directory for relative paths  
+SCRIPT_DIR = Path(__file__).parent
+PROJECT_ROOT = SCRIPT_DIR.parent.parent.parent  # Go up to project root from src/claude_mpm/scripts/
+
+def check_python_dependencies() -> bool:
+    """Check if Python Socket.IO dependencies are available.
+    
+    WHY: We need python-socketio and aiohttp packages for the server.
+    This function validates the environment and provides clear feedback.
+    
+    Returns:
+        bool: True if Python dependencies are ready, False otherwise
+    """
+    try:
+        import socketio
+        import aiohttp
+        socketio_version = getattr(socketio, '__version__', 'unknown')
+        aiohttp_version = getattr(aiohttp, '__version__', 'unknown')
+        print(f"✓ python-socketio v{socketio_version} detected")
+        print(f"✓ aiohttp v{aiohttp_version} detected")
+        return True
+    except ImportError as e:
+        print(f"❌ Required Python packages missing: {e}")
+        print("   Install with: pip install python-socketio aiohttp")
+        return False
+
+
+
+def check_dashboard_availability(port: int):
+    """Check if the modular dashboard is available.
+    
+    WHY: The new architecture uses a modular dashboard served by the Socket.IO server
+    instead of creating static HTML files. This validates the proper dashboard exists.
+    
+    Args:
+        port: Port number for the Socket.IO server
+    """
+    # Check if new modular dashboard is available
+    web_templates_dir = PROJECT_ROOT / "src" / "claude_mpm" / "web" / "templates"
+    modular_dashboard = web_templates_dir / "index.html"
+    if modular_dashboard.exists():
+        print(f"✓ Modular dashboard found at {modular_dashboard}")
+        return True
+    else:
+        print(f"⚠️  Modular dashboard not found at {modular_dashboard}")
+        print(f"   Expected path: {modular_dashboard}")
+        return False
+
+def check_server_running(port: int) -> bool:
+    """Check if a Socket.IO server is already running on the specified port.
+    
+    WHY: We want to avoid starting multiple servers on the same port
+    and provide clear feedback to users about existing servers.
+    
+    Args:
+        port: Port number to check
+        
+    Returns:
+        bool: True if server is running, False otherwise
+    """
+    try:
+        import socket
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.settimeout(1)
+            result = s.connect_ex(('127.0.0.1', port))
+            if result == 0:
+                print(f"✓ Socket.IO server already running on port {port}")
+                return True
+    except Exception:
+        pass
+    
+    return False
+
+def start_python_server(port: int, daemon: bool = False) -> Optional:
+    """Start the Python Socket.IO server.
+    
+    WHY: Uses python-socketio and aiohttp for a clean, Node.js-free
+    implementation that handles all Socket.IO functionality.
+    
+    Args:
+        port: Port number for the server
+        daemon: Whether to run in background mode
+        
+    Returns:
+        Thread object if successful, None otherwise
+    """
+    try:
+        # Import the existing Python Socket.IO server
+        sys.path.insert(0, str(PROJECT_ROOT / "src"))
+        from claude_mpm.services.socketio_server import SocketIOServer
+        
+        server = SocketIOServer(port=port)
+        
+        if daemon:
+            # Start in background thread
+            server.start()
+            print(f"🚀 Python Socket.IO server started on port {port}")
+            return server.thread
+        else:
+            # Start and block
+            print(f"🚀 Starting Python Socket.IO server on port {port}")
+            server.start()
+            
+            # Keep alive until interrupted
+            try:
+                while server.running:
+                    time.sleep(1)
+            except KeyboardInterrupt:
+                print("\\n🛑 Shutting down Python server...")
+                server.stop()
+            
+            return None
+            
+    except Exception as e:
+        print(f"❌ Failed to start Python server: {e}")
+        return None
+
+def open_dashboard(port: int, no_browser: bool = False):
+    """Open the Socket.IO dashboard in browser.
+    
+    WHY: Users need easy access to the monitoring dashboard. This function
+    handles URL construction and browser opening with fallback options.
+    Now uses the new modular dashboard location.
+    
+    Args:
+        port: Port number for the Socket.IO server
+        no_browser: Skip browser opening if True
+    """
+    if no_browser:
+        print(f"📊 Dashboard available at: http://localhost:{port}/dashboard")
+        return
+    
+    dashboard_url = f"http://localhost:{port}/dashboard?autoconnect=true&port={port}"
+    
+    try:
+        print(f"🌐 Opening dashboard: {dashboard_url}")
+        webbrowser.open(dashboard_url)
+        
+    except Exception as e:
+        print(f"⚠️  Failed to open browser automatically: {e}")
+        print(f"📊 Dashboard: {dashboard_url}")
+
+def cleanup_handler(signum, frame):
+    """Handle cleanup on shutdown signals.
+    
+    WHY: Proper cleanup ensures sockets are closed and resources freed
+    when the script is terminated.
+    """
+    print("\\n🛑 Shutting down Socket.IO launcher...")
+    sys.exit(0)
+
+def main():
+    """Main entry point for the Socket.IO dashboard launcher.
+    
+    WHY: This orchestrates the entire launch process, from dependency checking
+    to server startup and dashboard opening, with comprehensive error handling.
+    """
+    parser = argparse.ArgumentParser(
+        description="Launch Socket.IO dashboard for Claude MPM monitoring",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog='''
+Examples:
+  python launch_socketio_dashboard.py                    # Start with default settings
+  python launch_socketio_dashboard.py --port 3000       # Use specific port
+  python launch_socketio_dashboard.py --daemon          # Run in background
+  python launch_socketio_dashboard.py --no-browser      # Don't open browser
+  python launch_socketio_dashboard.py --setup-only      # Just create files
+        '''
+    )
+    
+    parser.add_argument('--port', type=int, default=3000,
+                       help='Socket.IO server port (default: 3000)')
+    parser.add_argument('--daemon', action='store_true',
+                       help='Run server in background mode')
+    parser.add_argument('--no-browser', action='store_true',
+                       help='Skip opening browser automatically')
+    parser.add_argument('--setup-only', action='store_true',
+                       help='Create necessary files without starting server')
+    
+    args = parser.parse_args()
+    
+    # Setup signal handlers
+    signal.signal(signal.SIGINT, cleanup_handler)
+    signal.signal(signal.SIGTERM, cleanup_handler)
+    
+    print("🚀 Claude MPM Socket.IO Dashboard Launcher")
+    print("=" * 50)
+    
+    # Check dashboard availability (modular dashboard)
+    check_dashboard_availability(args.port)
+    
+    if args.setup_only:
+        # Just setup files, don't start server
+        print("📁 Setup complete - files created")
+        return
+    
+    # Check if server is already running
+    if check_server_running(args.port):
+        print(f"✅ Using existing server on port {args.port}")
+        open_dashboard(args.port, args.no_browser)
+        return
+    
+    # Check Python dependencies
+    if not check_python_dependencies():
+        print("❌ Required Python packages not available")
+        sys.exit(1)
+    
+    # Start Python Socket.IO server
+    print("🟢 Using Python Socket.IO server")
+    
+    try:
+        server_thread = start_python_server(args.port, args.daemon)
+        
+        if server_thread or not args.daemon:
+            # Server started or is starting
+            time.sleep(2)  # Give server time to start
+            open_dashboard(args.port, args.no_browser)
+            
+            if args.daemon and server_thread:
+                print(f"🔄 Python server running in background")
+                print(f"   Dashboard: http://localhost:{args.port}/dashboard")
+        else:
+            print("❌ Failed to start Socket.IO server")
+            sys.exit(1)
+            
+    except KeyboardInterrupt:
+        print("\\n✅ Socket.IO launcher stopped")
+    except Exception as e:
+        print(f"❌ Launcher error: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

{claude_mpm-3.2.1 → claude_mpm-3.3.0}/src/claude_mpm/services/socketio_server.py

@@ -257,6 +257,16 @@ class SocketIOServer:
             # Add HTTP routes
             self.app.router.add_get('/health', self._handle_health)
             self.app.router.add_get('/status', self._handle_health)
+            self.app.router.add_get('/api/git-diff', self._handle_git_diff)
+            
+            # Add dashboard routes
+            self.app.router.add_get('/', self._handle_dashboard)
+            self.app.router.add_get('/dashboard', self._handle_dashboard)
+            
+            # Add static file serving for web assets
+            static_path = get_project_root() / 'src' / 'claude_mpm' / 'web' / 'static'
+            if static_path.exists():
+                self.app.router.add_static('/static/', path=str(static_path), name='static')
             
             # Register event handlers
             self._register_events()
@@ -301,6 +311,220 @@ class SocketIOServer:
             "host": self.host,
             "clients_connected": len(self.clients)
         })
+
+    async def _handle_dashboard(self, request):
+        """Serve the dashboard HTML file."""
+        dashboard_path = get_project_root() / 'src' / 'claude_mpm' / 'web' / 'templates' / 'index.html'
+        self.logger.info(f"Dashboard requested, looking for: {dashboard_path}")
+        self.logger.info(f"Path exists: {dashboard_path.exists()}")
+        if dashboard_path.exists():
+            return web.FileResponse(str(dashboard_path))
+        else:
+            return web.Response(text=f"Dashboard not found at: {dashboard_path}", status=404)
+        
+    async def _handle_git_diff(self, request):
+        """Handle git diff requests for file operations.
+        
+        Expected query parameters:
+        - file: The file path to generate diff for
+        - timestamp: ISO timestamp of the operation (optional)
+        - working_dir: Working directory for git operations (optional)
+        """
+        try:
+            # Extract query parameters
+            file_path = request.query.get('file')
+            timestamp = request.query.get('timestamp')
+            working_dir = request.query.get('working_dir', os.getcwd())
+            
+            if not file_path:
+                return web.json_response({
+                    "error": "Missing required parameter: file"
+                }, status=400)
+            
+            self.logger.debug(f"Git diff requested for file: {file_path}, timestamp: {timestamp}")
+            
+            # Generate git diff using the _generate_git_diff helper
+            diff_result = await self._generate_git_diff(file_path, timestamp, working_dir)
+            
+            return web.json_response(diff_result)
+            
+        except Exception as e:
+            self.logger.error(f"Error generating git diff: {e}")
+            return web.json_response({
+                "error": f"Failed to generate git diff: {str(e)}"
+            }, status=500)
+    
+    async def _generate_git_diff(self, file_path: str, timestamp: Optional[str] = None, working_dir: str = None):
+        """Generate git diff for a specific file operation.
+        
+        WHY: This method generates a git diff showing the changes made to a file
+        during a specific write operation. It uses git log and show commands to
+        find the most relevant commit around the specified timestamp.
+        
+        Args:
+            file_path: Path to the file relative to the git repository
+            timestamp: ISO timestamp of the file operation (optional)
+            working_dir: Working directory containing the git repository
+            
+        Returns:
+            dict: Contains diff content, metadata, and status information
+        """
+        try:
+            if working_dir is None:
+                working_dir = os.getcwd()
+                
+            # Change to the working directory
+            original_cwd = os.getcwd()
+            try:
+                os.chdir(working_dir)
+                
+                # Check if this is a git repository
+                git_check = await asyncio.create_subprocess_exec(
+                    'git', 'rev-parse', '--git-dir',
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE
+                )
+                await git_check.communicate()
+                
+                if git_check.returncode != 0:
+                    return {
+                        "error": "Not a git repository",
+                        "file_path": file_path,
+                        "working_dir": working_dir
+                    }
+                
+                # Get the absolute path of the file relative to git root
+                git_root_proc = await asyncio.create_subprocess_exec(
+                    'git', 'rev-parse', '--show-toplevel',
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE
+                )
+                git_root_output, _ = await git_root_proc.communicate()
+                
+                if git_root_proc.returncode != 0:
+                    return {"error": "Failed to determine git root directory"}
+                
+                git_root = git_root_output.decode().strip()
+                
+                # Make file_path relative to git root if it's absolute
+                if os.path.isabs(file_path):
+                    try:
+                        file_path = os.path.relpath(file_path, git_root)
+                    except ValueError:
+                        # File is not under git root
+                        pass
+                
+                # If timestamp is provided, try to find commits around that time
+                if timestamp:
+                    # Convert timestamp to git format
+                    try:
+                        from datetime import datetime
+                        dt = datetime.fromisoformat(timestamp.replace('Z', '+00:00'))
+                        git_since = dt.strftime('%Y-%m-%d %H:%M:%S')
+                        
+                        # Find commits that modified this file around the timestamp
+                        log_proc = await asyncio.create_subprocess_exec(
+                            'git', 'log', '--oneline', '--since', git_since, 
+                            '--until', f'{git_since} +1 hour', '--', file_path,
+                            stdout=asyncio.subprocess.PIPE,
+                            stderr=asyncio.subprocess.PIPE
+                        )
+                        log_output, _ = await log_proc.communicate()
+                        
+                        if log_proc.returncode == 0 and log_output:
+                            # Get the most recent commit hash
+                            commits = log_output.decode().strip().split('\n')
+                            if commits and commits[0]:
+                                commit_hash = commits[0].split()[0]
+                                
+                                # Get the diff for this specific commit
+                                diff_proc = await asyncio.create_subprocess_exec(
+                                    'git', 'show', '--format=fuller', commit_hash, '--', file_path,
+                                    stdout=asyncio.subprocess.PIPE,
+                                    stderr=asyncio.subprocess.PIPE
+                                )
+                                diff_output, diff_error = await diff_proc.communicate()
+                                
+                                if diff_proc.returncode == 0:
+                                    return {
+                                        "success": True,
+                                        "diff": diff_output.decode(),
+                                        "commit_hash": commit_hash,
+                                        "file_path": file_path,
+                                        "method": "timestamp_based",
+                                        "timestamp": timestamp
+                                    }
+                    except Exception as e:
+                        self.logger.warning(f"Failed to parse timestamp or find commits: {e}")
+                
+                # Fallback: Get the most recent change to the file
+                log_proc = await asyncio.create_subprocess_exec(
+                    'git', 'log', '-1', '--oneline', '--', file_path,
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE
+                )
+                log_output, _ = await log_proc.communicate()
+                
+                if log_proc.returncode == 0 and log_output:
+                    commit_hash = log_output.decode().strip().split()[0]
+                    
+                    # Get the diff for the most recent commit
+                    diff_proc = await asyncio.create_subprocess_exec(
+                        'git', 'show', '--format=fuller', commit_hash, '--', file_path,
+                        stdout=asyncio.subprocess.PIPE,
+                        stderr=asyncio.subprocess.PIPE
+                    )
+                    diff_output, diff_error = await diff_proc.communicate()
+                    
+                    if diff_proc.returncode == 0:
+                        return {
+                            "success": True,
+                            "diff": diff_output.decode(),
+                            "commit_hash": commit_hash,
+                            "file_path": file_path,
+                            "method": "latest_commit",
+                            "timestamp": timestamp
+                        }
+                
+                # Final fallback: Show current working directory changes
+                diff_proc = await asyncio.create_subprocess_exec(
+                    'git', 'diff', 'HEAD', '--', file_path,
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE
+                )
+                diff_output, _ = await diff_proc.communicate()
+                
+                if diff_proc.returncode == 0:
+                    working_diff = diff_output.decode()
+                    if working_diff.strip():
+                        return {
+                            "success": True,
+                            "diff": working_diff,
+                            "commit_hash": "working_directory",
+                            "file_path": file_path,
+                            "method": "working_directory",
+                            "timestamp": timestamp
+                        }
+                
+                return {
+                    "error": "No git history found for this file",
+                    "file_path": file_path,
+                    "suggestions": [
+                        "The file may not be tracked by git",
+                        "The file may not have any committed changes",
+                        "The timestamp may be outside the git history range"
+                    ]
+                }
+                
+            finally:
+                os.chdir(original_cwd)
+                
+        except Exception as e:
+            self.logger.error(f"Error in _generate_git_diff: {e}")
+            return {
+                "error": f"Git diff generation failed: {str(e)}",
+                "file_path": file_path
+            }
         
             
     def _register_events(self):

{claude_mpm-3.2.1 → claude_mpm-3.3.0}/src/claude_mpm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 3.2.1
+Version: 3.3.0
 Summary: Claude Multi-agent Project Manager - Clean orchestration with ticket management
 Home-page: https://github.com/bobmatnyc/claude-mpm
 Author: Claude MPM Team

{claude_mpm-3.2.1 → claude_mpm-3.3.0}/src/claude_mpm.egg-info/SOURCES.txt

@@ -464,6 +464,7 @@ src/claude_mpm/scripts/claude-mpm-socketio
 src/claude_mpm/scripts/claude_mpm_monitor.html
 src/claude_mpm/scripts/install_socketio_server.py
 src/claude_mpm/scripts/launch_monitor.py
+src/claude_mpm/scripts/launch_socketio_dashboard.py
 src/claude_mpm/scripts/manage_version.py
 src/claude_mpm/scripts/socketio_daemon.py
 src/claude_mpm/scripts/socketio_server_manager.py

claude_mpm-3.2.1/VERSION

@@ -1 +0,0 @@
-3.2.1