mcp-server-analyzer 0.1.0__py3-none-any.whl

mcp_python_analyzer/__init__.py

@@ -0,0 +1,7 @@
+"""MCP Python Analyzer - A Model Context Protocol server for Python code analysis."""
+
+__version__ = "0.1.0"
+__author__ = "MCP Python Analyzer Team"
+__email__ = "contact@example.com"
+
+__all__ = ["__author__", "__email__", "__version__"]

mcp_python_analyzer/__main__.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python3
+"""Main entry point for the MCP Python Analyzer server."""
+
+from mcp_python_analyzer.server import main
+
+if __name__ == "__main__":
+    main()

mcp_python_analyzer/analyzers/__init__.py

@@ -0,0 +1,6 @@
+"""Analyzers package for RUFF and VULTURE integration."""
+
+from .ruff import RuffAnalyzer
+from .vulture import VultureAnalyzer
+
+__all__ = ["RuffAnalyzer", "VultureAnalyzer"]

mcp_python_analyzer/analyzers/ruff.py

@@ -0,0 +1,188 @@
+"""RUFF integration for Python code linting and formatting."""
+
+import json
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Any
+
+from mcp_python_analyzer.models import RuffCheckResult, RuffFormatResult, RuffIssue
+
+
+class RuffAnalyzer:
+    """Handles RUFF-based Python code analysis."""
+
+    def __init__(self) -> None:
+        """Initialize the RUFF analyzer."""
+        self._check_ruff_installation()
+
+    def _check_ruff_installation(self) -> None:
+        """Verify that RUFF is installed and accessible."""
+        try:
+            result = subprocess.run(
+                ["ruff", "--version"],
+                capture_output=True,
+                text=True,
+                check=True,
+                timeout=10,
+            )
+            if result.returncode != 0:
+                raise RuntimeError("RUFF is not properly installed")
+        except (subprocess.CalledProcessError, FileNotFoundError) as e:
+            raise RuntimeError(f"RUFF is not available: {e}") from e
+
+    def check_code(self, code: str, config_path: str | None = None) -> RuffCheckResult:
+        """
+        Run RUFF linter on the provided code.
+
+        Args:
+            code: Python code to lint
+            config_path: Optional path to RUFF configuration file
+
+        Returns:
+            RuffCheckResult containing linting issues
+        """
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write(code)
+            temp_file = Path(f.name)
+
+        try:
+            cmd = ["ruff", "check", "--output-format=json", str(temp_file)]
+            if config_path:
+                cmd.extend(["--config", config_path])
+
+            result = subprocess.run(
+                cmd, capture_output=True, text=True, timeout=30, check=False
+            )
+
+            # RUFF returns non-zero exit code when issues are found
+            if result.returncode not in (0, 1):
+                raise RuntimeError(f"RUFF check failed: {result.stderr}")
+
+            issues: list[RuffIssue] = []
+            if result.stdout.strip():
+                try:
+                    ruff_output = json.loads(result.stdout)
+                    for item in ruff_output:
+                        end_location: dict[str, int] = item.get("end_location") or {}
+                        fix_info: dict[str, Any] = item.get("fix") or {}
+                        issue = RuffIssue(
+                            line=item["location"]["row"],
+                            column=item["location"]["column"],
+                            end_line=end_location.get("row"),
+                            end_column=end_location.get("column"),
+                            rule=item["code"],
+                            message=item["message"],
+                            severity=self._get_severity(item["code"]),
+                            fixable=fix_info.get("applicability") == "safe",
+                        )
+                        issues.append(issue)
+                except json.JSONDecodeError as e:
+                    raise RuntimeError(f"Failed to parse RUFF output: {e}") from e
+
+            return RuffCheckResult(
+                issues=issues,
+                total_issues=len(issues),
+                fixable_issues=sum(1 for issue in issues if issue.fixable),
+            )
+
+        finally:
+            temp_file.unlink()
+
+    def check_code_for_ci(
+        self, code: str, output_format: str = "json", config_path: str | None = None
+    ) -> str:
+        """
+        Run RUFF linter with specific output format for CI/CD systems.
+
+        Args:
+            code: Python code to lint
+            output_format: Output format (json, gitlab, github, sarif)
+            config_path: Optional path to RUFF configuration file
+
+        Returns:
+            Raw RUFF output in specified format
+        """
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write(code)
+            temp_file = Path(f.name)
+
+        try:
+            cmd = ["ruff", "check", f"--output-format={output_format}", str(temp_file)]
+            if config_path:
+                cmd.extend(["--config", config_path])
+
+            result = subprocess.run(
+                cmd, capture_output=True, text=True, timeout=30, check=False
+            )
+
+            # RUFF returns non-zero exit code when issues are found
+            if result.returncode not in (0, 1):
+                raise RuntimeError(f"RUFF check failed: {result.stderr}")
+
+            return result.stdout
+
+        finally:
+            temp_file.unlink()
+
+    def format_code(
+        self, code: str, config_path: str | None = None
+    ) -> RuffFormatResult:
+        """
+        Format Python code using RUFF formatter.
+
+        Args:
+            code: Python code to format
+            config_path: Optional path to RUFF configuration file
+
+        Returns:
+            RuffFormatResult containing formatted code
+        """
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write(code)
+            temp_file = Path(f.name)
+
+        try:
+            cmd = ["ruff", "format", "--stdin-filename", str(temp_file)]
+            if config_path:
+                cmd.extend(["--config", config_path])
+
+            result = subprocess.run(
+                cmd, input=code, capture_output=True, text=True, timeout=30, check=False
+            )
+
+            if result.returncode != 0:
+                raise RuntimeError(f"RUFF format failed: {result.stderr}")
+
+            formatted_code = result.stdout
+            changed = formatted_code != code
+
+            return RuffFormatResult(
+                formatted_code=formatted_code,
+                changed=changed,
+            )
+
+        finally:
+            temp_file.unlink()
+
+    def _get_severity(self, rule_code: str) -> str:
+        """
+        Determine severity level based on RUFF rule code.
+
+        Args:
+            rule_code: RUFF rule code (e.g., F401, E302)
+
+        Returns:
+            Severity level string
+        """
+        # Map RUFF rule prefixes to severity levels
+        if rule_code.startswith(("F", "E9")):
+            return "error"
+        elif rule_code.startswith(("W", "E", "C90", "N", "B", "A", "C4")):  # noqa: RET505
+            return "warning"
+        elif rule_code.startswith(
+            ("I", "UP", "PIE", "T20", "PT", "RET", "SIM", "TID", "ARG", "PL", "RUF")
+        ):
+            return "info"
+        else:
+            return "warning"

mcp_python_analyzer/analyzers/vulture.py

@@ -0,0 +1,194 @@
+"""VULTURE integration for Python dead code detection."""
+
+import re
+import subprocess
+import tempfile
+from pathlib import Path
+
+from mcp_python_analyzer.models import VultureItem, VultureScanResult
+
+
+class VultureAnalyzer:
+    """Handles VULTURE-based dead code detection."""
+
+    def __init__(self) -> None:
+        """Initialize the VULTURE analyzer."""
+        self._check_vulture_installation()
+
+    def _check_vulture_installation(self) -> None:
+        """Verify that VULTURE is installed and accessible."""
+        try:
+            result = subprocess.run(
+                ["vulture", "--version"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+                check=True,
+            )
+            if result.returncode != 0:
+                raise RuntimeError(
+                    f"VULTURE is not properly installed: {result.stderr}"
+                )
+        except (
+            subprocess.CalledProcessError,
+            FileNotFoundError,
+            subprocess.TimeoutExpired,
+        ) as e:
+            raise RuntimeError(f"VULTURE is not available: {e}") from e
+
+    def scan_code(self, code: str, min_confidence: int = 80) -> VultureScanResult:
+        """
+        Scan Python code for dead/unused code using VULTURE.
+
+        Args:
+            code: Python code to analyze
+            min_confidence: Minimum confidence level (0-100) for reporting items
+
+        Returns:
+            VultureScanResult containing unused code items
+        """
+        if not 0 <= min_confidence <= 100:  # noqa: PLR2004
+            raise ValueError("min_confidence must be between 0 and 100")
+
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write(code)
+            temp_file = Path(f.name)
+
+        try:
+            cmd = [
+                "vulture",
+                str(temp_file),
+                f"--min-confidence={min_confidence}",
+                "--sort-by-size",
+            ]
+
+            # Check if pyproject.toml exists and use it
+            pyproject_path = Path.cwd() / "pyproject.toml"
+            if pyproject_path.exists():
+                cmd.extend(["--config", str(pyproject_path)])
+
+            result = subprocess.run(
+                cmd, capture_output=True, text=True, timeout=30, check=False
+            )
+
+            # VULTURE exit codes:
+            # 0: No dead code found
+            # 1: Invalid input (file missing, syntax error, wrong encoding)
+            # 2: Invalid command line arguments
+            # 3: Dead code found
+            if result.returncode not in (0, 1, 3):
+                error_msg = (
+                    result.stderr.strip()
+                    or f"Unknown VULTURE error (exit code {result.returncode})"
+                )
+                raise RuntimeError(f"VULTURE scan failed: {error_msg}")
+
+            items = []
+            if result.stdout.strip():
+                items = self._parse_vulture_output(result.stdout, str(temp_file))
+            high_confidence_percentage = 80
+            high_confidence_count = sum(
+                1 for item in items if item.confidence >= high_confidence_percentage
+            )
+
+            return VultureScanResult(
+                unused_items=items,
+                total_items=len(items),
+                high_confidence_items=high_confidence_count,
+            )
+
+        except subprocess.TimeoutExpired:
+            raise RuntimeError("VULTURE scan timed out") from None
+        except (FileNotFoundError, PermissionError) as e:
+            raise RuntimeError(f"Failed to run VULTURE: {e}") from e
+        finally:
+            temp_file.unlink()
+
+    def _parse_vulture_output(
+        self, output: str, temp_filename: str
+    ) -> list[VultureItem]:
+        """
+        Parse VULTURE output into structured items.
+
+        Args:
+            output: Raw VULTURE output
+            temp_filename: Temporary file name to filter out from output
+
+        Returns:
+            List of VultureItem objects
+        """
+        items: list[VultureItem] = []
+        # VULTURE output format: filename:line: message (confidence%, size info)
+        pattern = (
+            r"^(.+):(\d+):\s+(.+?)\s+\((\d+)%\s+confidence(?:,\s+\d+\s+lines?)?\)$"
+        )
+
+        # Resolve the temp filename for comparison
+        temp_path_resolved = str(Path(temp_filename).resolve())
+
+        for line in output.strip().split("\n"):
+            if not line.strip():
+                continue
+
+            match = re.match(pattern, line)
+            if match:
+                filename, line_num, message, confidence = match.groups()
+
+                # Compare resolved paths to handle /private prefix on macOS
+                file_path_resolved = str(Path(filename).resolve())
+                if file_path_resolved != temp_path_resolved:
+                    continue
+
+                # Extract item name and type from message
+                item_name, item_type = self._extract_item_info(message)
+
+                item = VultureItem(
+                    name=item_name,
+                    type=item_type,
+                    line=int(line_num),
+                    column=0,  # Vulture doesn't provide column info in this format
+                    confidence=int(confidence),
+                    message=message,
+                )
+                items.append(item)
+
+        return items
+
+    def _extract_item_info(self, message: str) -> tuple[str, str]:
+        """
+        Extract item name and type from VULTURE message.
+
+        Args:
+            message: VULTURE message string
+
+        Returns:
+            Tuple of (item_name, item_type)
+        """
+        # Common VULTURE message patterns
+        patterns = [
+            (r"unused import '(.+?)'", "import"),
+            (r"unused function '(.+?)'", "function"),
+            (r"unused method '(.+?)'", "method"),
+            (r"unused class '(.+?)'", "class"),
+            (r"unused variable '(.+?)'", "variable"),
+            (r"unused attribute '(.+?)'", "attribute"),
+            (r"unused property '(.+?)'", "property"),
+            (r"unused argument '(.+?)'", "argument"),
+        ]
+
+        for pattern, item_type in patterns:
+            match = re.search(pattern, message, re.IGNORECASE)
+            if match:
+                return match.group(1), item_type
+
+        # Fallback: try to extract quoted name
+        quoted_match = re.search(r"'(.+?)'", message)
+        if quoted_match:
+            return quoted_match.group(1), "unknown"
+
+        # Last resort: use first word as name
+        words = message.split()
+        if words:
+            return words[0], "unknown"
+
+        return "unknown", "unknown"

mcp_python_analyzer/models.py

@@ -0,0 +1,72 @@
+"""Pydantic models for MCP Python Analyzer responses and configurations."""
+
+from pydantic import BaseModel, Field
+
+
+class RuffIssue(BaseModel):
+    """Represents a RUFF linting issue."""
+
+    line: int = Field(description="Line number where the issue occurs")
+    column: int = Field(description="Column number where the issue occurs")
+    end_line: int | None = Field(
+        None, description="End line number for multi-line issues"
+    )
+    end_column: int | None = Field(
+        None, description="End column number for multi-line issues"
+    )
+    rule: str = Field(description="RUFF rule code (e.g., F401, E302)")
+    message: str = Field(description="Human-readable description of the issue")
+    severity: str = Field(description="Issue severity level")
+    fixable: bool = Field(False, description="Whether the issue can be auto-fixed")
+
+
+class RuffCheckResult(BaseModel):
+    """Result of RUFF check operation."""
+
+    issues: list[RuffIssue] = Field(description="List of linting issues found")
+    total_issues: int = Field(description="Total number of issues")
+    fixable_issues: int = Field(description="Number of auto-fixable issues")
+
+
+class RuffFormatResult(BaseModel):
+    """Result of RUFF format operation."""
+
+    formatted_code: str = Field(description="The formatted Python code")
+    changed: bool = Field(description="Whether the code was modified during formatting")
+
+
+class VultureItem(BaseModel):
+    """Represents an unused code item found by VULTURE."""
+
+    name: str = Field(description="Name of the unused item")
+    type: str = Field(
+        description="Type of unused item (import, function, class, variable, etc.)"
+    )
+    line: int = Field(description="Line number where the unused item is defined")
+    column: int = Field(description="Column number where the unused item is defined")
+    confidence: int = Field(
+        description="Confidence level (0-100) that the item is unused"
+    )
+    message: str = Field(description="Description of the unused item")
+
+
+class VultureScanResult(BaseModel):
+    """Result of VULTURE scan operation."""
+
+    unused_items: list[VultureItem] = Field(
+        description="List of unused code items found"
+    )
+    total_items: int = Field(description="Total number of unused items")
+    high_confidence_items: int = Field(
+        description="Number of items with confidence >= 80"
+    )
+
+
+class AnalysisResult(BaseModel):
+    """Combined analysis result from both RUFF and VULTURE."""
+
+    ruff_result: RuffCheckResult = Field(description="RUFF linting results")
+    vulture_result: VultureScanResult = Field(
+        description="VULTURE dead code detection results"
+    )
+    summary: dict[str, int] = Field(description="Summary statistics of the analysis")

mcp_python_analyzer/server.py

@@ -0,0 +1,264 @@
+"""MCP Python Analyzer Server - Main FastMCP server implementation."""
+
+import logging
+import sys
+from typing import Any
+
+from fastmcp import FastMCP
+
+from mcp_python_analyzer.analyzers import RuffAnalyzer, VultureAnalyzer
+from mcp_python_analyzer.models import (
+    AnalysisResult,
+    RuffCheckResult,
+    VultureScanResult,
+)
+
+# Initialize logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize FastMCP server
+app: FastMCP[Any] = FastMCP("Python Analyzer")
+
+# Initialize analyzers
+ruff_analyzer = RuffAnalyzer()
+
+# Try to initialize VULTURE analyzer, but handle gracefully if it fails
+try:
+    vulture_analyzer: VultureAnalyzer | None = VultureAnalyzer()
+    vulture_available = True
+except RuntimeError as e:
+    logger.warning("VULTURE not available: %s", e)
+    vulture_analyzer = None
+    vulture_available = False
+
+
+@app.tool(name="ruff-check")
+def ruff_check(code: str, config_path: str | None = None) -> dict[str, Any]:
+    """
+    Lint Python code using RUFF to identify style violations and potential errors.
+
+    Args:
+        code: Python code to analyze
+        config_path: Optional path to RUFF configuration file
+
+    Returns:
+        Dictionary containing linting results with issues, counts, and metadata
+    """
+    try:
+        result = ruff_analyzer.check_code(code, config_path)
+        return result.model_dump()
+    except Exception as e:
+        return {
+            "error": f"RUFF check failed: {e!s}",
+            "issues": [],
+            "total_issues": 0,
+            "fixable_issues": 0,
+        }
+
+
+@app.tool(name="ruff-format")
+def ruff_format(code: str, config_path: str | None = None) -> dict[str, Any]:
+    """
+    Format Python code using RUFF's fast formatter.
+
+    Args:
+        code: Python code to format
+        config_path: Optional path to RUFF configuration file
+
+    Returns:
+        Dictionary containing formatted code and change status
+    """
+    try:
+        result = ruff_analyzer.format_code(code, config_path)
+        return result.model_dump()
+    except Exception as e:
+        return {
+            "error": f"RUFF format failed: {e!s}",
+            "formatted_code": code,  # Return original code on error
+            "changed": False,
+        }
+
+
+@app.tool(name="ruff-check-ci")
+def ruff_check_ci(
+    code: str, output_format: str = "json", config_path: str | None = None
+) -> dict[str, Any]:
+    """
+    Run RUFF linter with CI/CD-specific output formats.
+
+    Args:
+        code: Python code to lint
+        output_format: Output format (json, gitlab, github, sarif)
+        config_path: Optional path to RUFF configuration file
+
+    Returns:
+        Dictionary containing raw RUFF output in specified format
+    """
+    try:
+        result = ruff_analyzer.check_code_for_ci(code, output_format, config_path)
+        return {
+            "output": result,
+            "format": output_format,
+            "success": True,
+        }
+    except Exception as e:
+        return {
+            "error": f"RUFF CI check failed: {e!s}",
+            "output": "",
+            "format": output_format,
+            "success": False,
+        }
+
+
+@app.tool(name="vulture-scan")
+def vulture_scan(code: str, min_confidence: int = 80) -> dict[str, Any]:
+    """
+    Detect dead/unused code using VULTURE.
+
+    Args:
+        code: Python code to analyze
+        min_confidence: Minimum confidence level (0-100) for reporting items
+
+    Returns:
+        Dictionary containing unused code items with confidence scores and locations
+    """
+    if not vulture_available:
+        return {
+            "error": "VULTURE is not available - please install vulture package",
+            "unused_items": [],
+            "total_items": 0,
+            "high_confidence_items": 0,
+        }
+
+    try:
+        assert vulture_analyzer is not None  # assure the type checker
+        result = vulture_analyzer.scan_code(code, min_confidence)
+        return result.model_dump()
+    except Exception as e:
+        return {
+            "error": f"VULTURE scan failed: {e!s}",
+            "unused_items": [],
+            "total_items": 0,
+            "high_confidence_items": 0,
+        }
+
+
+@app.tool(name="analyze-code")
+def analyze_code(
+    code: str,
+    ruff_config_path: str | None = None,
+    min_confidence: int = 80,
+) -> dict[str, Any]:
+    """
+    Comprehensive analysis combining RUFF linting and VULTURE dead code detection.
+
+    Args:
+        code: Python code to analyze
+        ruff_config_path: Optional path to RUFF configuration file
+        min_confidence: Minimum confidence level for VULTURE (default: 80)
+
+    Returns:
+        Dictionary containing combined analysis results with summary statistics
+    """
+    try:
+        # Run RUFF analysis
+        ruff_result = ruff_analyzer.check_code(code, ruff_config_path)
+
+        # Run VULTURE analysis if available
+        if vulture_available:
+            assert vulture_analyzer is not None  # assure the type checker
+            vulture_result = vulture_analyzer.scan_code(code, min_confidence)
+        else:
+            # Create empty VULTURE result if not available
+            vulture_result = VultureScanResult(
+                unused_items=[],
+                total_items=0,
+                high_confidence_items=0,
+            )
+
+        # Create summary statistics
+        summary = {
+            "total_ruff_issues": ruff_result.total_issues,
+            "fixable_ruff_issues": ruff_result.fixable_issues,
+            "total_unused_items": vulture_result.total_items,
+            "high_confidence_unused": vulture_result.high_confidence_items,
+            "code_quality_score": _calculate_quality_score(ruff_result, vulture_result),
+        }
+
+        # Combine results
+        analysis = AnalysisResult(
+            ruff_result=ruff_result,
+            vulture_result=vulture_result,
+            summary=summary,
+        )
+
+        return analysis.model_dump()
+
+    except Exception as e:
+        return {
+            "error": f"Code analysis failed: {e!s}",
+            "ruff_result": {"issues": [], "total_issues": 0, "fixable_issues": 0},
+            "vulture_result": {
+                "unused_items": [],
+                "total_items": 0,
+                "high_confidence_items": 0,
+            },
+            "summary": {
+                "total_ruff_issues": 0,
+                "fixable_ruff_issues": 0,
+                "total_unused_items": 0,
+                "high_confidence_unused": 0,
+                "code_quality_score": 0,
+            },
+        }
+
+
+def _calculate_quality_score(
+    ruff_result: RuffCheckResult, vulture_result: VultureScanResult
+) -> int:
+    """
+    Calculate a simple code quality score based on analysis results.
+
+    Args:
+        ruff_result: RUFF linting results
+        vulture_result: VULTURE scanning results
+
+    Returns:
+        Quality score from 0 to 100 (higher is better)
+    """
+    # Simple scoring algorithm - can be improved
+    base_score = 100
+
+    # Deduct points for RUFF issues
+    ruff_penalty = min(ruff_result.total_issues * 2, 50)  # Max 50 points deduction
+
+    # Deduct points for high-confidence unused items
+    vulture_penalty = min(
+        vulture_result.high_confidence_items * 5, 30
+    )  # Max 30 points deduction
+
+    # Deduct points for total unused items (less severe)
+    total_unused_penalty = min(
+        (vulture_result.total_items - vulture_result.high_confidence_items) * 2, 20
+    )  # Max 20 points
+
+    # Replace temp variable with direct return
+    return max(0, base_score - ruff_penalty - vulture_penalty - total_unused_penalty)
+
+
+def main() -> None:
+    """Main entry point for the MCP server."""
+    try:
+        # Run the FastMCP server
+        app.run()
+    except KeyboardInterrupt:
+        logger.info("Server stopped by user")
+        sys.exit(0)
+    except Exception as e:
+        logger.error("Server error: %s", e)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

mcp_server_analyzer-0.1.0.dist-info/METADATA

@@ -0,0 +1,265 @@
+Metadata-Version: 2.4
+Name: mcp-server-analyzer
+Version: 0.1.0
+Summary: MCP server for Python code analysis with RUFF linting and VULTURE dead code detection
+Project-URL: Homepage, https://github.com/anselmoo/mcp-server-analyzer
+Project-URL: Documentation, https://github.com/anselmoo/mcp-server-analyzer
+Project-URL: Repository, https://github.com/anselmoo/mcp-server-analyzer
+Project-URL: Issues, https://github.com/anselmoo/mcp-server-analyzer/issues
+Author-email: Anselm Hahn <anselm.hahn@gmail.com>
+Maintainer-email: Anselm Hahn <anselm.hahn@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: code-analysis,linting,mcp,python,ruff,static-analysis,vulture
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Requires-Dist: fastmcp>=0.3.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: ruff>=0.8.0
+Requires-Dist: vulture>=2.11
+Provides-Extra: dev
+Requires-Dist: bandit>=1.7.0; extra == 'dev'
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pre-commit>=3.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.4.1; extra == 'dev'
+Requires-Dist: safety>=2.0.0; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'test'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'test'
+Requires-Dist: pytest>=8.4.1; extra == 'test'
+Description-Content-Type: text/markdown
+
+# MCP Python Analyzer Server 🐍🔍
+
+[![CI/CD Pipeline](https://github.com/anselmoo/mcp-server-analyzer/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/anselmoo/mcp-server-analyzer/actions/workflows/ci-cd.yml)
+[![PyPI version](https://badge.fury.io/py/mcp-server-analyzer.svg)](https://badge.fury.io/py/mcp-server-analyzer)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![Docker](https://img.shields.io/badge/docker-available-blue.svg)](https://github.com/anselmoo/mcp-server-analyzer/pkgs/container/mcp-server-analyzer)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Code Coverage](https://codecov.io/gh/anselmoo/mcp-server-analyzer/branch/main/graph/badge.svg)](https://codecov.io/gh/anselmoo/mcp-server-analyzer)
+
+A powerful [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) server that provides comprehensive Python code analysis using [**RUFF**](https://docs.astral.sh/ruff/) for linting and [**VULTURE**](https://github.com/jendrikseipp/vulture) for dead code detection. Perfect for AI assistants, IDEs, and automated code review workflows.
+
+## 🚀 Quick Start
+
+### VS Code Integration (One-Click Install)
+
+For quick installation, use one of the one-click install buttons below...
+
+[![Install with UV in VS Code](https://img.shields.io/badge/VS_Code-UV-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=analyzer&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22mcp-server-analyzer%22%5D%7D) [![Install with UV in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-UV-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=analyzer&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22mcp-server-analyzer%22%5D%7D&quality=insiders)
+
+[![Install with Docker in VS Code](https://img.shields.io/badge/VS_Code-Docker-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=analyzer&config=%7B%22command%22%3A%22docker%22%2C%22args%22%3A%5B%22run%22%2C%22-i%22%2C%22--rm%22%2C%22ghcr.io%2Fanselmoo%2Fmcp-server-analyzer%22%5D%7D) [![Install with Docker in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Docker-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=analyzer&config=%7B%22command%22%3A%22docker%22%2C%22args%22%3A%5B%22run%22%2C%22-i%22%2C%22--rm%22%2C%22ghcr.io%2Fanselmoo%2Fmcp-server-analyzer%22%5D%7D&quality=insiders)
+
+For manual installation, add the following JSON block to your User Settings (JSON) file in VS Code. You can do this by pressing `Ctrl + Shift + P` and typing `Preferences: Open User Settings (JSON)`.
+
+Optionally, you can add it to a file called `.vscode/mcp.json` in your workspace. This will allow you to share the configuration with others.
+
+> Note that the `mcp` key is needed when using the `mcp.json` file.
+
+**Using uvx (recommended):**
+
+```json
+{
+  "mcp": {
+    "servers": {
+      "analyzer": {
+        "command": "uvx",
+        "args": ["mcp-server-analyzer"]
+      }
+    }
+  }
+}
+```
+
+**Using Docker:**
+
+```json
+{
+  "mcp": {
+    "servers": {
+      "analyzer": {
+        "command": "docker",
+        "args": ["run", "-i", "--rm", "ghcr.io/anselmoo/mcp-server-analyzer"]
+      }
+    }
+  }
+}
+```
+
+### Universal Installation
+
+```bash
+# Install with uvx (recommended)
+uvx install mcp-server-analyzer
+
+# Install with pip
+pip install mcp-server-analyzer
+
+# Run with Docker
+docker run ghcr.io/anselmoo/mcp-server-analyzer:latest
+
+# Install from source
+git clone https://github.com/anselmoo/mcp-server-analyzer.git
+cd mcp-server-analyzer
+uv sync --dev
+uv run mcp-server-analyzer
+```
+
+## 📋 Features
+
+- **🔍 RUFF Analysis**: Comprehensive Python linting with auto-fixes
+- **🧹 Dead Code Detection**: Find unused imports, functions, and variables with VULTURE
+- **📊 Quality Scoring**: Combined analysis with quality metrics
+- **🚀 FastMCP Framework**: High-performance MCP server implementation
+- **🐳 Docker Ready**: Multi-architecture containers with security signing
+- **🔒 Secure**: All releases signed with Sigstore for supply chain security
+
+## 📈 Analysis Examples
+
+### RUFF Linting Preview
+
+See comprehensive linting analysis examples: **[📋 RUFF Analysis Preview](examples/preview-ruff.md)**
+
+### VULTURE Dead Code Detection Preview
+
+Explore dead code detection capabilities: **[🧹 VULTURE Analysis Preview](examples/preview-vulture.md)**
+
+## 🛠️ Available Tools
+
+| Tool            | Description                      | Use Case                             |
+| --------------- | -------------------------------- | ------------------------------------ |
+| `ruff-check`    | Lint Python code with RUFF       | Style violations, potential errors   |
+| `ruff-format`   | Format Python code with RUFF     | Code formatting and consistency      |
+| `ruff-check-ci` | CI/CD optimized RUFF output      | GitHub Actions, GitLab CI            |
+| `vulture-scan`  | Dead code detection              | Unused imports, functions, variables |
+| `analyze-code`  | Combined RUFF + VULTURE analysis | Complete code quality assessment     |
+
+## 🔧 Configuration
+
+### Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "analyzer": {
+      "command": "uvx",
+      "args": ["mcp-server-analyzer"]
+    }
+  }
+}
+```
+
+### Zed
+
+Add to your Zed settings.json:
+
+```json
+"context_servers": {
+  "analyzer": {
+    "command": "uvx",
+    "args": ["mcp-server-analyzer"]
+  }
+}
+```
+
+## 🧪 Development
+
+### Prerequisites
+
+- Python 3.10+
+- [uv](https://docs.astral.sh/uv/) (recommended) or pip
+- [Docker](https://docker.com) (optional)
+
+### Setup
+
+```bash
+# Clone repository
+git clone https://github.com/anselmoo/mcp-server-analyzer.git
+cd mcp-server-analyzer
+
+# Install dependencies
+uv sync --dev
+
+# Run tests
+uv run pytest
+
+# Run pre-commit hooks
+uv tool run pre-commit run --all-files
+
+# Build Docker image
+docker build -t mcp-server-analyzer .
+```
+
+### Testing
+
+```bash
+# Run all tests
+uv run pytest tests/ -v
+
+# Run with coverage
+uv run pytest --cov=src/mcp_python_analyzer --cov-report=html
+
+# Test specific functionality
+uv run pytest tests/test_server.py::TestAnalyzer::test_ruff_analysis
+```
+
+## 📊 Quality Metrics
+
+The server provides quality scoring based on:
+
+- **RUFF Issues**: Style violations, potential bugs, complexity metrics
+- **Dead Code Detection**: Unused imports, functions, variables
+- **Combined Score**: Weighted quality assessment (0-100)
+
+## 🔒 Security
+
+- **Signed Releases**: All releases signed with [Sigstore](https://sigstore.dev/)
+- **Container Signing**: Docker images signed with [Cosign](https://docs.sigstore.dev/cosign/overview/)
+- **Trusted Publishing**: PyPI releases use GitHub OIDC trusted publishing
+- **Vulnerability Scanning**: Automated security scanning in CI/CD
+- **Supply Chain Security**: SLSA Build Level 3 compliance
+
+## 📚 Documentation
+
+- **[MCP Specification](https://modelcontextprotocol.io/)** - Learn about Model Context Protocol
+- **[FastMCP Framework](https://gofastmcp.com/)** - High-performance MCP implementation
+- **[RUFF Documentation](https://docs.astral.sh/ruff/)** - Python linter and formatter
+- **[VULTURE Documentation](https://github.com/jendrikseipp/vulture)** - Dead code finder
+
+## 🤝 Contributing
+
+Contributions are welcome! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## 📝 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- [Astral](https://astral.sh/) for RUFF and uv
+- [Jendrik Seipp](https://github.com/jendrikseipp) for VULTURE
+- [Model Context Protocol](https://modelcontextprotocol.io/) team
+- [FastMCP](https://gofastmcp.com/) framework
+
+---
+
+**Made with ❤️ for better Python code quality**

mcp_server_analyzer-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+mcp_python_analyzer/__init__.py,sha256=bPIYonewbfJGGIqYmUtLQjkHEbt24GX4u7Ds7MnyvgI,237
+mcp_python_analyzer/__main__.py,sha256=HOKceDWn0JvyXdMZHonU1V9sTkNQP6a9Oqz_1RPmTVc,166
+mcp_python_analyzer/models.py,sha256=honpIBYerxcoC11GTEXwuMnmU_Wbihp_AgvFbUGXfCo,2748
+mcp_python_analyzer/server.py,sha256=9QCuTp-UCH4zP4cehP8L8jP4IZKjTGdqPHHIMeuQj9s,7925
+mcp_python_analyzer/analyzers/__init__.py,sha256=_TP4IrLzNrRcoEOexr5_AkWu6L_WyLSjRrIzPma5l9E,174
+mcp_python_analyzer/analyzers/ruff.py,sha256=iiHb4LSUc2fc-4BVpe1etI27w1neaJ4oOnKre4Cw-dY,6495
+mcp_python_analyzer/analyzers/vulture.py,sha256=CpQV4D5m4Zy3UwzmSJu9h1OzJUCS3oYAU5Cw2jLFKFo,6672
+mcp_server_analyzer-0.1.0.dist-info/METADATA,sha256=_AVDTybW5B8TsbTRR3j93y_b8GMQsROHFbRbGgb2r0I,10159
+mcp_server_analyzer-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_server_analyzer-0.1.0.dist-info/entry_points.txt,sha256=SpeNZYsdCOS8w8AJo9bXhK-i9n9DBv_dgkxtycVlN_E,72
+mcp_server_analyzer-0.1.0.dist-info/licenses/LICENSE,sha256=FqeVsqKpPjbVPTy3xbdFxzRvWd8GPgI0Hx3i_oAWcJQ,1068
+mcp_server_analyzer-0.1.0.dist-info/RECORD,,

mcp_server_analyzer-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

mcp_server_analyzer-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mcp-server-analyzer = mcp_python_analyzer.server:main

mcp_server_analyzer-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Anselm Hahn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.