# Clone and install FastApply
git clone https://github.com/your-org/fastapply-mcp.git
cd fastapply-mcp

# Install dependencies with uv (recommended)
uv sync --all-extras
source .venv/bin/activate
uv pip install -e .

# Or with pip
pip install -e .
cp .env.example .env

# Core FastApply Settings
FAST_APPLY_URL=http://localhost:1234/v1        # Your FastApply server URL
FAST_APPLY_MODEL=fastapply-1.5b                # Model identifier
FAST_APPLY_TIMEOUT=30.0                        # Request timeout

# Performance Optimization
FAST_APPLY_MAX_TOKENS=8000                     # Response token limit
FAST_APPLY_TEMPERATURE=0.05                    # Model consistency

# Security & Isolation
WORKSPACE_ROOT=/path/to/project                # Workspace confinement
FAST_APPLY_STRICT_PATHS=1                      # Path validation
MAX_FILE_SIZE=10485760                         # 10MB file limit

{
  "mcpServers": {
    "fast-apply-mcp": {
      "command": "uvx",
      "args": ["--from", "/path/to/fastapply-mcp", "run", "python", "main.py"]
    }
  }
}

# Verify FastApply server is accessible
curl http://localhost:1234/v1/models

# Restart Claude Code to load MCP server
# FastApply tools are now available!

// AI-guided refactoring with validation
{
  "tool": "edit_file",
  "arguments": {
    "target_file": "src/auth.js",
    "instructions": "Add input validation and error handling",
    "code_edit": "function login(email, password) {\n  if (!email || !password) {\n    throw new Error('Email and password are required');\n  }\n  \n  try {\n    return await authenticateUser(email, password);\n  } catch (error) {\n    throw new Error(`Authentication failed: ${error.message}`);\n  }\n}"
  }
}

// Find all async functions with error handling
{
  "tool": "search_code_patterns",
  "arguments": {
    "pattern": "async function $name($args) { $body }",
    "language": "javascript",
    "path": "src"
  }
}

// Analyze code structure and complexity
{
  "tool": "analyze_code_structure",
  "arguments": {
    "file_path": "src/api/user-service.ts"
  }
}

// Track symbol references across codebase
{
  "tool": "find_references",
  "arguments": {
    "symbol": "UserRepository",
    "path": "src",
    "symbol_type": "class"
  }
}

// Comprehensive security audit
{
  "tool": "security_scan_comprehensive",
  "arguments": {
    "project_path": "/path/to/project",
    "scan_types": ["pattern", "dependencies", "configuration"],
    "compliance_standards": ["owasp_top_10", "pci_dss"],
    "output_format": "json"
  }
}

// Multi-dimensional quality analysis
{
  "tool": "quality_assessment_comprehensive",
  "arguments": {
    "project_path": "/path/to/project",
    "analysis_types": ["complexity", "code_smells", "maintainability"],
    "output_format": "json"
  }
}

// Deep semantic analysis with collective memory
{
  "tool": "llm_analyze_code",
  "arguments": {
    "code": "function processData(data) { /* ... */ }",
    "language": "javascript",
    "analysis_type": "security",
    "use_collective_memory": true
  }
}

┌─────────────────────────────────────────────────────────────────┐
│                   FastApply MCP Server                         │
├─────────────────────────────────────────────────────────────────┤
│  🎯 Entry Point: main.py (Orchestration)                        │
│                                                                 │
│  🔍 Search Layer - 750% faster than alternatives               │
│  ├── ripgrep_integration.py (High-performance search)           │
│  └── enhanced_search.py (Multi-strategy search)                │
│                                                                 │
│  🧠 Intelligence Layer - AI-enhanced analysis                  │
│  ├── ast_rule_intelligence.py (LLM reasoning)                  │
│  ├── ast_search.py (Custom AST analysis)                       │
│  └── deep_semantic_analysis.py (Pattern recognition)         │
│                                                                 │
│  🔗 Analysis & Operations - Enterprise-grade tools             │
│  ├── symbol_operations.py (Symbol detection)                   │
│  ├── relationship_mapping.py (Dependency analysis)              │
│  ├── navigation_tools.py (Code navigation)                     │
│  ├── security_quality_analysis.py (Security & quality)         │
│  └── safe_refactoring.py (Safe transformations)                │
│                                                                 │
│  ⚡ Processing & Integration - Scalable backend                │
│  ├── batch_operations.py (Bulk processing)                     │
│  └── main.py (MCP server orchestration)                        │
└─────────────────────────────────────────────────────────────────┘

# === Core Server Settings ===
HOST=localhost                                    # Server host binding
PORT=8000                                       # Server port
DEBUG=false                                     # Debug mode
LOG_LEVEL=INFO                                  # Logging verbosity

# === FastApply Integration ===
FAST_APPLY_URL=http://localhost:1234/v1         # FastApply server URL
FAST_APPLY_MODEL=fastapply-1.5b                 # Model identifier
FAST_APPLY_API_KEY=optional-key                 # API key if required
FAST_APPLY_TIMEOUT=30.0                         # Request timeout
FAST_APPLY_MAX_TOKENS=8000                      # Max response tokens
FAST_APPLY_TEMPERATURE=0.05                     # Model creativity

# === Performance Optimization ===
MAX_CONCURRENT_OPERATIONS=4                     # Concurrent operations
CACHE_SIZE=1000                                 # Cache entry limit
TIMEOUT_SECONDS=30                              # Operation timeout

# === Security & Isolation ===
WORKSPACE_ROOT=/safe/workspace                  # Workspace confinement
FAST_APPLY_STRICT_PATHS=1                      # Path validation
MAX_FILE_SIZE=10485760                          # 10MB file limit
ALLOWED_EXTENSIONS=.py,.js,.ts,.jsx,.tsx,.md,.json,.yaml,.yml

# === Optional Integrations ===
OPENAI_API_KEY=your-openai-key                 # OpenAI integration
QDRANT_URL=http://localhost:6333               # Qdrant vector database
QDRANT_API_KEY=your-qdrant-key                 # Qdrant API key

{
  "mcpServers": {
    "fast-apply-mcp": {
      "command": "uvx",
      "args": ["--from", "/path/to/fastapply-mcp", "run", "python", "main.py"],
      "env": {
        "FAST_APPLY_URL": "http://localhost:1234/v1",
        "FAST_APPLY_MODEL": "fastapply-1.5b",
        "WORKSPACE_ROOT": "/path/to/project"
      }
    }
  }
}

# GitHub Actions - Automated Quality Gates
name: Code Quality & Security Check
on: [push, pull_request]

jobs:
  quality-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up FastApply
        run: |
          pip install fastapply-mcp
          fastapply-mcp --install

      - name: Security Scan
        run: |
          fastapply-mcp security-scan --path . --output security-report.json

      - name: Quality Assessment
        run: |
          fastapply-mcp quality-assess --path . --output quality-report.json

      - name: Generate Compliance Report
        run: |
          fastapply-mcp compliance-report --standards owasp_top_10,pci_dss

# Python API Integration
from fastapply import FastApplyClient

client = FastApplyClient(
    url="http://localhost:1234/v1",
    model="fastapply-1.5b"
)

# Security scan
results = client.security_scan(
    project_path="./src",
    scan_types=["pattern", "dependencies"]
)

# Quality analysis
quality = client.quality_assessment(
    project_path="./src",
    analysis_types=["complexity", "maintainability"]
)

// Safe refactoring with dependency analysis
{
  "tool": "llm_search_pattern",
  "arguments": {
    "query": "find all references to legacy UserService class",
    "language": "java",
    "path": "./src/main/java",
    "use_collective_memory": true
  }
}

// Comprehensive security scan with compliance reporting
{
  "tool": "security_scan_comprehensive",
  "arguments": {
    "project_path": "./payment-system",
    "scan_types": ["pattern", "dependencies", "configuration"],
    "compliance_standards": ["owasp_top_10", "pci_dss", "soc2"],
    "output_format": "json"
  }
}

// Multi-dimensional quality assessment
{
  "tool": "quality_assessment_comprehensive",
  "arguments": {
    "project_path": ".",
    "analysis_types": ["complexity", "code_smells", "maintainability", "test_coverage"],
    "quality_thresholds": {
      "complexity_score": 15,
      "maintainability_index": 70
    },
    "output_format": "json"
  }
}

// Deep architectural analysis
{
  "tool": "llm_analyze_code",
  "arguments": {
    "code": "monolith_codebase_context",
    "language": "multi",
    "analysis_type": "architecture",
    "use_collective_memory": true,
    "focus_areas": ["dependencies", "coupling", "boundaries"]
  }
}

// Automated documentation generation
{
  "tool": "search_code_patterns",
  "arguments": {
    "pattern": "function $name($args) { $body }",
    "language": "python",
    "path": "./api/endpoints",
    "extract_metadata": ["docstrings", "type_hints", "examples"]
  }
}

# Verify FastApply server accessibility
curl http://localhost:1234/v1/models

# Check MCP server configuration
echo "MCP Configuration:"
cat ~/.config/claude-code/mcp_servers.json

# Test server connectivity
python -c "
import requests
try:
    response = requests.get('http://localhost:1234/v1/models', timeout=5)
    print('✅ FastApply server accessible')
except Exception as e:
    print(f'❌ Connection failed: {e}')
"

# Enable debug logging for performance analysis
export LOG_LEVEL=DEBUG
export DEBUG=true

# Monitor resource usage
top -p $(pgrep -f fastapply)

# Clear cache and restart
rm -rf ./cache/*
python -m fastapply.main --restart

# Check memory usage
python -c "
import psutil
import os
process = psutil.Process(os.getpid())
print(f'Memory Usage: {process.memory_info().rss / 1024 / 1024:.1f}MB')
"

# Verify workspace configuration
echo "Workspace root: $WORKSPACE_ROOT"

# Check file permissions
ls -la /path/to/workspace

# Validate path resolution
python -c "
from fastapply.main import _secure_resolve
print('Test path resolution:', _secure_resolve('/test'))
"

# Audit security settings
python -c "
import os
print('Security Settings:')
print(f'Strict Paths: {os.getenv("FAST_APPLY_STRICT_PATHS", "0")}')
print(f'Max File Size: {os.getenv("MAX_FILE_SIZE", "10485760")}')
"

# Enable full debugging
export LOG_LEVEL=DEBUG
export DEBUG=true
export FAST_APPLY_DEBUG=1

# Start with debug output
python -m fastapply.main --debug --verbose

# Monitor logs in real-time
tail -f fastapply.log

# Comprehensive health check
python -c "
import asyncio
import json
from fastapply.main import health_check

async def full_health_check():
    print('🔍 Running comprehensive health check...')

    # Basic health
    health = await health_check()
    print(f'📊 Health Status: {health}')

    # MCP connectivity
    try:
        import mcp
        print('✅ MCP module available')
    except ImportError:
        print('❌ MCP module missing')

    # FastApply connectivity
    try:
        import openai
        client = openai.OpenAI(base_url='http://localhost:1234/v1')
        models = client.models.list()
        print('✅ FastApply server connected')
    except Exception as e:
        print(f'❌ FastApply connection failed: {e}')

asyncio.run(full_health_check())
"

# Performance analysis
python -c "
import time
import cProfile
import pstats

def profile_fastapply():
    # Profile startup time
    start = time.time()

    # Your FastApply operations here

    end = time.time()
    print(f'Operation completed in {end-start:.2f}s')

# Run profiling
profiler = cProfile.Profile()
profiler.enable()
profile_fastapply()
profiler.disable()

# Save profile stats
stats = pstats.Stats(profiler)
stats.sort_stats('cumulative')
stats.print_stats(10)
"

# Fork and clone the repository
git clone https://github.com/your-username/fastapply-mcp.git
cd fastapply-mcp

# Set up development environment
uv sync --all-extras --dev
source .venv/bin/activate

# Install pre-commit hooks
pre-commit install

# Create feature branch
git checkout -b feature/amazing-feature

# Make your changes with tests
# Update documentation for new features

# Run quality checks
ruff check .
ruff format .
mypy src/

# Run tests
pytest
pytest --cov=src/ --cov-report=html:htmlcov/ --cov-report=term-missing

# Commit changes
git commit -m "feat: add amazing feature with comprehensive tests"

# Push and create PR
git push origin feature/amazing-feature

┌─────────────────────────────────────────────────────────────────┐
│                   Development Environment                     │
├─────────────────────────────────────────────────────────────────┤
│  📁 src/fastapply/          # Core source code                 │
│  📁 tests/                   # Comprehensive test suite         │
│  📁 docs/                    # Documentation                   │
│  📁 examples/                # Practical usage examples         │
│  📁 .github/                 # CI/CD workflows                 │
│  📁 scripts/                 # Development utilities           │
└─────────────────────────────────────────────────────────────────┘

# Run all tests
pytest -v

# Run with coverage
pytest --cov=src/ --cov-report=html:htmlcov/ --cov-report=term-missing

# Run specific test categories
pytest -m unit          # Unit tests only
pytest -m integration   # Integration tests only
pytest -m performance   # Performance tests only
pytest -m security      # Security tests only

# Run with debugging
pytest -vvs --tb=short  # Verbose output with short tracebacks