claude-mpm 3.2.1__py3-none-any.whl → 3.3.2__py3-none-any.whl

claude_mpm/services/socketio_server.py

@@ -254,9 +254,31 @@ class SocketIOServer:
             self.app = web.Application()
             self.sio.attach(self.app)
             
+            # Add CORS middleware
+            import aiohttp_cors
+            cors = aiohttp_cors.setup(self.app, defaults={
+                "*": aiohttp_cors.ResourceOptions(
+                    allow_credentials=True,
+                    expose_headers="*",
+                    allow_headers="*",
+                    allow_methods="*"
+                )
+            })
+            
             # 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)
+            self.app.router.add_options('/api/git-diff', self._handle_cors_preflight)
+            
+            # 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()
@@ -300,7 +322,335 @@ class SocketIOServer:
             "port": self.port,
             "host": self.host,
             "clients_connected": len(self.clients)
+        }, headers={
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+            'Access-Control-Allow-Headers': 'Content-Type, Accept'
         })
+
+    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_cors_preflight(self, request):
+        """Handle CORS preflight requests."""
+        return web.Response(
+            status=200,
+            headers={
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type, Accept, Authorization',
+                'Access-Control-Max-Age': '86400'
+            }
+        )
+        
+    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())
+            
+            self.logger.info(f"Git diff API request: file={file_path}, timestamp={timestamp}, working_dir={working_dir}")
+            
+            if not file_path:
+                self.logger.warning("Git diff request missing file parameter")
+                return web.json_response({
+                    "success": False,
+                    "error": "Missing required parameter: file"
+                }, status=400, headers={
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+                    'Access-Control-Allow-Headers': 'Content-Type, Accept'
+                })
+            
+            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)
+            
+            self.logger.info(f"Git diff result: success={diff_result.get('success', False)}, method={diff_result.get('method', 'unknown')}")
+            
+            return web.json_response(diff_result, headers={
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type, Accept'
+            })
+            
+        except Exception as e:
+            self.logger.error(f"Error generating git diff: {e}")
+            import traceback
+            self.logger.error(f"Git diff error traceback: {traceback.format_exc()}")
+            return web.json_response({
+                "success": False,
+                "error": f"Failed to generate git diff: {str(e)}"
+            }, status=500, headers={
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type, Accept'
+            })
+    
+    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 file_path is absolute, determine its git repository
+            if os.path.isabs(file_path):
+                # Find the directory containing the file
+                file_dir = os.path.dirname(file_path)
+                if os.path.exists(file_dir):
+                    # Try to find the git root from the file's directory
+                    current_dir = file_dir
+                    while current_dir != "/" and current_dir:
+                        if os.path.exists(os.path.join(current_dir, ".git")):
+                            working_dir = current_dir
+                            self.logger.info(f"Found git repository at: {working_dir}")
+                            break
+                        current_dir = os.path.dirname(current_dir)
+                    else:
+                        # If no git repo found, use the file's directory
+                        working_dir = file_dir
+                        self.logger.info(f"No git repo found, using file's directory: {working_dir}")
+            
+            if working_dir is None:
+                working_dir = os.getcwd()
+                
+            # For read-only git operations, we can work from any directory
+            # by passing the -C flag to git commands instead of changing directories
+            original_cwd = os.getcwd()
+            try:
+                # We'll use git -C <working_dir> for all commands instead of chdir
+                
+                # Check if this is a git repository
+                git_check = await asyncio.create_subprocess_exec(
+                    'git', '-C', working_dir, 'rev-parse', '--git-dir',
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE
+                )
+                await git_check.communicate()
+                
+                if git_check.returncode != 0:
+                    return {
+                        "success": False,
+                        "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', '-C', working_dir, '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 {"success": False, "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', '-C', working_dir, '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', '-C', working_dir, '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', '-C', working_dir, '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', '-C', working_dir, '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
+                        }
+                
+                # Try to show unstaged changes first
+                diff_proc = await asyncio.create_subprocess_exec(
+                    'git', '-C', working_dir, 'diff', '--', file_path,
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE
+                )
+                diff_output, _ = await diff_proc.communicate()
+                
+                if diff_proc.returncode == 0 and diff_output.decode().strip():
+                    return {
+                        "success": True,
+                        "diff": diff_output.decode(),
+                        "commit_hash": "unstaged_changes",
+                        "file_path": file_path,
+                        "method": "unstaged_changes",
+                        "timestamp": timestamp
+                    }
+                
+                # Then try staged changes
+                diff_proc = await asyncio.create_subprocess_exec(
+                    'git', '-C', working_dir, 'diff', '--cached', '--', file_path,
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE
+                )
+                diff_output, _ = await diff_proc.communicate()
+                
+                if diff_proc.returncode == 0 and diff_output.decode().strip():
+                    return {
+                        "success": True,
+                        "diff": diff_output.decode(),
+                        "commit_hash": "staged_changes",
+                        "file_path": file_path,
+                        "method": "staged_changes",
+                        "timestamp": timestamp
+                    }
+                
+                # Final fallback: Show changes against HEAD
+                diff_proc = await asyncio.create_subprocess_exec(
+                    'git', '-C', working_dir, '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
+                        }
+                
+                # Check if file is from a different repository
+                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"
+                ]
+                
+                if os.path.isabs(file_path) and not file_path.startswith(os.getcwd()):
+                    current_repo = os.path.basename(os.getcwd())
+                    file_repo = "unknown"
+                    # Try to extract repository name from path
+                    path_parts = file_path.split("/")
+                    if "Projects" in path_parts:
+                        idx = path_parts.index("Projects")
+                        if idx + 1 < len(path_parts):
+                            file_repo = path_parts[idx + 1]
+                    
+                    suggestions.clear()
+                    suggestions.append(f"This file is from the '{file_repo}' repository")
+                    suggestions.append(f"The git diff viewer is running from the '{current_repo}' repository")
+                    suggestions.append("Git diff can only show changes for files in the current repository")
+                    suggestions.append("To view changes for this file, run the monitoring dashboard from its repository")
+                
+                return {
+                    "success": False,
+                    "error": "No git history found for this file",
+                    "file_path": file_path,
+                    "suggestions": suggestions
+                }
+                
+            finally:
+                os.chdir(original_cwd)
+                
+        except Exception as e:
+            self.logger.error(f"Error in _generate_git_diff: {e}")
+            return {
+                "success": False,
+                "error": f"Git diff generation failed: {str(e)}",
+                "file_path": file_path
+            }
         
             
     def _register_events(self):
@@ -406,6 +756,44 @@ class SocketIOServer:
             
             # Re-broadcast to all other clients
             await self.sio.emit('claude_event', data, skip_sid=sid)
+        
+        @self.sio.event
+        async def get_git_branch(sid, working_dir=None):
+            """Get the current git branch for a directory"""
+            import subprocess
+            try:
+                if not working_dir:
+                    working_dir = os.getcwd()
+                
+                # Run git command to get current branch
+                result = subprocess.run(
+                    ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+                    cwd=working_dir,
+                    capture_output=True,
+                    text=True
+                )
+                
+                if result.returncode == 0:
+                    branch = result.stdout.strip()
+                    await self.sio.emit('git_branch_response', {
+                        'success': True,
+                        'branch': branch,
+                        'working_dir': working_dir
+                    }, room=sid)
+                else:
+                    await self.sio.emit('git_branch_response', {
+                        'success': False,
+                        'error': 'Not a git repository',
+                        'working_dir': working_dir
+                    }, room=sid)
+                    
+            except Exception as e:
+                self.logger.error(f"Error getting git branch: {e}")
+                await self.sio.emit('git_branch_response', {
+                    'success': False,
+                    'error': str(e),
+                    'working_dir': working_dir
+                }, room=sid)
             
     async def _send_current_status(self, sid: str):
         """Send current system status to a client."""
@@ -695,4 +1083,4 @@ def stop_socketio_server():
     global _socketio_server
     if _socketio_server:
         _socketio_server.stop()
-        _socketio_server = None
+        _socketio_server = None

claude_mpm-3.3.2.dist-info/METADATA

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: claude-mpm
+Version: 3.3.2
+Summary: Claude Multi-agent Project Manager - Clean orchestration with ticket management
+Home-page: https://github.com/bobmatnyc/claude-mpm
+Author: Claude MPM Team
+Author-email: bob@matsuoka.com
+License: MIT
+Keywords: claude,orchestration,multi-agent,ticket-management
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+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
+Requires-Dist: requests>=2.25.0
+Requires-Dist: flask>=3.0.0
+Requires-Dist: flask-cors>=4.0.0
+Requires-Dist: watchdog>=3.0.0
+Requires-Dist: tree-sitter>=0.21.0
+Requires-Dist: tree-sitter-language-pack>=0.8.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Provides-Extra: monitor
+Requires-Dist: python-socketio>=5.11.0; extra == "monitor"
+Requires-Dist: aiohttp>=3.9.0; extra == "monitor"
+Requires-Dist: python-engineio>=4.8.0; extra == "monitor"
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Claude MPM - Multi-Agent Project Manager
+
+A powerful orchestration framework for Claude Code that enables multi-agent workflows, session management, and real-time monitoring through an intuitive interface.
+
+> **Quick Start**: See [QUICKSTART.md](QUICKSTART.md) to get running in 5 minutes!
+
+## Features
+
+- 🤖 **Multi-Agent System**: Automatically delegates tasks to specialized agents (PM, Research, Engineer, QA, Documentation, Security, Ops, Data Engineer)
+- 🔄 **Session Management**: Resume previous sessions with `--resume` 
+- 📊 **Real-Time Monitoring**: Live dashboard with `--monitor` flag
+- 📁 **Multi-Project Support**: Per-session working directories
+- 🔍 **Git Integration**: View diffs and track changes across projects
+- 🎯 **Smart Task Orchestration**: PM agent intelligently routes work to specialists
+
+## Installation
+
+```bash
+# Install from PyPI
+pip install claude-mpm
+
+# Or with monitoring support
+pip install "claude-mpm[monitor]"
+```
+
+## Basic Usage
+
+```bash
+# Interactive mode (recommended)
+claude-mpm
+
+# Non-interactive with task
+claude-mpm run -i "analyze this codebase" --non-interactive
+
+# With monitoring dashboard
+claude-mpm run --monitor
+
+# Resume last session
+claude-mpm run --resume
+```
+
+For detailed usage, see [QUICKSTART.md](QUICKSTART.md)
+
+## Key Capabilities
+
+### Multi-Agent Orchestration
+The PM agent automatically delegates work to specialized agents:
+- **Research**: Codebase analysis and investigation
+- **Engineer**: Implementation and coding
+- **QA**: Testing and validation
+- **Documentation**: Docs and guides
+- **Security**: Security analysis
+- **Ops**: Deployment and infrastructure
+
+### Session Management
+- All work is tracked in persistent sessions
+- Resume any session with `--resume`
+- Switch between projects with per-session directories
+- View session history and activity
+
+### Real-Time Monitoring
+The `--monitor` flag opens a web dashboard showing:
+- Live agent activity and delegations
+- File operations with git diff viewer
+- Tool usage and results
+- Session management UI
+
+See [docs/monitoring.md](docs/monitoring.md) for full monitoring guide.
+
+
+## Documentation
+
+- **[Quick Start Guide](QUICKSTART.md)** - Get running in 5 minutes
+- **[Monitoring Dashboard](docs/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.3.1)
+
+### Session Working Directories
+- Each session can now have its own working directory
+- Git operations use the session's directory automatically
+- Switch projects seamlessly without changing terminal directory
+
+### Monitoring Improvements
+- Fixed git diff viewer for cross-project files
+- Auto-sync working directory from session data
+- Improved error handling and display
+
+See [CHANGELOG.md](CHANGELOG.md) for full history.
+
+## Development
+
+### Contributing
+See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+### Project Structure
+See [docs/STRUCTURE.md](docs/STRUCTURE.md) for codebase organization.
+
+### License
+MIT License - see [LICENSE](LICENSE) file.
+
+## Credits
+
+- Based on [claude-multiagent-pm](https://github.com/kfsone/claude-multiagent-pm)
+- Enhanced for [Claude Code](https://docs.anthropic.com/en/docs/claude-code) integration
+- Built with ❤️ by the Claude MPM community