feat: poc for code complexity analyser

.gitignore

@@ -0,0 +1,50 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+env/
+ENV/
+.venv
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Gradio
+gradio_cached_examples/
+flagged/

.python-version

@@ -0,0 +1 @@
+3.13

README.md

@@ -11,4 +11,97 @@ license: mit
 short_description: An MCP Server to analyse Python code complexity
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Code Complexity Analyzer MCP Server
+
+**Category**: Enterprise MCP Server
+**Tags**: `building-mcp-track-enterprise`
+
+## Overview
+
+An MCP server that analyzes Python code complexity and provides actionable insights about code quality, maintainability, and potential refactoring opportunities.
+
+## Features
+
+### 1. Cyclomatic Complexity Analysis
+- Calculates cyclomatic complexity metric
+- Provides complexity level assessment (Low/Moderate/High/Critical)
+- Offers specific refactoring recommendations
+
+### 2. Code Metrics
+- Lines of Code (LOC)
+- Source Lines of Code (SLOC)
+- Comment lines and ratio
+- Function and class counts
+- Comment-to-code ratio analysis
+
+### 3. Code Smell Detection
+- Long functions (>50 lines)
+- Too many parameters (>5)
+- Deep nesting (>4 levels)
+- Duplicate code detection
+
+### 4. Comprehensive Analysis
+- Combined report with all metrics
+- Markdown-formatted output
+- Clear recommendations
+
+## Installation
+
+```bash
+pip install "gradio[mcp]"
+```
+
+## Usage
+
+### Running the MCP Server
+
+```bash
+python server.py
+```
+
+The server will start on `http://0.0.0.0:7860` with MCP protocol enabled.
+
+### MCP Tools Available
+
+1. `full_code_analysis` - Complete code analysis with all metrics
+2. `calculate_cyclomatic_complexity` - Complexity calculation only
+3. `analyze_code_metrics` - Code metrics only
+4. `detect_code_smells` - Code smell detection only
+
+### Example Usage
+
+```python
+# Example code to analyze
+code = """
+def complex_function(a, b, c, d, e, f):
+    if a > 0:
+        if b > 0:
+            if c > 0:
+                if d > 0:
+                    if e > 0:
+                        return a + b + c + d + e + f
+    return 0
+"""
+```
+
+## Why This Matters
+
+- **For Teams**: Maintain code quality standards across projects
+- **For Developers**: Get immediate feedback on code complexity
+- **For Code Reviews**: Automated complexity assessment
+- **For Legacy Code**: Identify refactoring priorities
+
+## Technical Details
+
+- Built with Gradio MCP server capabilities
+- AST-based Python code analysis
+- Real-time complexity calculation
+- No external dependencies for analysis
+
+## Future Enhancements
+
+- Support for more programming languages
+- Integration with CI/CD pipelines
+- Historical complexity tracking
+- Custom complexity thresholds
+- Team-wide analytics dashboard

app.py

@@ -0,0 +1,271 @@
+"""
+Code Complexity Analyzer MCP Server
+
+This MCP server analyzes Python code complexity and provides insights
+about code quality, maintainability, and potential refactoring opportunities.
+
+Tags: building-mcp-track-enterprise
+"""
+
+import ast
+import re
+from typing import Dict, List, Tuple
+import gradio as gr
+
+
+def calculate_cyclomatic_complexity(code: str) -> Dict[str, any]:
+    """
+    Calculate cyclomatic complexity of Python code.
+
+    Args:
+        code: Python source code as a string
+
+    Returns:
+        Dictionary with complexity metrics
+    """
+    try:
+        tree = ast.parse(code)
+    except SyntaxError as e:
+        return {"error": f"Syntax error in code: {str(e)}"}
+
+    complexity = 1  # Base complexity
+
+    # Count decision points that increase complexity
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.If, ast.While, ast.For, ast.ExceptHandler)):
+            complexity += 1
+        elif isinstance(node, ast.BoolOp):
+            complexity += len(node.values) - 1
+        elif isinstance(node, (ast.ListComp, ast.DictComp, ast.SetComp, ast.GeneratorExp)):
+            complexity += 1
+
+    # Determine complexity level
+    if complexity <= 10:
+        level = "Low (Simple)"
+        recommendation = "Code is easy to understand and maintain."
+    elif complexity <= 20:
+        level = "Moderate"
+        recommendation = "Consider breaking into smaller functions."
+    elif complexity <= 50:
+        level = "High"
+        recommendation = "Refactoring strongly recommended. Break into smaller, focused functions."
+    else:
+        level = "Very High (Critical)"
+        recommendation = "Immediate refactoring required. Code is difficult to test and maintain."
+
+    return {
+        "cyclomatic_complexity": complexity,
+        "complexity_level": level,
+        "recommendation": recommendation
+    }
+
+
+def analyze_code_metrics(code: str) -> Dict[str, any]:
+    """
+    Analyze various code metrics including LOC, functions, classes, etc.
+
+    Args:
+        code: Python source code as a string
+
+    Returns:
+        Dictionary with code metrics
+    """
+    try:
+        tree = ast.parse(code)
+    except SyntaxError as e:
+        return {"error": f"Syntax error in code: {str(e)}"}
+
+    lines = code.split('\n')
+    loc = len(lines)
+
+    # Count non-empty, non-comment lines
+    sloc = sum(1 for line in lines if line.strip() and not line.strip().startswith('#'))
+
+    # Count comments
+    comments = sum(1 for line in lines if line.strip().startswith('#'))
+
+    # Count functions and classes
+    functions = sum(1 for node in ast.walk(tree) if isinstance(node, ast.FunctionDef))
+    classes = sum(1 for node in ast.walk(tree) if isinstance(node, ast.ClassDef))
+
+    # Calculate comment ratio
+    comment_ratio = (comments / sloc * 100) if sloc > 0 else 0
+
+    return {
+        "lines_of_code": loc,
+        "source_lines_of_code": sloc,
+        "comment_lines": comments,
+        "comment_ratio_percent": round(comment_ratio, 2),
+        "functions": functions,
+        "classes": classes
+    }
+
+
+def detect_code_smells(code: str) -> List[str]:
+    """
+    Detect common code smells in Python code.
+
+    Args:
+        code: Python source code as a string
+
+    Returns:
+        List of detected code smells
+    """
+    smells = []
+
+    try:
+        tree = ast.parse(code)
+    except SyntaxError:
+        return ["Syntax error prevents analysis"]
+
+    # Check for long functions (>50 lines)
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            if hasattr(node, 'end_lineno') and hasattr(node, 'lineno'):
+                func_lines = node.end_lineno - node.lineno
+                if func_lines > 50:
+                    smells.append(f"Long function '{node.name}' ({func_lines} lines)")
+
+        # Check for too many parameters
+        if isinstance(node, ast.FunctionDef):
+            param_count = len(node.args.args)
+            if param_count > 5:
+                smells.append(f"Function '{node.name}' has too many parameters ({param_count})")
+
+        # Check for deeply nested code (>4 levels)
+        if isinstance(node, (ast.If, ast.For, ast.While)):
+            depth = sum(1 for parent in ast.walk(tree)
+                       if isinstance(parent, (ast.If, ast.For, ast.While)))
+            if depth > 4:
+                smells.append("Deeply nested code blocks detected")
+                break
+
+    # Check for duplicate code patterns (simple check)
+    lines = [line.strip() for line in code.split('\n') if line.strip()]
+    if len(lines) != len(set(lines)):
+        duplicate_count = len(lines) - len(set(lines))
+        if duplicate_count > 3:
+            smells.append(f"Possible duplicate code: {duplicate_count} duplicate lines")
+
+    if not smells:
+        smells.append("No obvious code smells detected!")
+
+    return smells
+
+
+def full_code_analysis(code: str) -> str:
+    """
+    Perform complete code analysis combining all metrics.
+
+    Args:
+        code: Python source code as a string
+
+    Returns:
+        Formatted analysis report
+    """
+    if not code.strip():
+        return "Please provide Python code to analyze."
+
+    complexity = calculate_cyclomatic_complexity(code)
+    metrics = analyze_code_metrics(code)
+    smells = detect_code_smells(code)
+
+    # Build report
+    report = "# Code Analysis Report\n\n"
+
+    # Complexity section
+    report += "## Complexity Analysis\n"
+    if "error" in complexity:
+        report += f"Error: {complexity['error']}\n\n"
+    else:
+        report += f"- **Cyclomatic Complexity**: {complexity['cyclomatic_complexity']}\n"
+        report += f"- **Complexity Level**: {complexity['complexity_level']}\n"
+        report += f"- **Recommendation**: {complexity['recommendation']}\n\n"
+
+    # Metrics section
+    report += "## Code Metrics\n"
+    if "error" in metrics:
+        report += f"Error: {metrics['error']}\n\n"
+    else:
+        report += f"- **Total Lines**: {metrics['lines_of_code']}\n"
+        report += f"- **Source Lines**: {metrics['source_lines_of_code']}\n"
+        report += f"- **Comment Lines**: {metrics['comment_lines']}\n"
+        report += f"- **Comment Ratio**: {metrics['comment_ratio_percent']}%\n"
+        report += f"- **Functions**: {metrics['functions']}\n"
+        report += f"- **Classes**: {metrics['classes']}\n\n"
+
+    # Code smells section
+    report += "## Code Smells Detected\n"
+    for smell in smells:
+        report += f"- {smell}\n"
+
+    return report
+
+
+# Create Gradio interface
+with gr.Blocks(title="Code Complexity Analyzer MCP Server") as demo:
+    gr.Markdown("""
+    # Code Complexity Analyzer MCP Server
+
+    Analyze Python code complexity and quality metrics. This MCP server provides:
+    - Cyclomatic complexity calculation
+    - Code metrics (LOC, comments, functions, classes)
+    - Code smell detection
+    - Refactoring recommendations
+
+    **Category**: Enterprise MCP Server
+    **Tags**: building-mcp-track-enterprise
+    """)
+
+    with gr.Tab("Full Analysis"):
+        code_input = gr.Code(
+            label="Python Code",
+            language="python",
+            lines=20,
+            value="# Paste your Python code here\ndef example():\n    pass"
+        )
+        analyze_btn = gr.Button("Analyze Code", variant="primary")
+        analysis_output = gr.Markdown(label="Analysis Report")
+
+        analyze_btn.click(
+            fn=full_code_analysis,
+            inputs=code_input,
+            outputs=analysis_output
+        )
+
+    with gr.Tab("Complexity Only"):
+        complexity_input = gr.Code(label="Python Code", language="python", lines=15)
+        complexity_btn = gr.Button("Calculate Complexity")
+        complexity_output = gr.JSON(label="Complexity Metrics")
+
+        complexity_btn.click(
+            fn=calculate_cyclomatic_complexity,
+            inputs=complexity_input,
+            outputs=complexity_output
+        )
+
+    with gr.Tab("Code Metrics"):
+        metrics_input = gr.Code(label="Python Code", language="python", lines=15)
+        metrics_btn = gr.Button("Analyze Metrics")
+        metrics_output = gr.JSON(label="Code Metrics")
+
+        metrics_btn.click(
+            fn=analyze_code_metrics,
+            inputs=metrics_input,
+            outputs=metrics_output
+        )
+
+    with gr.Tab("Code Smells"):
+        smells_input = gr.Code(label="Python Code", language="python", lines=15)
+        smells_btn = gr.Button("Detect Code Smells")
+        smells_output = gr.JSON(label="Detected Code Smells")
+
+        smells_btn.click(
+            fn=detect_code_smells,
+            inputs=smells_input,
+            outputs=smells_output
+        )
+
+
+if __name__ == "__main__":
+    demo.launch(mcp_server=True, server_name="0.0.0.0", server_port=7860)

pyproject.toml

@@ -0,0 +1,9 @@
+[project]
+name = "code-complexity-analyzer"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "gradio[mcp]>=5.49.1",
+]