validate_system.py

#!/usr/bin/env python3
"""System validation for the CodeWeaver application.

Validates the current project structure, syntax, and runtime configuration that are
actually required for this repository.
"""

import os
import re
import ast
from pathlib import Path


def validate_python_syntax(file_path):
    """Validate Python syntax using AST parsing."""
    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            content = f.read()

        ast.parse(content)
        return True, "Syntax valid"
    except SyntaxError as e:
        return False, f"Syntax error: {e}"
    except Exception as e:
        return False, f"Error: {e}"


def validate_javascript_syntax(file_path):
    """Basic JavaScript syntax validation."""
    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            content = f.read()

        open_braces = content.count('{')
        close_braces = content.count('}')
        open_parens = content.count('(')
        close_parens = content.count(')')
        open_brackets = content.count('[')
        close_brackets = content.count(']')

        if open_braces != close_braces:
            return False, f"Mismatched braces: {open_braces} vs {close_braces}"
        if open_parens != close_parens:
            return False, f"Mismatched parentheses: {open_parens} vs {close_parens}"
        if open_brackets != close_brackets:
            return False, f"Mismatched brackets: {open_brackets} vs {close_brackets}"

        return True, "Syntax appears valid"
    except Exception as e:
        return False, f"Error: {e}"


def validate_css_syntax(file_path):
    """Basic CSS syntax validation."""
    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            content = f.read()

        content = re.sub(r'/\*.*?\*/', '', content, flags=re.DOTALL)

        open_braces = content.count('{')
        close_braces = content.count('}')

        if open_braces != close_braces:
            return False, f"Mismatched braces: {open_braces} vs {close_braces}"

        return True, "Syntax appears valid"
    except Exception as e:
        return False, f"Error: {e}"


def validate_file_structure():
    """Validate that required files exist and identify optional files."""
    required_files = {
        'app.py': ('Flask application entrypoint', True),
        'dependency_analyzer.py': ('Dependency analysis module', True),
        'compressor.py': ('Compression module', True),
        'requirements.txt': ('Python dependencies', True),
        '.env': ('Environment configuration', True),
        'templates/index.html': ('Main HTML template', True),
        'static/script.js': ('Frontend JavaScript', True),
        'static/style.css': ('Frontend CSS styling', True),
    }

    optional_files = {
        'model_configuration.py': ('Legacy model-configuration helper', False),
        'README.md': ('Project documentation', False),
    }

    results = {}
    for file_path, (description, required) in required_files.items():
        exists = os.path.exists(file_path)
        results[file_path] = {
            'exists': exists,
            'description': description,
            'required': required,
            'status': '✅ Found' if exists else '❌ Missing',
        }

    for file_path, (description, required) in optional_files.items():
        exists = os.path.exists(file_path)
        results[file_path] = {
            'exists': exists,
            'description': description,
            'required': required,
            'status': '✅ Found' if exists else '⚠️ Optional: Missing',
        }

    return results


def _read_env_value(env_content, key):
    for raw_line in env_content.splitlines():
        line = raw_line.strip()
        if not line or line.startswith('#') or '=' not in line:
            continue

        candidate_key, value = line.split('=', 1)
        if candidate_key.strip() == key:
            return value.strip()

    return ''


def validate_frontend_enhancements():
    """Validate frontend enhancements that exist in this project."""
    js_path = 'static/script.js'
    css_path = 'static/style.css'

    results = {}

    if os.path.exists(js_path):
        with open(js_path, 'r', encoding='utf-8') as f:
            js_content = f.read()

        js_features = [
            'renderEnhancedMermaidDiagram',
            'validateMermaidSyntax',
            'addDiagramInteractivity',
            'addMermaidControls',
            'enhanced_mermaid_diagram',
        ]

        missing_js = [feature for feature in js_features if feature not in js_content]
        results['javascript'] = {
            'valid': len(missing_js) == 0,
            'missing': missing_js,
            'status': '✅ Enhanced' if len(missing_js) == 0 else '⚠️ Partial'
        }
    else:
        results['javascript'] = {'valid': False, 'missing': ['File not found'], 'status': '❌ Missing'}

    if os.path.exists(css_path):
        with open(css_path, 'r', encoding='utf-8') as f:
            css_content = f.read()

        css_features = [
            '.mermaid-enhanced',
            '.mermaid-controls',
            '.mermaid-error-container',
            '.mermaid-loading',
            '.mermaid-svg-container',
        ]

        missing_css = [feature for feature in css_features if feature not in css_content]
        results['css'] = {
            'valid': len(missing_css) == 0,
            'missing': missing_css,
            'status': '✅ Enhanced' if len(missing_css) == 0 else '⚠️ Partial'
        }
    else:
        results['css'] = {'valid': False, 'missing': ['File not found'], 'status': '❌ Missing'}

    return results


def validate_configuration():
    """Validate environment configuration."""
    env_path = '.env'

    if not os.path.exists(env_path):
        return False, "Environment file not found", ['.env is required'], []

    with open(env_path, 'r', encoding='utf-8') as f:
        env_content = f.read()

    openrouter_api_key = _read_env_value(env_content, 'OPENROUTER_API_KEY')
    gemini_api_key = _read_env_value(env_content, 'GEMINI_API_KEY')

    if not openrouter_api_key and not gemini_api_key:
        return (
            False,
            "Missing provider keys: set OPENROUTER_API_KEY or GEMINI_API_KEY",
            ['No OPENROUTER_API_KEY'],
            [],
        )

    if not openrouter_api_key:
        warnings = ['OPENROUTER_API_KEY is not set; fallback legacy flow may fail']
    else:
        warnings = []

    required_recommended = [
        ('OPENROUTER_MODEL', 'google/gemma-3-27b-it:free'),
        ('OPENROUTER_API_URL', 'https://openrouter.ai/api/v1/chat/completions'),
        ('OPENROUTER_REQUEST_TIMEOUT', '120'),
        ('OPENROUTER_TIMEOUT', '120 (legacy alias)'),
        ('OPENROUTER_MAX_RETRIES', '3'),
        ('OPENROUTER_INITIAL_RETRY_DELAY', '1.0'),
        ('OPENROUTER_MAX_RETRY_DELAY', '30.0'),
        ('OPENROUTER_RETRY_JITTER_SECONDS', '0.4'),
        ('OPENROUTER_TEMPERATURE', '0.7'),
        ('OPENROUTER_TOP_P', '0.95'),
        ('OPENROUTER_MAX_TOKENS', '8192'),
        ('AI_SELECT_MAX_FILES_FOR_PROMPT', '2000'),
    ]

    recommendations = []
    for key, fallback in required_recommended:
        value = _read_env_value(env_content, key)
        if not value:
            recommendations.append(f"Missing recommended key '{key}' (default: {fallback})")

    diagram_keys = ['DIAGRAM_MAX_NODES', 'DIAGRAM_MAX_EDGES', 'DIAGRAM_ENABLE_VALIDATION']
    for key in diagram_keys:
        if not _read_env_value(env_content, key):
            recommendations.append(f"Missing recommended key '{key}'")

    return True, 'Configuration valid for current runtime', recommendations if recommendations else [], warnings


def main():
    """Run comprehensive system validation."""
    print("🔍 CodeWeaver System Validation")
    print("=" * 60)

    print("\n📁 File Structure Validation:")
    file_structure = validate_file_structure()
    all_files_exist = True
    missing_optional = []

    for file_path, info in file_structure.items():
        status = info['status']
        print(f"  {status} {file_path} - {info['description']}")
        if not info['exists']:
            if info['required']:
                all_files_exist = False
            else:
                missing_optional.append(file_path)

    if missing_optional:
        print(f"  ℹ️ Optional files missing (non-blocking): {', '.join(missing_optional)}")

    print("\n🐍 Python Syntax Validation:")
    python_files = [
        'app.py',
        'dependency_analyzer.py',
        'compressor.py',
        'model_configuration.py',
    ]

    python_syntax_valid = True
    for file_path in python_files:
        if os.path.exists(file_path):
            valid, message = validate_python_syntax(file_path)
            status = "✅" if valid else "❌"
            print(f"  {status} {file_path}: {message}")
            if not valid:
                python_syntax_valid = False

    print("\n🌐 Frontend Syntax Validation:")
    if os.path.exists('static/script.js'):
        js_valid, js_message = validate_javascript_syntax('static/script.js')
        print(f"  {'✅' if js_valid else '❌'} script.js: {js_message}")
    else:
        js_valid = False
        print("  ❌ script.js: File not found")

    if os.path.exists('static/style.css'):
        css_valid, css_message = validate_css_syntax('static/style.css')
        print(f"  {'✅' if css_valid else '❌'} style.css: {css_message}")
    else:
        css_valid = False
        print("  ❌ style.css: File not found")

    print("\n🎨 Frontend Feature Validation:")
    frontend_results = validate_frontend_enhancements()

    print(f"  {frontend_results['javascript']['status']} JavaScript features")
    if frontend_results['javascript']['missing']:
        for missing in frontend_results['javascript']['missing']:
            print(f"    - Missing: {missing}")

    print(f"  {frontend_results['css']['status']} CSS features")
    if frontend_results['css']['missing']:
        for missing in frontend_results['css']['missing']:
            print(f"    - Missing: {missing}")

    print("\n⚙️ Configuration Validation:")
    config_valid, config_msg, config_recommendations, config_warnings = validate_configuration()

    if config_warnings:
        print("  ⚠️ Configuration warnings:")
        for warning in config_warnings:
            print(f"    - {warning}")

    if config_recommendations:
        print("  ℹ️ Recommended settings:")
        for recommendation in config_recommendations:
            print(f"    - {recommendation}")

    status = "✅" if config_valid else "❌"
    print(f"  {status} Environment configuration: {config_msg}")

    print("\n" + "=" * 60)
    print("🎯 VALIDATION SUMMARY")
    print("=" * 60)

    overall_valid = (
        all_files_exist and
        python_syntax_valid and
        js_valid and
        css_valid and
        config_valid
    )

    if overall_valid:
        print("✅ SYSTEM VALIDATION PASSED")
        print("\n🎉 CodeWeaver system is ready for deployment")
    else:
        print("❌ SYSTEM VALIDATION FAILED")
        print("\n⚠️ Please address the issues above before deployment.")

    return overall_valid


if __name__ == '__main__':
    success = main()
    exit(0 if success else 1)