# Create and activate virtual environment
python3 -m venv venv
source venv/bin/activate

# Install dependencies
pip install -r requirements.txt
pip install mcp
pip install -e .

# Run as MCP server
python -m src.mcp_compliance_validator.simple_server

# Or validate a repository directly
python -c "
import asyncio
from src.mcp_compliance_validator.tools.validate_compliance import validate_compliance

async def validate():
    result = await validate_compliance('/path/to/your/mcp-server')
    print(f'Security Score: {result[\"analysis_summary\"][\"security_score\"]:.2f}')

asyncio.run(validate())
"

# Run directly with npx (no installation required)
npx mcp-compliance-validator

# Or install globally
npm install -g mcp-compliance-validator

# Create virtual environment
python3 -m venv venv

# Activate virtual environment
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install dependencies
pip install -r requirements.txt

# Install MCP library
pip install mcp

# Install package in development mode
pip install -e .

# Development installation (includes testing and linting tools)
pip install -r requirements-dev.txt

# Set up development environment (if available)
make setup

# Run tests
make test

# Check code quality
make lint

# Test MCP server
./venv/bin/python -m src.mcp_compliance_validator.simple_server

# Run all tests
python3 -m pytest

# Run specific test
python3 -m pytest tests/contract/test_analyze_tools_contract.py::TestAnalyzeMCPToolsContract::test_tool_exists

# Run MCP server directly
python3 src/mcp_compliance_validator/simple_server.py

cd /path/to/mcp-compliance-validator
pip install -r requirements.txt
pip install -e .

{
  "mcpServers": {
    "mcp-compliance-validator": {
      "command": "npx",
      "args": ["-y", "mcp-compliance-validator"],
      "description": "Security validation system for MCP server implementations with enterprise-grade authentication and authorization checks",
      "alwaysAllow": [
        "validate_compliance",
        "analyze_mcp_tools",
        "get_mcp_spec_version"
      ]
    }
  }
}

{
  "mcpServers": {
    "mcp-compliance-validator": {
      "command": "/path/to/mcp-compliance-validator/venv/bin/python",
      "args": [
        "-m",
        "src.mcp_compliance_validator.simple_server"
      ],
      "cwd": "/path/to/mcp-compliance-validator",
      "description": "Security validation system for MCP server implementations with enterprise-grade authentication and authorization checks",
      "alwaysAllow": [
        "validate_compliance",
        "analyze_mcp_tools",
        "get_mcp_spec_version"
      ]
    }
  }
}

claude mcp add-json "mcp-compliance-validator" '{
  "command": "npx",
  "args": ["-y", "mcp-compliance-validator"]
}'

claude mcp add-from-claude-desktop

{
  "mcpServers": {
    "mcp-compliance-validator": {
      "command": "npx",
      "args": ["-y", "mcp-compliance-validator"]
    }
  }
}

{
  "mcpServers": {
    "mcp-compliance-validator": {
      "command": "python",
      "args": [
        "/full/path/to/mcp-compliance-validator/src/mcp_compliance_validator/simple_server.py"
      ]
    }
  }
}

python -m mcp_compliance_validator.simple_server

{
  "name": "validate_compliance",
  "arguments": {
    "repository_path": "/path/to/your/mcp-server",
    "validation_categories": ["SECURITY", "TOOLS", "PROTOCOL"],
    "include_patterns": ["**/*.py"],
    "exclude_patterns": ["**/test_*", "**/__pycache__/**"]
  }
}

{
  "success": true,
  "analysis_summary": {
    "files_analyzed": 150,
    "total_findings": 23,
    "security_score": 0.85,
    "compliance_status": "COMPLIANT_WITH_WARNINGS"
  },
  "findings": [
    {
      "rule_id": "OAUTH-001",
      "severity": "high",
      "message": "PKCE not required for OAuth flows",
      "recommendation": "Require PKCE for all OAuth authorization flows",
      "file_path": "/path/to/oauth.py",
      "line_number": 42
    }
  ]
}

{
  "name": "analyze_mcp_tools",
  "arguments": {
    "repository_path": "/path/to/your/mcp-server",
    "tool_patterns": ["@mcp.tool", "@tool", "def.*tool.*\\("]
  }
}

{
  "name": "get_mcp_spec_version",
  "arguments": {}
}

{
  "name": "monitor_mcp_docs",
  "arguments": {
    "days_back": 30,
    "severity_filter": "medium",
    "github_token": "ghp_xxxxxxxxxxxxxxxxxxxx"
  }
}

{
  "success": true,
  "monitoring_summary": {
    "monitoring_period": {
      "days_back": 30,
      "start_date": "2025-08-27T13:04:14.986886+00:00",
      "end_date": "2025-09-26T13:04:21.509954+00:00"
    },
    "repositories_checked": [
      "modelcontextprotocol/specification",
      "modelcontextprotocol/python-sdk",
      "modelcontextprotocol/typescript-sdk"
    ],
    "raw_commits_found": 21,
    "changes_detected": 44,
    "changes_after_filtering": 39
  },
  "compliance_report": {
    "priority_summary": {
      "critical": 0,
      "high": 15,
      "medium": 24,
      "low": 0
    },
    "changes_requiring_validation_updates": 28
  }
}

{
  "name": "analyze_mcp_tools_comprehensive",
  "arguments": {
    "repository_path": ".",
    "include_docs_analysis": true,
    "docs_monitoring_days": 7,
    "github_token": "ghp_xxxxxxxxxxxxxxxxxxxx"
  }
}

{
  "name": "monitor_tools_compliance_drift",
  "arguments": {
    "repository_path": ".",
    "baseline_days": 30,
    "comparison_days": 7,
    "github_token": "ghp_xxxxxxxxxxxxxxxxxxxx"
  }
}

from mcp_compliance_validator.validators.auth_security import AuthSecurityValidator

# Initialize validator
validator = AuthSecurityValidator()

# Validate OAuth 2.1 configuration
oauth_config = {
    "oauth": {
        "pkce_required": True,
        "state_required": True,
        "redirect_uri_validation": {"enabled": True},
        "authorization_code": {"expiration_seconds": 600},
        "client_authentication": {"required": True}
    }
}

result = validator.validate_oauth_implementation(oauth_config)
print(f"OAuth Security: {'SECURE' if result.is_secure else 'INSECURE'}")

# Validate JWT configuration
jwt_config = {
    "algorithm": "RS256",
    "expiration_hours": 1,
    "issuer_validation": {"enabled": True},
    "audience_validation": {"enabled": True}
}

jwt_result = validator.validate_jwt_security(jwt_config)
print(f"JWT Security: {'SECURE' if jwt_result.is_secure else 'INSECURE'}")

# .github/workflows/security-validation.yml
name: Security Validation

on: [push, pull_request]

jobs:
  security-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2

      - name: Set up Python
        uses: actions/setup-python@v2
        with:
          python-version: '3.11'

      - name: Install MCP Validator
        run: |
          git clone https://github.com/your-org/mcp-compliance-validator.git
          cd mcp-compliance-validator
          pip install -r requirements.txt

      - name: Run Security Validation
        run: |
          cd mcp-compliance-validator
          python -c "
          import asyncio, sys
          from mcp_compliance_validator.tools.validate_compliance import validate_compliance

          async def validate():
              result = await validate_compliance('$GITHUB_WORKSPACE',
                                               validation_categories=['SECURITY'])
              score = result['analysis_summary']['security_score']
              print(f'Security Score: {score:.2f}')

              # Fail if critical issues found
              critical_findings = [f for f in result['findings']
                                 if f['severity'] == 'critical']
              if critical_findings:
                  print(f'ERROR: {len(critical_findings)} critical security issues found')
                  sys.exit(1)
              else:
                  print('No critical security issues')

          asyncio.run(validate())
          "

# GitHub integration (required for MCP documentation monitoring)
export GITHUB_TOKEN=ghp_xxxxxxxxxxxxxxxxxxxx

# Security settings
export MCP_SECURITY_MIN_ENTROPY=8.0
export MCP_SECURITY_FALSE_POSITIVE_RATE=0.01

# Performance settings
export MCP_ANALYSIS_MAX_WORKERS=4
export MCP_ANALYSIS_TIMEOUT_SECONDS=300

# Logging
export MCP_LOG_LEVEL=INFO
export MCP_LOG_FORMAT=json

github:
  token: "ghp_xxxxxxxxxxxxxxxxxxxx"  # GitHub personal access token

security:
  min_secret_entropy: 8.0
  false_positive_rate: 0.01
  allowed_path_prefixes:
    - "/safe/path"

analysis:
  max_workers: 4
  timeout_seconds: 300
  chunk_size: 100

logging:
  level: INFO
  format: json
  file_path: "/var/log/mcp-validator.log"

from mcp_compliance_validator.tools.monitor_mcp_docs import monitor_mcp_docs

# Monitor last 7 days with medium+ severity
result = await monitor_mcp_docs(
    days_back=7,
    severity_filter="medium"
)

if result["success"]:
    print(f"Found {len(result['detailed_changes'])} relevant changes")
    for change in result['detailed_changes']:
        print(f"- {change['title']} ({change['severity']})")

from mcp_compliance_validator.tools.analyze_mcp_tools import analyze_mcp_tools_comprehensive

# Analyze tools with documentation monitoring
result = await analyze_mcp_tools_comprehensive(
    repository_path="/path/to/your/mcp/project",
    include_docs_analysis=True,
    docs_monitoring_days=14
)

if result["success"]:
    # View tool analysis
    tools = result["tools_analysis"]
    print(f"Tools found: {tools['tools_found']}")
    print(f"Compliant: {tools['tools_compliant']}")

    # View cross-reference insights
    insights = result.get("cross_reference_insights", {})
    for recommendation in insights.get("recommendations", []):
        print(f"Recommendation: {recommendation}")

# Using the MCP tool directly
mcp_validate_compliance \
  --repository_path /path/to/your/repo \
  --exclude_patterns "test_env/**/*" "**/__pycache__/**" "**/site-packages/**" \
  --exclude_test_files true

# External dependencies
test_env/**/*
**/site-packages/**
lib/python*/site-packages/**

# Cache and build files
**/__pycache__/**
*.pyc
*.pyo
*.pyd

# Virtual environments
venv/*
.venv/*
env/*

# IDE files
.vscode/*
.idea/*

# For development - see all issues
--severity_threshold INFO

# For CI/CD - only critical issues
--severity_threshold ERROR

--validation_categories "PROTOCOL,SCHEMA,TOOLS"

# Include packaging recommendations
--validation_categories "PROTOCOL,SCHEMA,TOOLS,PACKAGING"

import asyncio
from mcp_compliance_validator.tools.validate_compliance import validate_compliance

async def comprehensive_security_check():
    """Run a complete security assessment."""

    result = await validate_compliance(
        repository_path="/path/to/your/mcp-server",
        validation_categories=["SECURITY", "TOOLS", "PROTOCOL"],
        include_patterns=["**/*.py"],
        exclude_patterns=["**/tests/**", "**/__pycache__/**"]
    )

    # Print summary
    summary = result["analysis_summary"]
    print(f"Security Assessment Results:")
    print(f"   Files Analyzed: {summary['files_analyzed']}")
    print(f"   Security Score: {summary['security_score']:.2f}/1.00")
    print(f"   Status: {summary['compliance_status']}")

    # Print findings by severity
    findings_by_severity = {}
    for finding in result["findings"]:
        severity = finding["severity"]
        findings_by_severity.setdefault(severity, []).append(finding)

    for severity in ["critical", "high", "medium", "low"]:
        if severity in findings_by_severity:
            count = len(findings_by_severity[severity])
            print(f"   {severity.upper()}: {count} findings")

    # Print critical findings
    critical_findings = findings_by_severity.get("critical", [])
    if critical_findings:
        print("\\nCritical Security Issues:")
        for finding in critical_findings:
            print(f"   {finding['rule_id']}: {finding['message']}")
            print(f"   Location: {finding['file_path']}:{finding['line_number']}")
            print(f"   Recommendation: {finding['recommendation']}")
            print()

    return result

# Run the assessment
asyncio.run(comprehensive_security_check())

from mcp_compliance_validator.validators.auth_security import AuthSecurityValidator

def validate_multiple_configs():
    """Validate multiple authentication configurations."""

    validator = AuthSecurityValidator()

    configs = {
        "Production OAuth": {
            "oauth": {
                "pkce_required": True,
                "state_required": True,
                "redirect_uri_validation": {"enabled": True},
                "client_authentication": {"required": True}
            }
        },
        "Development JWT": {
            "algorithm": "HS256",  # Intentionally weak for demo
            "expiration_hours": 24,
            "issuer_validation": {"enabled": False}
        },
        "Secure API Keys": {
            "key_length": 64,
            "rotation_enabled": True,
            "revocation": {"enabled": True}
        }
    }

    print("Authentication Configuration Validation\\n")

    for name, config in configs.items():
        print(f"Testing: {name}")

        # Choose appropriate validator
        if "oauth" in config:
            result = validator.validate_oauth_implementation(config)
        elif "algorithm" in config:
            result = validator.validate_jwt_security(config)
        else:
            result = validator.validate_api_key_security(config)

        # Display results
        status = "SECURE" if result.is_secure else "INSECURE"
        print(f"   Status: {status}")

        if result.findings:
            print(f"   Findings: {len(result.findings)}")
            for finding in result.findings[:3]:  # Show first 3
                print(f"     [{finding.severity}] {finding.message}")
            if len(result.findings) > 3:
                print(f"     ... and {len(result.findings) - 3} more")
        print()

validate_multiple_configs()

# Clone repository
git clone <repository-url>
cd mcp-compliance-validator

# Install development dependencies
pip install -r requirements-dev.txt

# Set up pre-commit hooks
make setup

# Run tests
make test

# Run type checking
make type-check

# Format code
make format

# Run all tests
pytest

# Run with coverage
pytest --cov=mcp_compliance_validator

# Run specific test categories
pytest tests/contract/  # Contract tests
pytest tests/unit/      # Unit tests

# Run performance tests
pytest -m "not slow"    # Skip slow tests