# CodeBase Optimizer MCP Tool

A sophisticated Model Context Protocol (MCP) server that provides comprehensive codebase analysis, optimization, and duplicate detection capabilities for Claude Code.

## Features

🔍 **Comprehensive Analysis**
- Project structure and architecture detection
- Cross-language code duplication detection  
- Microservices architecture validation
- Configuration optimization analysis
- Security and performance insights

🤖 **AI-Powered Learning**
- Pattern recognition that improves with each use
- Project-specific recommendations
- Historical analysis tracking
- Custom rule learning

🚀 **Zero Setup Required**
- Integrates directly with Claude Code
- No additional installations needed
- Works with any programming language
- Portable across all projects

## Available Tools

### Individual Analysis Functions

1. **`analyze_project_structure`** - Analyze project organization and architecture
2. **`detect_code_duplicates`** - Find duplicate code across multiple languages
3. **`validate_microservices_architecture`** - Validate microservices patterns
4. **`optimize_configurations`** - Analyze configuration management
5. **`generate_improvement_report`** - Generate comprehensive actionable report

### Master Orchestrator Function

6. **`run_complete_project_analysis`** - 🎯 **ONE-COMMAND COMPLETE ANALYSIS**
   - Runs all analyses in optimal order
   - Provides prioritized action plan
   - Generates health score and improvement roadmap

## Installation & Setup

### 1. Install Dependencies

```bash
pip install mcp sqlite3
```

### 2. Add to Claude Code MCP Configuration

Add this to your Claude Code MCP configuration:

```json
{
  "mcpServers": {
    "codebase-optimizer": {
      "command": "python",
      "args": ["/Users/liadgez/Documents/codebase-optimizer-mcp/server.py"],
      "env": {
        "PYTHONPATH": "/Users/liadgez/Documents/codebase-optimizer-mcp"
      }
    }
  }
}
```

### 3. Restart Claude Code

The tool will be automatically available in all Claude Code sessions.

## Usage Examples

### Quick Project Health Check
```
Use run_complete_project_analysis with path "/path/to/your/project"
```

### Focused Duplicate Detection
```
Use detect_code_duplicates with path "/path/to/project" and languages ["python", "javascript"]
```

### Microservices Validation
```
Use validate_microservices_architecture with path "/path/to/microservices/project"
```

### Comprehensive Report
```
Use generate_improvement_report with path "/path/to/project"
```

## Output Examples

### Health Score Dashboard
```
Health Score: 87/100
- Organization Score: 0.9/1.0
- Duplication: 3.2%
- Security Score: 0.95/1.0
```

### Prioritized Recommendations
```
🔴 HIGH: Address security issues in configuration files
🟡 MEDIUM: Consolidate 12 duplicate functions into shared modules  
🟢 LOW: Standardize naming conventions across directories
```

### Action Plan
```
Phase 1: Critical Issues (1-2 days)
- Fix environment variable exposure
- Remove hardcoded secrets

Phase 2: Improvements (3-5 days)  
- Refactor duplicate code blocks
- Standardize API error handling
```

## Supported Languages

- Python (.py)
- JavaScript (.js)
- TypeScript (.ts)
- Java (.java)
- Go (.go)
- Rust (.rs)
- C/C++ (.c, .cpp)
- PHP (.php)
- Ruby (.rb)

## Learning & Improvement

The tool automatically:
- Learns patterns from each project analyzed
- Builds knowledge database of common issues
- Improves recommendations based on past successes
- Adapts to your specific coding patterns

## Troubleshooting

### Common Issues

**Tool not appearing in Claude Code:**
- Verify MCP configuration path is correct
- Restart Claude Code after adding configuration
- Check Python dependencies are installed

**Analysis fails:**
- Ensure project path exists and is accessible
- Check that Python can read the project directory
- Verify no permission issues on the project folder

**Performance issues:**
- Large projects (>10k files) may take longer to analyze
- Use "quick" depth for faster analysis on huge codebases
- Pattern database improves performance over time

## Technical Details

### Architecture
- **Engine**: Sophisticated analysis engine with ML pattern recognition
- **Database**: SQLite for pattern learning and improvement tracking  
- **MCP Server**: Standards-compliant Model Context Protocol implementation
- **Extensibility**: Plugin system for custom analyzers

### Data Storage
- Pattern database stored in `codebase_patterns.db`
- No sensitive data stored - only patterns and metrics
- Database grows smarter with each project analyzed

## Contributing

To extend the tool:

1. Add new analyzers to `codebase_optimizer_engine.py`
2. Expose new functions in `server.py`  
3. Update tool schema for new parameters
4. Test with various project types

## License

MIT License - Feel free to use and modify for your projects.

---

**Made with ❤️ for better codebases everywhere**