claude-mpm 3.4.10__py3-none-any.whl → 5.4.55__py3-none-any.whl

claude_mpm/utils/paths.py

@@ -1,289 +0,0 @@
-"""Path resolution utilities for Claude MPM.
-
-This module provides centralized path discovery and resolution logic
-to avoid duplication across the codebase.
-"""
-
-import os
-from pathlib import Path
-from typing import Optional, Union, List
-from functools import lru_cache
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class PathResolver:
-    """Centralized path resolution for Claude MPM.
-    
-    This class consolidates all path discovery logic to avoid duplication
-    across different modules. It handles various scenarios including:
-    - Running from different directories
-    - Installed vs development mode
-    - Missing directories
-    
-    All methods use caching to improve performance for repeated lookups.
-    """
-    
-    @classmethod
-    @lru_cache(maxsize=1)
-    def get_framework_root(cls) -> Path:
-        """Find the framework root directory.
-        
-        This method searches for the framework root by looking for marker files
-        like pyproject.toml or the claude_mpm package directory.
-        
-        Returns:
-            Path: The framework root directory
-            
-        Raises:
-            FileNotFoundError: If framework root cannot be determined
-        """
-        # First, try to find via the module location
-        try:
-            import claude_mpm
-            module_path = Path(claude_mpm.__file__).parent
-            # Go up to find the src directory, then one more for root
-            if module_path.parent.name == 'src':
-                return module_path.parent.parent
-            # Otherwise, assume we're in site-packages
-            return module_path
-        except ImportError:
-            pass
-        
-        # Fallback: search upward for pyproject.toml
-        current = Path.cwd()
-        while current != current.parent:
-            if (current / 'pyproject.toml').exists():
-                # Verify this is our project
-                if (current / 'src' / 'claude_mpm').exists():
-                    return current
-            current = current.parent
-        
-        raise FileNotFoundError(
-            "Could not determine framework root. Please run from within "
-            "the claude-mpm project or ensure it's properly installed."
-        )
-    
-    @classmethod
-    @lru_cache(maxsize=1)
-    def get_agents_dir(cls) -> Path:
-        """Get the agents directory path.
-        
-        Returns:
-            Path: The agents directory within the framework
-            
-        Raises:
-            FileNotFoundError: If agents directory doesn't exist
-        """
-        framework_root = cls.get_framework_root()
-        
-        # Check for development structure
-        agents_dir = framework_root / 'src' / 'claude_mpm' / 'agents'
-        if agents_dir.exists():
-            return agents_dir
-        
-        # Check for installed structure
-        agents_dir = framework_root / 'claude_mpm' / 'agents'
-        if agents_dir.exists():
-            return agents_dir
-        
-        raise FileNotFoundError(
-            f"Agents directory not found. Searched in:\n"
-            f"  - {framework_root / 'src' / 'claude_mpm' / 'agents'}\n"
-            f"  - {framework_root / 'claude_mpm' / 'agents'}"
-        )
-    
-    @classmethod
-    @lru_cache(maxsize=1)
-    def get_project_root(cls) -> Path:
-        """Find the current project root.
-        
-        Searches for project markers like .git, pyproject.toml, package.json, etc.
-        
-        Returns:
-            Path: The current project root directory
-            
-        Raises:
-            FileNotFoundError: If no project root can be determined
-        """
-        # Project root markers in order of preference
-        markers = ['.git', 'pyproject.toml', 'package.json', 'Cargo.toml', 
-                   'go.mod', 'pom.xml', 'build.gradle', '.claude-pm']
-        
-        current = Path.cwd()
-        while current != current.parent:
-            for marker in markers:
-                if (current / marker).exists():
-                    logger.debug(f"Found project root at {current} via {marker}")
-                    return current
-            current = current.parent
-        
-        # If no markers found, use current directory
-        logger.warning("No project markers found, using current directory as project root")
-        return Path.cwd()
-    
-    @classmethod
-    @lru_cache(maxsize=4)
-    def get_config_dir(cls, scope: str = 'project') -> Path:
-        """Get configuration directory for the specified scope.
-        
-        Args:
-            scope: One of 'project', 'user', 'system', or 'framework'
-            
-        Returns:
-            Path: The configuration directory
-            
-        Raises:
-            ValueError: If scope is invalid
-            FileNotFoundError: If directory cannot be determined
-        """
-        if scope == 'project':
-            return cls.get_project_root() / '.claude-pm'
-        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'
-        elif scope == 'system':
-            # System-wide configuration
-            if os.name == 'posix':
-                return Path('/etc/claude-pm')
-            else:
-                # Windows: Use ProgramData
-                return Path(os.environ.get('ProgramData', 'C:\\ProgramData')) / 'claude-pm'
-        elif scope == 'framework':
-            return cls.get_framework_root() / '.claude-pm'
-        else:
-            raise ValueError(f"Invalid scope: {scope}. Must be one of: project, user, system, framework")
-    
-    @classmethod
-    def find_file_upwards(cls, filename: str, start_path: Optional[Path] = None) -> Optional[Path]:
-        """Generic upward file search.
-        
-        Searches for a file by traversing up the directory tree.
-        
-        Args:
-            filename: Name of the file to search for
-            start_path: Starting directory (defaults to current directory)
-            
-        Returns:
-            Path: Full path to the found file, or None if not found
-        """
-        current = Path(start_path) if start_path else Path.cwd()
-        
-        while current != current.parent:
-            target = current / filename
-            if target.exists():
-                logger.debug(f"Found {filename} at {target}")
-                return target
-            current = current.parent
-        
-        logger.debug(f"Could not find {filename} in any parent directory")
-        return None
-    
-    @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.
-        
-        Args:
-            base_path: Starting directory (defaults to current directory)
-            
-        Returns:
-            Path: The .claude-pm directory, or None if not found
-        """
-        result = cls.find_file_upwards('.claude-pm', base_path)
-        return result if result and result.is_dir() else None
-    
-    @classmethod
-    def ensure_directory(cls, path: Path) -> Path:
-        """Ensure a directory exists, creating it if necessary.
-        
-        Args:
-            path: Directory path to ensure exists
-            
-        Returns:
-            Path: The directory path
-            
-        Raises:
-            OSError: If directory cannot be created
-        """
-        try:
-            path.mkdir(parents=True, exist_ok=True)
-            return path
-        except OSError as e:
-            logger.error(f"Failed to create directory {path}: {e}")
-            raise
-    
-    @classmethod
-    def get_relative_to_root(cls, path: Union[str, Path], root_type: str = 'project') -> Path:
-        """Get a path relative to a specific root.
-        
-        Args:
-            path: Relative path within the root
-            root_type: Type of root ('project' or 'framework')
-            
-        Returns:
-            Path: Full path relative to the specified root
-            
-        Raises:
-            ValueError: If root_type is invalid
-        """
-        if root_type == 'project':
-            root = cls.get_project_root()
-        elif root_type == 'framework':
-            root = cls.get_framework_root()
-        else:
-            raise ValueError(f"Invalid root_type: {root_type}. Must be 'project' or 'framework'")
-        
-        return root / path
-    
-    @classmethod
-    def find_files_by_pattern(cls, pattern: str, root: Optional[Path] = None) -> List[Path]:
-        """Find all files matching a pattern within a directory tree.
-        
-        Args:
-            pattern: Glob pattern to match (e.g., '*.py', '**/*.md')
-            root: Root directory to search (defaults to project root)
-            
-        Returns:
-            List[Path]: List of matching file paths
-        """
-        if root is None:
-            root = cls.get_project_root()
-        
-        matches = list(root.glob(pattern))
-        logger.debug(f"Found {len(matches)} files matching '{pattern}' in {root}")
-        return matches
-    
-    @classmethod
-    def clear_cache(cls):
-        """Clear all cached path lookups.
-        
-        Useful for testing or when the file system structure changes.
-        """
-        # Clear all lru_cache instances
-        cls.get_framework_root.cache_clear()
-        cls.get_agents_dir.cache_clear()
-        cls.get_project_root.cache_clear()
-        cls.get_config_dir.cache_clear()
-        cls.get_claude_pm_dir.cache_clear()
-        logger.debug("Cleared all PathResolver caches")
-
-
-# Convenience functions for backward compatibility
-def get_framework_root() -> Path:
-    """Get the framework root directory."""
-    return PathResolver.get_framework_root()
-
-
-def get_project_root() -> Path:
-    """Get the current project root directory."""
-    return PathResolver.get_project_root()
-
-
-def find_file_upwards(filename: str, start_path: Optional[Path] = None) -> Optional[Path]:
-    """Search for a file by traversing up the directory tree."""
-    return PathResolver.find_file_upwards(filename, start_path)

claude_mpm-3.4.10.dist-info/METADATA

@@ -1,183 +0,0 @@
-Metadata-Version: 2.4
-Name: claude-mpm
-Version: 3.4.10
-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
-Requires-Dist: python-socketio>=5.11.0
-Requires-Dist: aiohttp>=3.9.0
-Requires-Dist: python-engineio>=4.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
-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)
-- 🧠 **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
-- 📁 **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
-
-### Agent Memory System
-Agents learn and improve over time with persistent memory:
-- **Project-Specific Knowledge**: Automatically analyzes your codebase to understand patterns
-- **Continuous Learning**: Agents remember insights across sessions
-- **Memory Management**: Initialize, optimize, and manage agent memories
-- **Quick Initialization**: Use `/mpm memory init` to scan project and create memories
-
-```bash
-# Initialize project-specific memories
-claude-mpm memory init
-
-# View memory status
-claude-mpm memory status
-
-# Add specific learning
-claude-mpm memory add engineer pattern "Always use async/await for I/O"
-```
-
-See [docs/MEMORY.md](docs/MEMORY.md) for comprehensive memory system documentation.
-
-### 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
-- **[Agent Memory System](docs/MEMORY.md)** - Comprehensive memory documentation
-- **[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.4.0)
-
-### 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
-
-### 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
-
-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