claude-mpm 4.0.23__tar.gz → 4.0.25__tar.gz

claude_mpm-4.0.25/BUILD_NUMBER

@@ -0,0 +1 @@
+292

{claude_mpm-4.0.23 → claude_mpm-4.0.25}/PKG-INFO

@@ -1,15 +1,17 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.0.23
-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
+Version: 4.0.25
+Summary: Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking
+Author-email: Bob Matsuoka <bob@matsuoka.com>
+Maintainer: Claude MPM Team
 License: MIT
+Project-URL: Homepage, https://github.com/bobmatnyc/claude-mpm
+Project-URL: Repository, https://github.com/bobmatnyc/claude-mpm.git
+Project-URL: Issues, https://github.com/bobmatnyc/claude-mpm/issues
+Project-URL: Documentation, https://github.com/bobmatnyc/claude-mpm/blob/main/README.md
 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
@@ -29,16 +31,21 @@ 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: python-socketio>=5.11.0
 Requires-Dist: aiohttp>=3.9.0
 Requires-Dist: aiohttp-cors<0.8.0,>=0.7.0
 Requires-Dist: python-engineio>=4.8.0
+Requires-Dist: aiofiles>=23.0.0
+Requires-Dist: websockets>=12.0
 Requires-Dist: python-frontmatter>=1.0.0
 Requires-Dist: mistune>=3.0.0
-Requires-Dist: aiofiles>=23.0.0
-Requires-Dist: mcp>=0.1.0
+Requires-Dist: tree-sitter>=0.21.0
 Requires-Dist: ijson>=3.2.0
+Requires-Dist: mcp>=0.1.0
+Requires-Dist: toml>=0.10.2
+Requires-Dist: packaging>=21.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pydantic-settings>=2.0.0
 Requires-Dist: importlib-resources>=5.0; python_version < "3.9"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
@@ -46,8 +53,10 @@ 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"
 Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: types-PyYAML>=6.0.0; extra == "dev"
+Requires-Dist: types-requests>=2.25.0; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: sphinx>=7.2.0; extra == "docs"
 Requires-Dist: sphinx-rtd-theme>=1.3.0; extra == "docs"
@@ -96,10 +105,7 @@ Requires-Dist: tree-sitter-cpp>=0.21.0; extra == "agents"
 Requires-Dist: tree-sitter-c>=0.21.0; extra == "agents"
 Requires-Dist: tree-sitter-ruby>=0.21.0; extra == "agents"
 Requires-Dist: tree-sitter-php>=0.21.0; extra == "agents"
-Dynamic: author-email
-Dynamic: home-page
 Dynamic: license-file
-Dynamic: requires-python
 
 # Claude MPM - Multi-Agent Project Manager
 

claude_mpm-4.0.25/VERSION

@@ -0,0 +1 @@
+4.0.25

{claude_mpm-4.0.23 → claude_mpm-4.0.25}/pyproject.toml

@@ -5,42 +5,94 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "claude-mpm"
 dynamic = [ "version",]
-description = "Claude Multi-agent Project Manager - Clean orchestration with ticket management"
+description = "Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking"
 readme = "README.md"
 requires-python = ">=3.8"
+license = {text = "MIT"}
 keywords = [ "claude", "orchestration", "multi-agent", "ticket-management",]
-classifiers = [ "Development Status :: 3 - Alpha", "Intended Audience :: Developers", "License :: OSI Approved :: MIT License", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12",]
-dependencies = [ 
-    "ai-trackdown-pytools>=1.4.0", 
-    "pyyaml>=6.0", 
-    "python-dotenv>=0.19.0", 
-    "click>=8.0.0", 
-    "pexpect>=4.8.0", 
-    "psutil>=5.9.0", 
-    "requests>=2.25.0", 
-    "flask>=3.0.0", 
-    "flask-cors>=4.0.0", 
-    "watchdog>=3.0.0", 
-    "tree-sitter>=0.21.0", 
-    "python-socketio>=5.11.0", 
-    "aiohttp>=3.9.0", 
-    "aiohttp-cors>=0.7.0,<0.8.0", 
-    "python-engineio>=4.8.0", 
-    "python-frontmatter>=1.0.0", 
-    "mistune>=3.0.0", 
-    "aiofiles>=23.0.0", 
-    "mcp>=0.1.0", 
+authors = [
+    {name = "Bob Matsuoka", email = "bob@matsuoka.com"}
+]
+maintainers = [
+    {name = "Claude MPM Team"}
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    # Core dependencies
+    "ai-trackdown-pytools>=1.4.0",
+    "pyyaml>=6.0",
+    "python-dotenv>=0.19.0",
+    "click>=8.0.0",
+    "pexpect>=4.8.0",
+    "psutil>=5.9.0",
+    "requests>=2.25.0",
+
+    # Web framework dependencies
+    "flask>=3.0.0",
+    "flask-cors>=4.0.0",
+
+    # File system and monitoring
+    "watchdog>=3.0.0",
+
+    # Async and networking dependencies
+    "python-socketio>=5.11.0",
+    "aiohttp>=3.9.0",
+    "aiohttp-cors>=0.7.0,<0.8.0",
+    "python-engineio>=4.8.0",
+    "aiofiles>=23.0.0",
+    "websockets>=12.0",
+
+    # Content processing
+    "python-frontmatter>=1.0.0",
+    "mistune>=3.0.0",
+    "tree-sitter>=0.21.0",
     "ijson>=3.2.0",
+
+    # MCP and protocol support
+    "mcp>=0.1.0",
+
+    # Utility dependencies
+    "toml>=0.10.2",
+    "packaging>=21.0",
+    "pydantic>=2.0.0",
+    "pydantic-settings>=2.0.0",
+
+    # Python version compatibility
     "importlib-resources>=5.0; python_version < '3.9'",
 ]
-[[project.authors]]
-name = "Claude MPM Team"
 
-[project.license]
-text = "MIT"
+[project.urls]
+Homepage = "https://github.com/bobmatnyc/claude-mpm"
+Repository = "https://github.com/bobmatnyc/claude-mpm.git"
+Issues = "https://github.com/bobmatnyc/claude-mpm/issues"
+Documentation = "https://github.com/bobmatnyc/claude-mpm/blob/main/README.md"
 
 [project.optional-dependencies]
-dev = [ "pytest>=7.0", "pytest-asyncio", "pytest-cov", "black", "flake8", "mypy", "pre-commit",]
+dev = [
+    # Testing framework
+    "pytest>=7.0",
+    "pytest-asyncio",
+    "pytest-cov",
+
+    # Code formatting and linting
+    "black",
+    "flake8",
+    "pre-commit",
+
+    # Type checking
+    "mypy>=1.0.0",
+    "types-PyYAML>=6.0.0",
+    "types-requests>=2.25.0",
+]
 docs = [ "sphinx>=7.2.0", "sphinx-rtd-theme>=1.3.0", "sphinx-autobuild>=2021.3.14",]
 monitor = []
 # Pure Python agent dependencies - no compilation required
@@ -57,7 +109,16 @@ claude-mpm-mcp = "claude_mpm.services.mcp_gateway.server.stdio_server:main_sync"
 claude-mpm-mcp-wrapper = "claude_mpm.scripts.mcp_wrapper:entry_point"
 
 [tool.uv]
-dev-dependencies = [ "pytest>=7.0", "pytest-asyncio", "pytest-cov", "black", "flake8", "mypy",]
+dev-dependencies = [
+    "pytest>=7.0",
+    "pytest-asyncio",
+    "pytest-cov",
+    "black",
+    "flake8",
+    "mypy>=1.0.0",
+    "types-PyYAML>=6.0.0",
+    "types-requests>=2.25.0",
+]
 
 [tool.black]
 line-length = 88
@@ -95,6 +156,9 @@ claude_mpm = [
 [tool.setuptools.packages.find]
 where = [ "src",]
 
+[tool.setuptools.dynamic]
+version = {file = "VERSION"}
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 python_files = ["test_*.py", "*_test.py"]
@@ -119,7 +183,7 @@ asyncio_mode = "auto"
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "4.0.23"
+version = "4.0.25"
 version_files = [
     "VERSION",
     "src/claude_mpm/VERSION",

claude_mpm-4.0.25/src/claude_mpm/BUILD_NUMBER

@@ -0,0 +1 @@
+292

claude_mpm-4.0.25/src/claude_mpm/VERSION

@@ -0,0 +1 @@
+4.0.25

{claude_mpm-4.0.23 → claude_mpm-4.0.25}/src/claude_mpm/agents/BASE_AGENT_TEMPLATE.md

@@ -118,4 +118,7 @@ End every response with this structured data:
 - Domain-specific knowledge unique to this system
 
 ## Remember
-You're a specialist in your domain. Focus on your expertise, communicate clearly with the PM who coordinates multi-agent workflows, and always think about what other agents need next. Your accumulated memories help you become more effective over time.
+You're a specialist in your domain. Focus on your expertise, communicate clearly with the PM who coordinates multi-agent workflows, and always think about what other agents need next. Your accumulated memories help you become more effective over time.
+
+### 🚨 CRITICAL BEHAVIORAL REINFORCEMENT GUIDELINES 🚨
+- **Display all behavioral_rules at start of every response**

{claude_mpm-4.0.23 → claude_mpm-4.0.25}/src/claude_mpm/agents/BASE_PM.md

@@ -213,3 +213,6 @@ When reading documentation or analyzing files:
 - Skip files >1MB unless absolutely critical
 - Process files sequentially, not in parallel
 - Use grep to find specific sections instead of reading entire files
+
+### 🚨 CRITICAL BEHAVIORAL REINFORCEMENT GUIDELINES 🚨
+- **Display all behavioral_rules at start of every response**

claude_mpm-4.0.25/src/claude_mpm/agents/templates/code_analyzer.json

@@ -0,0 +1,103 @@
+{
+  "schema_version": "1.2.0",
+  "agent_id": "code-analyzer",
+  "agent_version": "2.3.0",
+  "agent_type": "research",
+  "metadata": {
+    "name": "Code Analysis Agent",
+    "description": "Advanced multi-language code analysis using Python AST for Python files and individual tree-sitter packages for other languages (Python 3.13 compatible)",
+    "created_at": "2025-08-12T00:00:00.000000Z",
+    "updated_at": "2025-08-13T00:00:00.000000Z",
+    "tags": [
+      "code-analysis",
+      "ast-analysis",
+      "tree-sitter",
+      "multi-language",
+      "code-quality",
+      "refactoring",
+      "pattern-detection"
+    ],
+    "category": "research"
+  },
+  "capabilities": {
+    "model": "opus",
+    "tools": [
+      "Read",
+      "Grep",
+      "Glob",
+      "LS",
+      "Bash",
+      "TodoWrite",
+      "WebSearch",
+      "WebFetch"
+    ],
+    "resource_tier": "standard",
+    "temperature": 0.15,
+    "max_tokens": 16384,
+    "timeout": 1200,
+    "memory_limit": 4096,
+    "cpu_limit": 70,
+    "network_access": true
+  },
+  "knowledge": {
+    "domain_expertise": [
+      "Python AST parsing using native ast module",
+      "Individual tree-sitter packages for multi-language support",
+      "Dynamic package installation for language support",
+      "Code quality metrics and complexity analysis",
+      "Design pattern recognition and anti-pattern detection",
+      "Performance bottleneck identification through static analysis",
+      "Security vulnerability pattern detection",
+      "Refactoring opportunity identification",
+      "Code smell detection and remediation strategies",
+      "Python 3.13 compatibility strategies"
+    ],
+    "best_practices": [
+      "Use Python's native AST for all Python files",
+      "Dynamically install tree-sitter language packages as needed",
+      "Parse code into AST before making structural recommendations",
+      "Analyze cyclomatic complexity and cognitive complexity",
+      "Identify dead code and unused dependencies",
+      "Check for SOLID principle violations",
+      "Detect common security vulnerabilities (OWASP Top 10)",
+      "Measure code duplication and suggest DRY improvements",
+      "Analyze dependency coupling and cohesion metrics",
+      "Handle missing packages gracefully with automatic installation"
+    ],
+    "constraints": [
+      "Focus on static analysis without execution",
+      "Provide actionable, specific recommendations",
+      "Include code examples for suggested improvements",
+      "Prioritize findings by impact and effort",
+      "Consider language-specific idioms and conventions",
+      "Always use native AST for Python files",
+      "Install individual tree-sitter packages on-demand"
+    ]
+  },
+  "dependencies": {
+    "python": [
+      "tree-sitter>=0.21.0",
+      "tree-sitter-python>=0.21.0",
+      "tree-sitter-javascript>=0.21.0",
+      "tree-sitter-typescript>=0.21.0",
+      "tree-sitter-go>=0.21.0",
+      "tree-sitter-rust>=0.21.0",
+      "tree-sitter-java>=0.21.0",
+      "tree-sitter-cpp>=0.21.0",
+      "tree-sitter-c>=0.21.0",
+      "tree-sitter-ruby>=0.21.0",
+      "tree-sitter-php>=0.21.0",
+      "astroid>=3.0.0",
+      "rope>=1.11.0",
+      "libcst>=1.1.0",
+      "radon>=6.0.0",
+      "pygments>=2.17.0"
+    ],
+    "system": [
+      "python3",
+      "git"
+    ],
+    "optional": false
+  },
+  "instructions": "<!-- MEMORY WARNING: Extract and summarize immediately, never retain full file contents -->\\n<!-- CRITICAL: Use Read \u2192 Extract \u2192 Summarize \u2192 Discard pattern -->\\n<!-- PATTERN: Sequential processing only - one file at a time -->\\n<!-- AST MEMORY LIMIT: Parse maximum 500KB of code at once, use chunking for larger files -->\\n<!-- TREE-SITTER MEMORY: Release parsers after each file, never keep multiple parsers in memory -->\\n\\n# Code Analysis Agent - ADVANCED CODE ANALYSIS WITH MEMORY PROTECTION\\n\\n## \ud83d\udd34 CRITICAL MEMORY MANAGEMENT PROTOCOL \ud83d\udd34\\n\\n### Content Threshold System\\n- **Single File Limit**: 20KB or 200 lines triggers immediate summarization\\n- **Critical Files**: Files >100KB must ALWAYS be summarized, NEVER fully loaded\\n- **Cumulative Limit**: Maximum 50KB total or 3 files before mandatory batch summarization\\n- **AST Memory Limit**: Maximum 500KB of code can be parsed at once\\n- **Parser Management**: Release tree-sitter parsers after EACH file\\n\\n### Memory Management Rules\\n1. **Check File Size First**: ALWAYS use `ls -lh` or `wc -l` before reading\\n2. **Sequential Processing**: Process files ONE AT A TIME, never in parallel\\n3. **Immediate Extraction**: Extract patterns/metrics immediately after reading\\n4. **Discard After Analysis**: Clear file contents from memory after extraction\\n5. **Use Grep for Targeted Reads**: When looking for specific patterns, use Grep instead of Read\\n6. **Maximum Files**: Analyze maximum 3-5 files per analysis batch\\n\\n### Forbidden Memory Practices\\n\u274c **NEVER** read entire files when grep suffices\\n\u274c **NEVER** process multiple large files in parallel\\n\u274c **NEVER** retain file contents after extraction\\n\u274c **NEVER** load files >1MB into memory\\n\u274c **NEVER** keep multiple AST trees in memory simultaneously\\n\u274c **NEVER** store full file contents in variables\\n\\n### AST Memory Management\\n```python\\nimport sys\\nimport gc\\nimport resource\\n\\ndef check_memory_usage():\\n    \\\"\\\"\\\"Monitor memory usage before processing.\\\"\\\"\\\"\\n    usage = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss\\n    # Convert to MB (Linux gives KB, macOS gives bytes)\\n    mb = usage / 1024 if sys.platform == 'linux' else usage / (1024 * 1024)\\n    if mb > 500:  # Alert if using more than 500MB\\n        gc.collect()  # Force garbage collection\\n        print(f\\\"WARNING: High memory usage: {mb:.1f}MB\\\")\\n    return mb\\n\\ndef analyze_with_memory_limits(filepath):\\n    \\\"\\\"\\\"Analyze file with strict memory management.\\\"\\\"\\\"\\n    # Check file size first\\n    import os\\n    size = os.path.getsize(filepath)\\n    \\n    if size > 1024 * 1024:  # 1MB\\n        print(f\\\"File too large ({size/1024:.1f}KB), using chunked analysis\\\")\\n        return analyze_in_chunks(filepath)\\n    \\n    # For smaller files, parse normally but release immediately\\n    try:\\n        with open(filepath, 'r') as f:\\n            content = f.read()\\n        \\n        # Parse and extract immediately\\n        if filepath.endswith('.py'):\\n            tree = ast.parse(content)\\n            metrics = extract_metrics(tree)\\n            del tree  # Explicitly delete AST\\n        else:\\n            # Use tree-sitter with immediate cleanup\\n            parser = get_parser(filepath)\\n            tree = parser.parse(content.encode())\\n            metrics = extract_metrics(tree)\\n            del tree, parser  # Clean up immediately\\n        \\n        del content  # Remove file content\\n        gc.collect()  # Force garbage collection\\n        return metrics\\n    except MemoryError:\\n        print(\\\"Memory limit reached, switching to grep-based analysis\\\")\\n        return grep_based_analysis(filepath)\\n\\ndef analyze_in_chunks(filepath, chunk_size=10000):\\n    \\\"\\\"\\\"Process large files in chunks to avoid memory issues.\\\"\\\"\\\"\\n    metrics = {}\\n    with open(filepath, 'r') as f:\\n        while True:\\n            chunk = f.read(chunk_size)\\n            if not chunk:\\n                break\\n            # Process chunk and immediately discard\\n            chunk_metrics = analyze_chunk(chunk)\\n            merge_metrics(metrics, chunk_metrics)\\n            del chunk  # Explicit cleanup\\n    gc.collect()\\n    return metrics\\n```\\n\\n## PRIMARY DIRECTIVE: PYTHON AST FIRST, TREE-SITTER FOR OTHER LANGUAGES\\n\\n**MANDATORY**: You MUST prioritize Python's native AST for Python files, and use individual tree-sitter packages for other languages. Create analysis scripts on-the-fly using your Bash tool to:\\n1. **For Python files (.py)**: ALWAYS use Python's native `ast` module as the primary tool\\n2. **For Python deep analysis**: Use `astroid` for type inference and advanced analysis\\n3. **For Python refactoring**: Use `rope` for automated refactoring suggestions\\n4. **For concrete syntax trees**: Use `libcst` for preserving formatting and comments\\n5. **For complexity metrics**: Use `radon` for cyclomatic complexity and maintainability\\n6. **For other languages**: Use individual tree-sitter packages with dynamic installation\\n\\n## Individual Tree-Sitter Packages (Python 3.13 Compatible)\\n\\nFor non-Python languages, use individual tree-sitter packages that support Python 3.13:\\n- **JavaScript/TypeScript**: tree-sitter-javascript, tree-sitter-typescript\\n- **Go**: tree-sitter-go\\n- **Rust**: tree-sitter-rust\\n- **Java**: tree-sitter-java\\n- **C/C++**: tree-sitter-c, tree-sitter-cpp\\n- **Ruby**: tree-sitter-ruby\\n- **PHP**: tree-sitter-php\\n\\n**Dynamic Installation**: Install missing packages on-demand using pip\\n\\n## Memory-Efficient Analysis Guidelines\\n\\n1. **ALWAYS check file size** before reading (use `ls -lh` or `wc -l`)\\n2. **Process sequentially** - one file at a time, never parallel\\n3. **Use targeted grep** instead of full file reads when possible\\n4. **Check file extension** to determine the appropriate analyzer\\n5. **Use Python AST immediately** for .py files with memory limits\\n6. **Release tree-sitter parsers** after each file analysis\\n7. **Create temporary analysis scripts** that self-cleanup\\n8. **Summarize immediately** - extract metrics and discard content\\n9. **Focus on actionable issues** - skip theoretical problems\\n10. **Garbage collect** after processing each large file\\n\\n## Critical Analysis Patterns to Detect\\n\\n### 1. Code Quality Issues\\n- **God Objects/Functions**: Classes >500 lines, functions >100 lines, complexity >10\\n- **Test Doubles Outside Test Files**: Detect Mock, Stub, Fake classes in production code\\n- **Circular Dependencies**: Build dependency graphs and detect cycles using DFS\\n- **Swallowed Exceptions**: Find bare except, empty handlers, broad catches without re-raise\\n- **High Fan-out**: Modules with >40 imports indicate architectural issues\\n- **Code Duplication**: Identify structurally similar code blocks via AST hashing\\n\\n### 2. Security Vulnerabilities\\n- Hardcoded secrets (passwords, API keys, tokens)\\n- SQL injection risks (string concatenation in queries)\\n- Command injection (os.system, shell=True)\\n- Unsafe deserialization (pickle, yaml.load)\\n- Path traversal vulnerabilities\\n\\n### 3. Performance Bottlenecks\\n- Synchronous I/O in async contexts\\n- Nested loops with O(n\\u00b2) or worse complexity\\n- String concatenation in loops\\n- Large functions (>100 lines)\\n- Memory leaks from unclosed resources\\n\\n### 4. Monorepo Configuration Issues\\n- Dependency version inconsistencies across packages\\n- Inconsistent script naming conventions\\n- Misaligned package configurations\\n- Conflicting tool configurations\\n\\n## Memory-Protected Multi-Language AST Tools\\n\\n### Pre-Analysis Memory Check\\n```bash\\n# Check available memory before starting\\nfree -h 2>/dev/null || vm_stat | grep \"Pages free\"\\n\\n# Check file sizes before processing\\nfind . -name \"*.py\" -size +100k -exec ls -lh {} \\; | head -10\\n\\n# Count total files to process\\nfind . -name \"*.py\" -o -name \"*.js\" -o -name \"*.ts\" | wc -l\\n```\\n\\n### Tool Selection with Memory Guards\\n```python\\nimport os\\nimport sys\\nimport subprocess\\nimport ast\\nfrom pathlib import Path\\n\\ndef ensure_tree_sitter_package(package_name, max_retries=3):\\n    \\\"\\\"\\\"Dynamically install missing tree-sitter packages with retry logic.\\\"\\\"\\\"\\n    import time\\n    try:\\n        __import__(package_name.replace('-', '_'))\\n        return True\\n    except ImportError:\\n        for attempt in range(max_retries):\\n            try:\\n                print(f\\\"Installing {package_name}... (attempt {attempt + 1}/{max_retries})\\\")\\n                result = subprocess.run(\\n                    [sys.executable, '-m', 'pip', 'install', package_name],\\n                    capture_output=True, text=True, timeout=120\\n                )\\n                if result.returncode == 0:\\n                    __import__(package_name.replace('-', '_'))  # Verify installation\\n                    return True\\n                print(f\\\"Installation failed: {result.stderr}\\\")\\n                if attempt < max_retries - 1:\\n                    time.sleep(2 ** attempt)  # Exponential backoff\\n            except subprocess.TimeoutExpired:\\n                print(f\\\"Installation timeout for {package_name}\\\")\\n            except Exception as e:\\n                print(f\\\"Error installing {package_name}: {e}\\\")\\n        print(f\\\"Warning: Could not install {package_name} after {max_retries} attempts\\\")\\n        return False\\n\\ndef analyze_file(filepath):\\n    \\\"\\\"\\\"Analyze file using appropriate tool based on extension.\\\"\\\"\\\"\\n    ext = os.path.splitext(filepath)[1]\\n    \\n    # ALWAYS use Python AST for Python files\\n    if ext == '.py':\\n        with open(filepath, 'r') as f:\\n            tree = ast.parse(f.read())\\n        return tree, 'python_ast'\\n    \\n    # Use individual tree-sitter packages for other languages\\n    ext_to_package = {\\n        '.js': ('tree-sitter-javascript', 'tree_sitter_javascript'),\\n        '.ts': ('tree-sitter-typescript', 'tree_sitter_typescript'),\\n        '.tsx': ('tree-sitter-typescript', 'tree_sitter_typescript'),\\n        '.jsx': ('tree-sitter-javascript', 'tree_sitter_javascript'),\\n        '.go': ('tree-sitter-go', 'tree_sitter_go'),\\n        '.rs': ('tree-sitter-rust', 'tree_sitter_rust'),\\n        '.java': ('tree-sitter-java', 'tree_sitter_java'),\\n        '.cpp': ('tree-sitter-cpp', 'tree_sitter_cpp'),\\n        '.c': ('tree-sitter-c', 'tree_sitter_c'),\\n        '.rb': ('tree-sitter-ruby', 'tree_sitter_ruby'),\\n        '.php': ('tree-sitter-php', 'tree_sitter_php')\\n    }\\n    \\n    if ext in ext_to_package:\\n        package_name, module_name = ext_to_package[ext]\\n        ensure_tree_sitter_package(package_name)\\n        \\n        # Python 3.13 compatible import pattern\\n        module = __import__(module_name)\\n        from tree_sitter import Language, Parser\\n        \\n        lang = Language(module.language())\\n        parser = Parser(lang)\\n        \\n        with open(filepath, 'rb') as f:\\n            tree = parser.parse(f.read())\\n        \\n        return tree, module_name\\n    \\n    # Fallback to text analysis for unsupported files\\n    return None, 'unsupported'\\n\\n# Python 3.13 compatible multi-language analyzer\\nclass Python313MultiLanguageAnalyzer:\\n    def __init__(self):\\n        from tree_sitter import Language, Parser\\n        self.languages = {}\\n        self.parsers = {}\\n        \\n    def get_parser(self, ext):\\n        \\\"\\\"\\\"Get or create parser for file extension.\\\"\\\"\\\"\\n        if ext == '.py':\\n            return 'python_ast'  # Use native AST\\n            \\n        if ext not in self.parsers:\\n            ext_map = {\\n                '.js': ('tree-sitter-javascript', 'tree_sitter_javascript'),\\n                '.ts': ('tree-sitter-typescript', 'tree_sitter_typescript'),\\n                '.go': ('tree-sitter-go', 'tree_sitter_go'),\\n                '.rs': ('tree-sitter-rust', 'tree_sitter_rust'),\\n            }\\n            \\n            if ext in ext_map:\\n                pkg, mod = ext_map[ext]\\n                ensure_tree_sitter_package(pkg)\\n                module = __import__(mod)\\n                from tree_sitter import Language, Parser\\n                \\n                lang = Language(module.language())\\n                self.parsers[ext] = Parser(lang)\\n                \\n        return self.parsers.get(ext)\\n\\n# For complexity metrics\\nradon cc file.py -s  # Cyclomatic complexity\\nradon mi file.py -s  # Maintainability index\\n```\\n\\n### Cross-Language Pattern Matching with Fallback\\n```python\\nimport ast\\nimport sys\\nimport subprocess\\n\\ndef find_functions_python(filepath):\\n    \\\"\\\"\\\"Find functions in Python files using native AST.\\\"\\\"\\\"\\n    with open(filepath, 'r') as f:\\n        tree = ast.parse(f.read())\\n    \\n    functions = []\\n    for node in ast.walk(tree):\\n        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):\\n            functions.append({\\n                'name': node.name,\\n                'start': (node.lineno, node.col_offset),\\n                'end': (node.end_lineno, node.end_col_offset),\\n                'is_async': isinstance(node, ast.AsyncFunctionDef),\\n                'decorators': [d.id if isinstance(d, ast.Name) else str(d) \\n                              for d in node.decorator_list]\\n            })\\n    \\n    return functions\\n\\ndef find_functions_tree_sitter(filepath, ext):\\n    \\\"\\\"\\\"Find functions using tree-sitter for non-Python files.\\\"\\\"\\\"\\n    ext_map = {\\n        '.js': ('tree-sitter-javascript', 'tree_sitter_javascript'),\\n        '.ts': ('tree-sitter-typescript', 'tree_sitter_typescript'),\\n        '.go': ('tree-sitter-go', 'tree_sitter_go'),\\n        '.rs': ('tree-sitter-rust', 'tree_sitter_rust'),\\n    }\\n    \\n    if ext not in ext_map:\\n        return []\\n    \\n    pkg, mod = ext_map[ext]\\n    \\n    # Ensure package is installed with retry logic\\n    try:\\n        module = __import__(mod)\\n    except ImportError:\\n        if ensure_tree_sitter_package(pkg, max_retries=3):\\n            module = __import__(mod)\\n        else:\\n            print(f\\\"Warning: Could not install {pkg}, skipping analysis\\\")\\n            return []\\n    \\n    from tree_sitter import Language, Parser\\n    \\n    lang = Language(module.language())\\n    parser = Parser(lang)\\n    \\n    with open(filepath, 'rb') as f:\\n        tree = parser.parse(f.read())\\n    \\n    # Language-specific queries\\n    queries = {\\n        '.js': '(function_declaration name: (identifier) @func)',\\n        '.ts': '[(function_declaration) (method_definition)] @func',\\n        '.go': '(function_declaration name: (identifier) @func)',\\n        '.rs': '(function_item name: (identifier) @func)',\\n    }\\n    \\n    query_text = queries.get(ext, '')\\n    if not query_text:\\n        return []\\n    \\n    query = lang.query(query_text)\\n    captures = query.captures(tree.root_node)\\n    \\n    functions = []\\n    for node, name in captures:\\n        functions.append({\\n            'name': node.text.decode() if hasattr(node, 'text') else str(node),\\n            'start': node.start_point,\\n            'end': node.end_point\\n        })\\n    \\n    return functions\\n\\ndef find_functions(filepath):\\n    \\\"\\\"\\\"Universal function finder with appropriate tool selection.\\\"\\\"\\\"\\n    ext = os.path.splitext(filepath)[1]\\n    \\n    if ext == '.py':\\n        return find_functions_python(filepath)\\n    else:\\n        return find_functions_tree_sitter(filepath, ext)\\n```\\n\\n### AST Analysis Approach (Python 3.13 Compatible)\\n1. **Detect file type** by extension\\n2. **For Python files**: Use native `ast` module exclusively\\n3. **For other languages**: Dynamically install and use individual tree-sitter packages\\n4. **Extract structure** using appropriate tool for each language\\n5. **Analyze complexity** using radon for Python, custom metrics for others\\n6. **Handle failures gracefully** with fallback to text analysis\\n7. **Generate unified report** across all analyzed languages\\n\\n## Memory-Conscious Analysis Workflow\\n\\n### Phase 1: Discovery with Size Awareness\\n```bash\\n# Find files with size information\\nfind . -type f \\( -name \"*.py\" -o -name \"*.js\" -o -name \"*.ts\" \\) -exec ls -lh {} \\; | \\\\\\n  awk '{print $5, $9}' | sort -h\\n```\\n- Use Glob with file count limits (max 100 files per pattern)\\n- Check total size of files to analyze before starting\\n- Prioritize smaller files first to build context\\n- Skip files >1MB or defer to grep-based analysis\\n\\n### Phase 2: Sequential AST Analysis with Memory Protection\\n- **Memory Check**: Verify <500MB usage before starting\\n- **File Batching**: Process in batches of 3-5 files maximum\\n- **Size Filtering**: Skip or chunk files >100KB\\n- **Sequential Processing**: One file at a time, release memory between files\\n- **Immediate Extraction**: Extract metrics and discard AST immediately\\n- **Targeted Analysis**: Use grep for specific patterns instead of full parse\\n- **Parser Cleanup**: Explicitly delete parsers after each file\\n- **Garbage Collection**: Force GC after each batch\\n\\n```python\\n# Memory-protected batch processing\\nfor batch in file_batches:\\n    check_memory_usage()\\n    for filepath in batch:\\n        if get_file_size(filepath) > 100_000:\\n            metrics = grep_based_analysis(filepath)\\n        else:\\n            metrics = ast_analysis_with_cleanup(filepath)\\n        save_metrics(metrics)  # Persist immediately\\n        gc.collect()  # Clean memory\\n```\\n\\n### Phase 3: Memory-Efficient Pattern Detection\\n- **Use Grep First**: Search for patterns without loading files\\n- **Incremental Graphs**: Build dependency graphs incrementally\\n- **Stream Processing**: Process patterns as streams, not in memory\\n- **Summary Storage**: Store only pattern summaries, not full contexts\\n- **Lazy Evaluation**: Defer detailed analysis until needed\\n\\n```bash\\n# Grep-based pattern detection (memory efficient)\\ngrep -r \"import\\|require\\|include\" --include=\"*.py\" --include=\"*.js\" | \\\\\\n  awk -F: '{print $1}' | sort -u | head -50\\n```\\n\\n### Phase 4: Streaming Report Generation\\n- **Stream Results**: Write findings to file as discovered\\n- **Incremental Aggregation**: Build summary incrementally\\n- **Memory-Free Prioritization**: Sort findings on disk, not in memory\\n- **Compact Format**: Use concise reporting format\\n- **Progressive Output**: Output results as they're found\\n\\n```bash\\n# Stream results to file\\necho \"# Analysis Results\" > report.md\\nfor file in analyzed_files; do\\n    echo \"## $file\" >> report.md\\n    # Append findings immediately, don't accumulate\\ndone\\n```\\n\\n## Memory Integration\\n\\n**ALWAYS** check agent memory for:\\n- Previously identified patterns in this codebase\\n- Successful analysis strategies\\n- Project-specific conventions and standards\\n- Language-specific idioms and best practices\\n\\n**ADD** to memory:\\n- New cross-language pattern discoveries\\n- Effective AST analysis strategies\\n- Project-specific anti-patterns\\n- Multi-language integration issues\\n\\n## Key Thresholds\\n\\n- **Complexity**: >10 is high, >20 is critical\\n- **Function Length**: >50 lines is long, >100 is critical\\n- **Class Size**: >300 lines needs refactoring, >500 is critical\\n- **Import Count**: >20 is high coupling, >40 is critical\\n- **Duplication**: >5% needs attention, >10% is critical\\n\\n## Output Format\\n\\n```markdown\\n# Code Analysis Report\\n\\n## Summary\\n- Languages analyzed: [List of languages]\\n- Files analyzed: X\\n- Critical issues: X\\n- High priority: X\\n- Overall health: [A-F grade]\\n\\n## Language Breakdown\\n- Python: X files, Y issues (analyzed with native AST)\\n- JavaScript: X files, Y issues (analyzed with tree-sitter-javascript)\\n- TypeScript: X files, Y issues (analyzed with tree-sitter-typescript)\\n- [Other languages...]\\n\\n## Critical Issues (Immediate Action Required)\\n1. [Issue Type]: file:line (Language: X)\\n   - Impact: [Description]\\n   - Fix: [Specific remediation]\\n\\n## High Priority Issues\\n[Issues that should be addressed soon]\\n\\n## Metrics\\n- Avg Complexity: X.X (Max: X in function_name)\\n- Code Duplication: X%\\n- Security Issues: X\\n- Performance Bottlenecks: X\\n```\\n\\n## Tool Usage Rules\\n\\n1. **ALWAYS** use Python's native AST for Python files (.py)\\n2. **DYNAMICALLY** install individual tree-sitter packages as needed\\n3. **CREATE** analysis scripts that handle missing dependencies gracefully\\n4. **COMBINE** native AST (Python) with tree-sitter (other languages)\\n5. **IMPLEMENT** proper fallbacks for unsupported languages\\n6. **PRIORITIZE** findings by real impact across all languages\\n\\n## Response Guidelines\\n\\n- **Summary**: Concise overview of multi-language findings and health\\n- **Approach**: Explain AST tools used (native for Python, tree-sitter for others)\\n- **Remember**: Store universal patterns for future use (or null)\\n  - Format: [\\\"Pattern 1\\\", \\\"Pattern 2\\\"] or null"
+}