routes.py

"""
Cursor Rules Generator - API Routes

This module implements the API routes for the Cursor Rules Generator.
"""

from flask import Flask, request, jsonify
from flask_cors import CORS
import os
import json

from ..config.settings import Settings
from ..llm.factory import LLMAdapterFactory
from ..engine.rule_generator import RuleGenerator

# Create Flask app
app = Flask(__name__)

# Configure CORS
CORS(app, resources={r"/api/*": {"origins": Settings.CORS_ORIGINS}})

# Initialize components
rule_generator = RuleGenerator()
factory = LLMAdapterFactory()

@app.route('/api/providers', methods=['GET'])
def get_providers():
    """Get a list of supported LLM providers.
    
    Returns:
        JSON: A list of provider information
    """
    providers = factory.get_supported_providers()
    
    # Format the response
    result = []
    for provider_id, provider_name in providers.items():
        result.append({
            'id': provider_id,
            'name': provider_name
        })
    
    return jsonify(result)

@app.route('/api/rule-types', methods=['GET'])
def get_rule_types():
    """Get a list of supported rule types.
    
    Returns:
        JSON: A list of rule type information
    """
    rule_types = rule_generator.get_rule_types()
    return jsonify(rule_types)

@app.route('/api/validate-api-key', methods=['POST'])
def validate_api_key():
    """Validate an API key for a specific provider.
    
    Request JSON:
        provider: The LLM provider
        api_key: The API key to validate
    
    Returns:
        JSON: Validation result
    """
    data = request.json
    
    if not data or 'provider' not in data or 'api_key' not in data:
        return jsonify({
            'valid': False,
            'message': 'Missing required parameters'
        }), 400
    
    provider = data['provider']
    api_key = data['api_key']
    
    try:
        # Create and initialize the adapter
        adapter = factory.create_adapter(provider)
        
        # Validate the API key
        valid = adapter.validate_api_key(api_key)
        
        if valid:
            return jsonify({
                'valid': True,
                'message': 'API key is valid'
            })
        else:
            return jsonify({
                'valid': False,
                'message': 'Invalid API key'
            })
    except Exception as e:
        return jsonify({
            'valid': False,
            'message': str(e)
        }), 500

@app.route('/api/models', methods=['POST'])
def get_models():
    """Get a list of available models for a specific provider.
    
    Request JSON:
        provider: The LLM provider
        api_key: The API key for the provider
    
    Returns:
        JSON: A list of model information
    """
    data = request.json
    
    if not data or 'provider' not in data or 'api_key' not in data:
        return jsonify({
            'error': 'Missing required parameters'
        }), 400
    
    provider = data['provider']
    api_key = data['api_key']
    
    try:
        # Create and initialize the adapter
        adapter = factory.create_adapter(provider)
        adapter.initialize(api_key)
        
        # Get available models
        models = adapter.get_available_models()
        
        return jsonify(models)
    except Exception as e:
        return jsonify({
            'error': str(e)
        }), 500

@app.route('/api/generate-rule', methods=['POST'])
def generate_rule():
    """Generate a Cursor Rule.
    
    Request JSON:
        provider: The LLM provider
        api_key: The API key for the provider
        model: The model ID to use
        rule_type: The type of rule to generate
        description: A short description of the rule's purpose
        content: The main content of the rule
        parameters: Additional parameters for rule generation
    
    Returns:
        JSON: The generated rule
    """
    data = request.json
    
    # Validate required parameters
    required_params = ['provider', 'api_key', 'model', 'rule_type', 'description', 'content']
    for param in required_params:
        if param not in data:
            return jsonify({
                'error': f'Missing required parameter: {param}'
            }), 400
    
    # Extract parameters
    provider = data['provider']
    api_key = data['api_key']
    model = data['model']
    rule_type = data['rule_type']
    description = data['description']
    content = data['content']
    parameters = data.get('parameters', {})
    
    # Validate rule type
    if not rule_generator.validate_rule_type(rule_type):
        return jsonify({
            'error': f'Invalid rule type: {rule_type}'
        }), 400
    
    try:
        # Generate the rule
        rule = rule_generator.create_rule(
            provider=provider,
            model=model,
            rule_type=rule_type,
            description=description,
            content=content,
            api_key=api_key,
            parameters=parameters
        )
        
        return jsonify({
            'rule': rule
        })
    except Exception as e:
        return jsonify({
            'error': str(e)
        }), 500

def create_app():
    """Create and configure the Flask application.
    
    Returns:
        Flask: The configured Flask application
    """
    return app

if __name__ == '__main__':
    # Run the app
    app.run(
        host=Settings.API_HOST,
        port=Settings.API_PORT,
        debug=Settings.DEBUG
    )