app.py

"""
Cursor Rules Generator - Hugging Face Spaces App

This module implements the Gradio interface for Hugging Face Spaces deployment.
All code is self-contained in this file to avoid import issues.
"""

import os
import gradio as gr
import json
import requests
import traceback
from dotenv import load_dotenv
from abc import ABC, abstractmethod
from typing import Dict, List, Optional, Any

# Load environment variables
load_dotenv()

# Configuration settings
class Settings:
    """Application settings."""
    
    # Application settings
    APP_NAME = "Cursor Rules Generator"
    DEBUG = os.getenv("DEBUG", "False").lower() == "true"
    
    # API keys
    GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "")
    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
    OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY", "")
    
    # Default settings
    DEFAULT_PROVIDER = os.getenv("DEFAULT_PROVIDER", "gemini")
    DEFAULT_RULE_TYPE = os.getenv("DEFAULT_RULE_TYPE", "Always")
    
    # LLM provider settings
    GEMINI_API_URL = "https://generativelanguage.googleapis.com/v1beta"
    OPENAI_API_URL = "https://api.openai.com/v1"
    OPENROUTER_API_URL = "https://openrouter.ai/api/v1"
    
    # LLM model settings
    DEFAULT_GEMINI_MODEL = os.getenv("DEFAULT_GEMINI_MODEL", "gemini-2.0-flash")
    DEFAULT_OPENAI_MODEL = os.getenv("DEFAULT_OPENAI_MODEL", "gpt-4o")
    DEFAULT_OPENROUTER_MODEL = os.getenv("DEFAULT_OPENROUTER_MODEL", "openai/gpt-4o")
    
    # Rule generation settings
    MAX_RULE_LENGTH = int(os.getenv("MAX_RULE_LENGTH", "10000"))
    DEFAULT_TEMPERATURE = float(os.getenv("DEFAULT_TEMPERATURE", "0.7"))

# LLM Adapter Interface
class LLMAdapter(ABC):
    """Base adapter interface for LLM providers."""
    
    @abstractmethod
    def initialize(self, api_key: str, **kwargs) -> None:
        """Initialize the adapter with API key and optional parameters."""
        pass
    
    @abstractmethod
    def validate_api_key(self, api_key: str) -> bool:
        """Validate the API key."""
        pass
    
    @abstractmethod
    def get_available_models(self) -> List[Dict[str, str]]:
        """Get a list of available models from the provider."""
        pass
    
    @abstractmethod
    def generate_rule(
        self, 
        model: str,
        rule_type: str, 
        description: str, 
        content: str, 
        parameters: Optional[Dict[str, Any]] = None
    ) -> str:
        """Generate a Cursor Rule using the LLM provider."""
        pass

# Gemini Adapter
class GeminiAdapter(LLMAdapter):
    """Adapter for Google's Gemini API."""
    
    def __init__(self):
        """Initialize the Gemini adapter."""
        self.api_key = None
        self.api_url = Settings.GEMINI_API_URL
        self.initialized = False
        self.last_error = None
    
    def initialize(self, api_key: str, **kwargs) -> None:
        """Initialize the adapter with API key and optional parameters."""
        self.api_key = api_key
        self.api_url = kwargs.get('api_url', Settings.GEMINI_API_URL)
        self.initialized = True
    
    def validate_api_key(self, api_key: str) -> bool:
        """Validate the Gemini API key."""
        try:
            # Try to list models with the provided API key
            url = f"{self.api_url}/models?key={api_key}"
            response = requests.get(url)
            
            # Check if the request was successful
            if response.status_code == 200:
                return True
            
            # Store error details for debugging
            self.last_error = f"API Error: Status {response.status_code}, Response: {response.text}"
            print(f"Gemini API validation failed: {self.last_error}")
            return False
        except Exception as e:
            # Store exception details for debugging
            self.last_error = f"Exception: {str(e)}\n{traceback.format_exc()}"
            print(f"Gemini API validation exception: {self.last_error}")
            return False
    
    def get_available_models(self) -> List[Dict[str, str]]:
        """Get a list of available Gemini models."""
        if not self.initialized:
            raise ValueError("Adapter not initialized. Call initialize() first.")
        
        try:
            # Get available models
            url = f"{self.api_url}/models?key={self.api_key}"
            response = requests.get(url)
            
            if response.status_code != 200:
                print(f"Failed to get models: Status {response.status_code}, Response: {response.text}")
                raise ValueError(f"Failed to get models: {response.text}")
            
            data = response.json()
            
            # Filter for Gemini models and format the response
            models = []
            for model in data.get('models', []):
                if 'gemini' in model.get('name', '').lower():
                    model_id = model.get('name').split('/')[-1]
                    models.append({
                        'id': model_id,
                        'name': self._format_model_name(model_id)
                    })
            
            # If no models found, return default models
            if not models:
                models = [
                    {'id': 'gemini-2.5-pro', 'name': 'Gemini 2.5 Pro'},
                    {'id': 'gemini-2.0-flash', 'name': 'Gemini 2.0 Flash'},
                    {'id': 'gemini-2.0-flash-lite', 'name': 'Gemini 2.0 Flash-Lite'}
                ]
            
            return models
        except Exception as e:
            print(f"Exception in get_available_models: {str(e)}\n{traceback.format_exc()}")
            # Return default models on error
            return [
                {'id': 'gemini-2.5-pro', 'name': 'Gemini 2.5 Pro'},
                {'id': 'gemini-2.0-flash', 'name': 'Gemini 2.0 Flash'},
                {'id': 'gemini-2.0-flash-lite', 'name': 'Gemini 2.0 Flash-Lite'}
            ]
    
    def generate_rule(
        self, 
        model: str,
        rule_type: str, 
        description: str, 
        content: str, 
        parameters: Optional[Dict[str, Any]] = None
    ) -> str:
        """Generate a Cursor Rule using Gemini."""
        if not self.initialized:
            raise ValueError("Adapter not initialized. Call initialize() first.")
        
        # Set default parameters if not provided
        if parameters is None:
            parameters = {}
        
        # Extract parameters
        temperature = parameters.get('temperature', Settings.DEFAULT_TEMPERATURE)
        globs = parameters.get('globs', '')
        referenced_files = parameters.get('referenced_files', '')
        prompt = parameters.get('prompt', '')
        
        # Prepare the prompt for Gemini
        system_prompt = """
        You are a Cursor Rules expert. Create a rule in MDC format based on the provided information.
        
        MDC format example:
        ---
        description: RPC Service boilerplate
        globs: 
        alwaysApply: false
        ---
        
        - Use our internal RPC pattern when defining services
        - Always use snake_case for service names.
        
        @service-template.ts
        """
        
        user_prompt = f"""
        Create a Cursor Rule with the following details:
        
        Rule Type: {rule_type}
        Description: {description}
        Content: {content}
        """
        
        if globs:
            user_prompt += f"\nGlobs: {globs}"
        
        if referenced_files:
            user_prompt += f"\nReferenced Files: {referenced_files}"
        
        if prompt:
            user_prompt += f"\nAdditional Instructions: {prompt}"
        
        # Prepare the API request
        url = f"{self.api_url}/models/{model}:generateContent?key={self.api_key}"
        
        payload = {
            "contents": [
                {
                    "role": "user",
                    "parts": [
                        {"text": system_prompt + "\n\n" + user_prompt}
                    ]
                }
            ],
            "generationConfig": {
                "temperature": temperature,
                "topP": 0.8,
                "topK": 40,
                "maxOutputTokens": 2048
            }
        }
        
        # Make the API request
        try:
            response = requests.post(url, json=payload)
            
            if response.status_code != 200:
                print(f"Failed to generate rule: Status {response.status_code}, Response: {response.text}")
                raise ValueError(f"Failed to generate rule: {response.text}")
            
            data = response.json()
            
            # Extract the generated text
            generated_text = data.get('candidates', [{}])[0].get('content', {}).get('parts', [{}])[0].get('text', '')
            
            # If no text was generated, create a basic rule
            if not generated_text:
                return self._create_basic_rule(rule_type, description, content, globs, referenced_files)
            
            return generated_text
        except Exception as e:
            print(f"Exception in generate_rule: {str(e)}\n{traceback.format_exc()}")
            # Create a basic rule on error
            return self._create_basic_rule(rule_type, description, content, globs, referenced_files)
    
    def _format_model_name(self, model_id: str) -> str:
        """Format a model ID into a human-readable name."""
        # Replace hyphens with spaces and capitalize each word
        name = model_id.replace('-', ' ').title()
        
        # Special case handling
        name = name.replace('Gemini ', 'Gemini ')
        name = name.replace('Pro ', 'Pro ')
        name = name.replace('Flash ', 'Flash ')
        name = name.replace('Lite', 'Lite')
        
        return name
    
    def _create_basic_rule(
        self,
        rule_type: str,
        description: str,
        content: str,
        globs: str = '',
        referenced_files: str = ''
    ) -> str:
        """Create a basic rule in MDC format without using the LLM."""
        # Create MDC format
        mdc = '---\n'
        mdc += f'description: {description}\n'
        
        if rule_type == 'Auto Attached' and globs:
            mdc += f'globs: {globs}\n'
        
        if rule_type == 'Always':
            mdc += 'alwaysApply: true\n'
        else:
            mdc += 'alwaysApply: false\n'
        
        mdc += '---\n\n'
        mdc += content + '\n'
        
        # Add referenced files
        if referenced_files:
            mdc += '\n' + referenced_files
        
        return mdc

# OpenAI Adapter
class OpenAIAdapter(LLMAdapter):
    """Adapter for OpenAI API."""
    
    def __init__(self):
        """Initialize the OpenAI adapter."""
        self.api_key = None
        self.api_url = Settings.OPENAI_API_URL
        self.initialized = False
        self.last_error = None
    
    def initialize(self, api_key: str, **kwargs) -> None:
        """Initialize the adapter with API key and optional parameters."""
        self.api_key = api_key
        self.api_url = kwargs.get('api_url', Settings.OPENAI_API_URL)
        self.initialized = True
    
    def validate_api_key(self, api_key: str) -> bool:
        """Validate the OpenAI API key."""
        try:
            # Try to list models with the provided API key
            url = f"{self.api_url}/models"
            headers = {
                "Authorization": f"Bearer {api_key}"
            }
            response = requests.get(url, headers=headers)
            
            # Check if the request was successful
            if response.status_code == 200:
                return True
            
            # Store error details for debugging
            self.last_error = f"API Error: Status {response.status_code}, Response: {response.text}"
            print(f"OpenAI API validation failed: {self.last_error}")
            return False
        except Exception as e:
            # Store exception details for debugging
            self.last_error = f"Exception: {str(e)}\n{traceback.format_exc()}"
            print(f"OpenAI API validation exception: {self.last_error}")
            return False
    
    def get_available_models(self) -> List[Dict[str, str]]:
        """Get a list of available OpenAI models."""
        if not self.initialized:
            raise ValueError("Adapter not initialized. Call initialize() first.")
        
        try:
            # Get available models
            url = f"{self.api_url}/models"
            headers = {
                "Authorization": f"Bearer {self.api_key}"
            }
            response = requests.get(url, headers=headers)
            
            if response.status_code != 200:
                print(f"Failed to get models: Status {response.status_code}, Response: {response.text}")
                raise ValueError(f"Failed to get models: {response.text}")
            
            data = response.json()
            
            # Filter for chat models and format the response
            models = []
            for model in data.get('data', []):
                model_id = model.get('id')
                if any(prefix in model_id for prefix in ['gpt-4', 'gpt-3.5']):
                    models.append({
                        'id': model_id,
                        'name': self._format_model_name(model_id)
                    })
            
            # If no models found, return default models
            if not models:
                models = [
                    {'id': 'gpt-4o', 'name': 'GPT-4o'},
                    {'id': 'gpt-4-turbo', 'name': 'GPT-4 Turbo'},
                    {'id': 'gpt-3.5-turbo', 'name': 'GPT-3.5 Turbo'}
                ]
            
            return models
        except Exception as e:
            print(f"Exception in get_available_models: {str(e)}\n{traceback.format_exc()}")
            # Return default models on error
            return [
                {'id': 'gpt-4o', 'name': 'GPT-4o'},
                {'id': 'gpt-4-turbo', 'name': 'GPT-4 Turbo'},
                {'id': 'gpt-3.5-turbo', 'name': 'GPT-3.5 Turbo'}
            ]
    
    def generate_rule(
        self, 
        model: str,
        rule_type: str, 
        description: str, 
        content: str, 
        parameters: Optional[Dict[str, Any]] = None
    ) -> str:
        """Generate a Cursor Rule using OpenAI."""
        if not self.initialized:
            raise ValueError("Adapter not initialized. Call initialize() first.")
        
        # Set default parameters if not provided
        if parameters is None:
            parameters = {}
        
        # Extract parameters
        temperature = parameters.get('temperature', Settings.DEFAULT_TEMPERATURE)
        globs = parameters.get('globs', '')
        referenced_files = parameters.get('referenced_files', '')
        prompt = parameters.get('prompt', '')
        
        # Prepare the prompt for OpenAI
        system_prompt = """
        You are a Cursor Rules expert. Create a rule in MDC format based on the provided information.
        
        MDC format example:
        ---
        description: RPC Service boilerplate
        globs: 
        alwaysApply: false
        ---
        
        - Use our internal RPC pattern when defining services
        - Always use snake_case for service names.
        
        @service-template.ts
        """
        
        user_prompt = f"""
        Create a Cursor Rule with the following details:
        
        Rule Type: {rule_type}
        Description: {description}
        Content: {content}
        """
        
        if globs:
            user_prompt += f"\nGlobs: {globs}"
        
        if referenced_files:
            user_prompt += f"\nReferenced Files: {referenced_files}"
        
        if prompt:
            user_prompt += f"\nAdditional Instructions: {prompt}"
        
        # Prepare the API request
        url = f"{self.api_url}/chat/completions"
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": model,
            "messages": [
                {
                    "role": "system",
                    "content": system_prompt
                },
                {
                    "role": "user",
                    "content": user_prompt
                }
            ],
            "temperature": temperature,
            "max_tokens": 2048
        }
        
        # Make the API request
        try:
            response = requests.post(url, headers=headers, json=payload)
            
            if response.status_code != 200:
                print(f"Failed to generate rule: Status {response.status_code}, Response: {response.text}")
                raise ValueError(f"Failed to generate rule: {response.text}")
            
            data = response.json()
            
            # Extract the generated text
            generated_text = data.get('choices', [{}])[0].get('message', {}).get('content', '')
            
            # If no text was generated, create a basic rule
            if not generated_text:
                return self._create_basic_rule(rule_type, description, content, globs, referenced_files)
            
            return generated_text
        except Exception as e:
            print(f"Exception in generate_rule: {str(e)}\n{traceback.format_exc()}")
            # Create a basic rule on error
            return self._create_basic_rule(rule_type, description, content, globs, referenced_files)
    
    def _format_model_name(self, model_id: str) -> str:
        """Format a model ID into a human-readable name."""
        # Replace hyphens with spaces and capitalize each word
        name = model_id.replace('-', ' ').title()
        
        # Special case handling
        name = name.replace('Gpt ', 'GPT ')
        name = name.replace('Gpt4', 'GPT-4')
        name = name.replace('Gpt3', 'GPT-3')
        name = name.replace('Gpt 4', 'GPT-4')
        name = name.replace('Gpt 3', 'GPT-3')
        name = name.replace('Turbo', 'Turbo')
        name = name.replace('O', 'o')
        
        return name
    
    def _create_basic_rule(
        self,
        rule_type: str,
        description: str,
        content: str,
        globs: str = '',
        referenced_files: str = ''
    ) -> str:
        """Create a basic rule in MDC format without using the LLM."""
        # Create MDC format
        mdc = '---\n'
        mdc += f'description: {description}\n'
        
        if rule_type == 'Auto Attached' and globs:
            mdc += f'globs: {globs}\n'
        
        if rule_type == 'Always':
            mdc += 'alwaysApply: true\n'
        else:
            mdc += 'alwaysApply: false\n'
        
        mdc += '---\n\n'
        mdc += content + '\n'
        
        # Add referenced files
        if referenced_files:
            mdc += '\n' + referenced_files
        
        return mdc

# OpenRouter Adapter
class OpenRouterAdapter(LLMAdapter):
    """Adapter for OpenRouter API."""
    
    def __init__(self):
        """Initialize the OpenRouter adapter."""
        self.api_key = None
        self.api_url = Settings.OPENROUTER_API_URL
        self.initialized = False
        self.last_error = None
    
    def initialize(self, api_key: str, **kwargs) -> None:
        """Initialize the adapter with API key and optional parameters."""
        self.api_key = api_key
        self.api_url = kwargs.get('api_url', Settings.OPENROUTER_API_URL)
        self.site_url = kwargs.get('site_url', 'https://cursor-rules-generator.example.com')
        self.site_name = kwargs.get('site_name', 'Cursor Rules Generator')
        self.initialized = True
    
    def validate_api_key(self, api_key: str) -> bool:
        """Validate the OpenRouter API key."""
        try:
            # Try to list models with the provided API key
            url = f"{self.api_url}/models"
            headers = {
                "Authorization": f"Bearer {api_key}"
            }
            response = requests.get(url, headers=headers)
            
            # Check if the request was successful
            if response.status_code == 200:
                return True
            
            # Store error details for debugging
            self.last_error = f"API Error: Status {response.status_code}, Response: {response.text}"
            print(f"OpenRouter API validation failed: {self.last_error}")
            return False
        except Exception as e:
            # Store exception details for debugging
            self.last_error = f"Exception: {str(e)}\n{traceback.format_exc()}"
            print(f"OpenRouter API validation exception: {self.last_error}")
            return False
    
    def get_available_models(self) -> List[Dict[str, str]]:
        """Get a list of available OpenRouter models."""
        if not self.initialized:
            raise ValueError("Adapter not initialized. Call initialize() first.")
        
        try:
            # Get available models
            url = f"{self.api_url}/models"
            headers = {
                "Authorization": f"Bearer {self.api_key}"
            }
            response = requests.get(url, headers=headers)
            
            if response.status_code != 200:
                print(f"Failed to get models: Status {response.status_code}, Response: {response.text}")
                raise ValueError(f"Failed to get models: {response.text}")
            
            data = response.json()
            
            # Format the response
            models = []
            for model in data.get('data', []):
                model_id = model.get('id')
                model_name = model.get('name', model_id)
                
                # Skip non-chat models
                if not model.get('capabilities', {}).get('chat'):
                    continue
                
                models.append({
                    'id': model_id,
                    'name': model_name
                })
            
            # If no models found, return default models
            if not models:
                models = [
                    {'id': 'openai/gpt-4o', 'name': 'OpenAI GPT-4o'},
                    {'id': 'anthropic/claude-3-opus', 'name': 'Anthropic Claude 3 Opus'},
                    {'id': 'google/gemini-2.5-pro', 'name': 'Google Gemini 2.5 Pro'},
                    {'id': 'meta-llama/llama-3-70b-instruct', 'name': 'Meta Llama 3 70B'}
                ]
            
            return models
        except Exception as e:
            print(f"Exception in get_available_models: {str(e)}\n{traceback.format_exc()}")
            # Return default models on error
            return [
                {'id': 'openai/gpt-4o', 'name': 'OpenAI GPT-4o'},
                {'id': 'anthropic/claude-3-opus', 'name': 'Anthropic Claude 3 Opus'},
                {'id': 'google/gemini-2.5-pro', 'name': 'Google Gemini 2.5 Pro'},
                {'id': 'meta-llama/llama-3-70b-instruct', 'name': 'Meta Llama 3 70B'}
            ]
    
    def generate_rule(
        self, 
        model: str,
        rule_type: str, 
        description: str, 
        content: str, 
        parameters: Optional[Dict[str, Any]] = None
    ) -> str:
        """Generate a Cursor Rule using OpenRouter."""
        if not self.initialized:
            raise ValueError("Adapter not initialized. Call initialize() first.")
        
        # Set default parameters if not provided
        if parameters is None:
            parameters = {}
        
        # Extract parameters
        temperature = parameters.get('temperature', Settings.DEFAULT_TEMPERATURE)
        globs = parameters.get('globs', '')
        referenced_files = parameters.get('referenced_files', '')
        prompt = parameters.get('prompt', '')
        
        # Prepare the prompt for OpenRouter
        system_prompt = """
        You are a Cursor Rules expert. Create a rule in MDC format based on the provided information.
        
        MDC format example:
        ---
        description: RPC Service boilerplate
        globs: 
        alwaysApply: false
        ---
        
        - Use our internal RPC pattern when defining services
        - Always use snake_case for service names.
        
        @service-template.ts
        """
        
        user_prompt = f"""
        Create a Cursor Rule with the following details:
        
        Rule Type: {rule_type}
        Description: {description}
        Content: {content}
        """
        
        if globs:
            user_prompt += f"\nGlobs: {globs}"
        
        if referenced_files:
            user_prompt += f"\nReferenced Files: {referenced_files}"
        
        if prompt:
            user_prompt += f"\nAdditional Instructions: {prompt}"
        
        # Prepare the API request
        url = f"{self.api_url}/chat/completions"
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json",
            "HTTP-Referer": self.site_url,
            "X-Title": self.site_name
        }
        
        payload = {
            "model": model,
            "messages": [
                {
                    "role": "system",
                    "content": system_prompt
                },
                {
                    "role": "user",
                    "content": user_prompt
                }
            ],
            "temperature": temperature,
            "max_tokens": 2048
        }
        
        # Make the API request
        try:
            response = requests.post(url, headers=headers, json=payload)
            
            if response.status_code != 200:
                print(f"Failed to generate rule: Status {response.status_code}, Response: {response.text}")
                raise ValueError(f"Failed to generate rule: {response.text}")
            
            data = response.json()
            
            # Extract the generated text
            generated_text = data.get('choices', [{}])[0].get('message', {}).get('content', '')
            
            # If no text was generated, create a basic rule
            if not generated_text:
                return self._create_basic_rule(rule_type, description, content, globs, referenced_files)
            
            return generated_text
        except Exception as e:
            print(f"Exception in generate_rule: {str(e)}\n{traceback.format_exc()}")
            # Create a basic rule on error
            return self._create_basic_rule(rule_type, description, content, globs, referenced_files)
    
    def _create_basic_rule(
        self,
        rule_type: str,
        description: str,
        content: str,
        globs: str = '',
        referenced_files: str = ''
    ) -> str:
        """Create a basic rule in MDC format without using the LLM."""
        # Create MDC format
        mdc = '---\n'
        mdc += f'description: {description}\n'
        
        if rule_type == 'Auto Attached' and globs:
            mdc += f'globs: {globs}\n'
        
        if rule_type == 'Always':
            mdc += 'alwaysApply: true\n'
        else:
            mdc += 'alwaysApply: false\n'
        
        mdc += '---\n\n'
        mdc += content + '\n'
        
        # Add referenced files
        if referenced_files:
            mdc += '\n' + referenced_files
        
        return mdc

# LLM Adapter Factory
class LLMAdapterFactory:
    """Factory for creating LLM adapters."""
    
    @staticmethod
    def create_adapter(provider_name: str) -> LLMAdapter:
        """Create an adapter for the specified provider."""
        provider_name = provider_name.lower()
        
        if provider_name == "gemini":
            return GeminiAdapter()
        elif provider_name == "openai":
            return OpenAIAdapter()
        elif provider_name == "openrouter":
            return OpenRouterAdapter()
        else:
            raise ValueError(f"Unsupported provider: {provider_name}")
    
    @staticmethod
    def get_supported_providers() -> Dict[str, str]:
        """Get a dictionary of supported providers."""
        return {
            "gemini": "Google Gemini",
            "openai": "OpenAI",
            "openrouter": "OpenRouter"
        }

# Rule Generator
class RuleGenerator:
    """Engine for generating Cursor Rules."""
    
    def __init__(self):
        """Initialize the rule generator."""
        self.factory = LLMAdapterFactory()
    
    def create_rule(
        self,
        provider: str,
        model: str,
        rule_type: str,
        description: str,
        content: str,
        api_key: str,
        parameters: Optional[Dict[str, Any]] = None
    ) -> str:
        """Create a Cursor Rule using the specified LLM provider."""
        # Set default parameters if not provided
        if parameters is None:
            parameters = {}
        
        try:
            # Create and initialize the adapter
            adapter = self.factory.create_adapter(provider)
            adapter.initialize(api_key)
            
            # Generate the rule using the adapter
            rule = adapter.generate_rule(model, rule_type, description, content, parameters)
            
            return rule
        except Exception as e:
            print(f"Exception in create_rule: {str(e)}\n{traceback.format_exc()}")
            # If LLM generation fails, create a basic rule
            return self._create_basic_rule(rule_type, description, content, parameters)
    
    def _create_basic_rule(
        self,
        rule_type: str,
        description: str,
        content: str,
        parameters: Optional[Dict[str, Any]] = None
    ) -> str:
        """Create a basic rule in MDC format without using an LLM."""
        # Set default parameters if not provided
        if parameters is None:
            parameters = {}
        
        # Extract parameters
        globs = parameters.get('globs', '')
        referenced_files = parameters.get('referenced_files', '')
        
        # Create MDC format
        mdc = '---\n'
        mdc += f'description: {description}\n'
        
        if rule_type == 'Auto Attached' and globs:
            mdc += f'globs: {globs}\n'
        
        if rule_type == 'Always':
            mdc += 'alwaysApply: true\n'
        else:
            mdc += 'alwaysApply: false\n'
        
        mdc += '---\n\n'
        mdc += content + '\n'
        
        # Add referenced files
        if referenced_files:
            mdc += '\n' + referenced_files
        
        return mdc
    
    def validate_rule_type(self, rule_type: str) -> bool:
        """Validate if the rule type is supported."""
        valid_types = ['Always', 'Auto Attached', 'Agent Requested', 'Manual']
        return rule_type in valid_types
    
    def get_rule_types(self) -> List[Dict[str, str]]:
        """Get a list of supported rule types."""
        return [
            {
                'id': 'Always',
                'name': 'Always',
                'description': 'Always included in the model context'
            },
            {
                'id': 'Auto Attached',
                'name': 'Auto Attached',
                'description': 'Included when files matching glob patterns are referenced'
            },
            {
                'id': 'Agent Requested',
                'name': 'Agent Requested',
                'description': 'Rule is presented to the AI, which decides whether to include it'
            },
            {
                'id': 'Manual',
                'name': 'Manual',
                'description': 'Only included when explicitly referenced using @ruleName'
            }
        ]

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

# Get supported providers
providers = factory.get_supported_providers()
provider_choices = list(providers.keys())

# Get rule types
rule_types = rule_generator.get_rule_types()
rule_type_choices = [rt['id'] for rt in rule_types]

def validate_api_key(provider, api_key):
    """Validate an API key for a specific provider.
    
    Args:
        provider: The LLM provider
        api_key: The API key to validate
        
    Returns:
        tuple: (success, message, model_names, model_ids)
    """
    if not provider or not api_key:
        return False, "Lütfen bir sağlayıcı seçin ve API anahtarı girin.", [], []
    
    try:
        # Create the adapter
        adapter = factory.create_adapter(provider)
        
        # Print debug info
        print(f"Validating {provider} API key: {api_key[:5]}...{api_key[-5:] if len(api_key) > 10 else ''}")
        
        # Validate the API key
        valid = adapter.validate_api_key(api_key)
        
        if valid:
            # Initialize the adapter
            adapter.initialize(api_key)
            
            # Get available models
            models = adapter.get_available_models()
            model_names = [model['name'] for model in models]
            model_ids = [model['id'] for model in models]
            
            print(f"Models found: {model_names}")
            print(f"Model IDs: {model_ids}")
            
            # Use default models if none are returned
            if not model_names or not model_ids:
                if provider == "gemini":
                    model_names = ["Gemini 2.5 Pro", "Gemini 2.0 Flash", "Gemini 2.0 Flash-Lite"]
                    model_ids = ["gemini-2.5-pro", "gemini-2.0-flash", "gemini-2.0-flash-lite"]
                elif provider == "openai":
                    model_names = ["GPT-4o", "GPT-4 Turbo", "GPT-3.5 Turbo"]
                    model_ids = ["gpt-4o", "gpt-4-turbo", "gpt-3.5-turbo"]
                elif provider == "openrouter":
                    model_names = ["OpenAI GPT-4o", "Anthropic Claude 3 Opus", "Google Gemini 2.5 Pro"]
                    model_ids = ["openai/gpt-4o", "anthropic/claude-3-opus", "google/gemini-2.5-pro"]
                
                print(f"Using default models: {model_names}")
            
            return True, "API anahtarı doğrulandı.", model_names, model_ids
        else:
            error_msg = getattr(adapter, 'last_error', 'Bilinmeyen hata')
            return False, f"Geçersiz API anahtarı. Hata: {error_msg}", [], []
    except Exception as e:
        error_details = traceback.format_exc()
        print(f"Exception in validate_api_key: {str(e)}\n{error_details}")
        return False, f"Hata: {str(e)}", [], []

def generate_rule(provider, api_key, model_index, model_ids, rule_type, description, content, globs, referenced_files, prompt, temperature):
    """Generate a Cursor Rule.
    
    Args:
        provider: The LLM provider
        api_key: The API key for the provider
        model_index: The index of the selected model
        model_ids: The list of model IDs
        rule_type: The type of rule to generate
        description: A short description of the rule's purpose
        content: The main content of the rule
        globs: Glob patterns for Auto Attached rules
        referenced_files: Referenced files
        prompt: Additional instructions for the LLM
        temperature: Temperature parameter for generation
        
    Returns:
        tuple: (success, message, rule)
    """
    print(f"Generate rule called with model_index: {model_index}, model_ids: {model_ids}")
    
    if not provider or not api_key:
        return False, "Lütfen bir sağlayıcı seçin ve API anahtarı girin.", ""
    
    if model_index is None or model_index == "":
        return False, "Lütfen bir model seçin. Model seçimi yapılamıyorsa, API anahtarını tekrar doğrulayın.", ""
    
    if not rule_type or not description or not content:
        return False, "Lütfen kural tipi, açıklama ve içerik alanlarını doldurun.", ""
    
    # Convert model_index to integer if it's a string
    try:
        if isinstance(model_index, str) and model_index.isdigit():
            model_index = int(model_index)
    except:
        pass
    
    # Get the model ID
    if not model_ids:
        return False, "Model listesi bulunamadı. Lütfen API anahtarını tekrar doğrulayın.", ""
    
    try:
        model_index = int(model_index)
    except:
        return False, f"Geçersiz model indeksi: {model_index}", ""
    
    if model_index < 0 or model_index >= len(model_ids):
        return False, f"Geçersiz model seçimi. İndeks: {model_index}, Mevcut modeller: {len(model_ids)}", ""
    
    model = model_ids[model_index]
    
    # Validate rule type
    if not rule_generator.validate_rule_type(rule_type):
        return False, f"Geçersiz kural tipi: {rule_type}", ""
    
    # Validate globs for Auto Attached rule type
    if rule_type == 'Auto Attached' and not globs:
        return False, "Auto Attached kural tipi için glob desenleri gereklidir.", ""
    
    try:
        # Prepare parameters
        parameters = {
            'globs': globs,
            'referenced_files': referenced_files,
            'prompt': prompt,
            'temperature': float(temperature) if temperature else 0.7
        }
        
        # 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 True, "Kural başarıyla oluşturuldu.", rule
    except Exception as e:
        error_details = traceback.format_exc()
        print(f"Exception in generate_rule: {str(e)}\n{error_details}")
        return False, f"Kural oluşturulurken bir hata oluştu: {str(e)}", ""

def update_rule_type_info(rule_type):
    """Update the rule type information.
    
    Args:
        rule_type: The selected rule type
        
    Returns:
        str: Information about the selected rule type
    """
    if rule_type == 'Always':
        return "Her zaman model bağlamına dahil edilir."
    elif rule_type == 'Auto Attached':
        return "Glob desenine uyan dosyalar referans alındığında dahil edilir."
    elif rule_type == 'Agent Requested':
        return "Kural AI'ya sunulur, dahil edilip edilmeyeceğine AI karar verir."
    elif rule_type == 'Manual':
        return "Yalnızca @ruleName kullanılarak açıkça belirtildiğinde dahil edilir."
    else:
        return ""

def update_globs_visibility(rule_type):
    """Update the visibility of the globs input.
    
    Args:
        rule_type: The selected rule type
        
    Returns:
        bool: Whether the globs input should be visible
    """
    return rule_type == 'Auto Attached'

# Create Gradio interface
with gr.Blocks(title="Cursor Rules Oluşturucu") as demo:
    gr.Markdown("# Cursor Rules Oluşturucu")
    gr.Markdown("Gemini, OpenRouter, OpenAI API ve tüm modellerini destekleyen dinamik bir Cursor Rules oluşturucu.")
    
    with gr.Row():
        with gr.Column():
            provider = gr.Dropdown(
                choices=provider_choices,
                label="LLM Sağlayıcı",
                value=provider_choices[0] if provider_choices else None
            )
            
            api_key = gr.Textbox(
                label="API Anahtarı",
                placeholder="API anahtarınızı girin",
                type="password"
            )
            
            validate_btn = gr.Button("API Anahtarını Doğrula")
            
            api_status = gr.Textbox(
                label="API Durumu",
                interactive=False
            )
            
            # Default model choices for each provider
            default_models = {
                "gemini": ["Gemini 2.5 Pro", "Gemini 2.0 Flash", "Gemini 2.0 Flash-Lite"],
                "openai": ["GPT-4o", "GPT-4 Turbo", "GPT-3.5 Turbo"],
                "openrouter": ["OpenAI GPT-4o", "Anthropic Claude 3 Opus", "Google Gemini 2.5 Pro"]
            }
            
            model_dropdown = gr.Dropdown(
                label="Model",
                choices=default_models.get(provider_choices[0] if provider_choices else "gemini", []),
                interactive=True
            )
            
            # Hidden field to store model IDs
            model_ids = gr.State([])
            
            rule_type = gr.Dropdown(
                choices=rule_type_choices,
                label="Kural Tipi",
                value=rule_type_choices[0] if rule_type_choices else None
            )
            
            rule_type_info = gr.Textbox(
                label="Kural Tipi Bilgisi",
                interactive=False,
                value=update_rule_type_info(rule_type_choices[0] if rule_type_choices else "")
            )
            
            description = gr.Textbox(
                label="Açıklama",
                placeholder="Kuralın amacını açıklayan kısa bir açıklama"
            )
            
            globs = gr.Textbox(
                label="Glob Desenleri (Auto Attached için)",
                placeholder="Örn: *.ts, src/*.js",
                visible=False
            )
            
            content = gr.Textbox(
                label="Kural İçeriği",
                placeholder="Kuralın ana içeriği",
                lines=10
            )
            
            referenced_files = gr.Textbox(
                label="Referans Dosyaları (İsteğe bağlı)",
                placeholder="Her satıra bir dosya adı girin, örn: @service-template.ts",
                lines=3
            )
            
            prompt = gr.Textbox(
                label="AI Prompt (İsteğe bağlı)",
                placeholder="AI'ya özel talimatlar verin",
                lines=3
            )
            
            temperature = gr.Slider(
                label="Sıcaklık",
                minimum=0.0,
                maximum=1.0,
                value=0.7,
                step=0.1
            )
            
            generate_btn = gr.Button("Kural Oluştur")
        
        with gr.Column():
            generation_status = gr.Textbox(
                label="Durum",
                interactive=False
            )
            
            rule_output = gr.Textbox(
                label="Oluşturulan Kural",
                lines=20,
                interactive=False
            )
            
            download_btn = gr.Button("İndir")
    
    # Provider change handler to update default models
    def update_default_models(provider_value):
        if provider_value == "gemini":
            return gr.Dropdown.update(choices=default_models["gemini"], value=default_models["gemini"][0] if default_models["gemini"] else None)
        elif provider_value == "openai":
            return gr.Dropdown.update(choices=default_models["openai"], value=default_models["openai"][0] if default_models["openai"] else None)
        elif provider_value == "openrouter":
            return gr.Dropdown.update(choices=default_models["openrouter"], value=default_models["openrouter"][0] if default_models["openrouter"] else None)
        else:
            return gr.Dropdown.update(choices=[], value=None)
    
    provider.change(
        fn=update_default_models,
        inputs=[provider],
        outputs=[model_dropdown]
    )
    
    # API key validation
    validate_btn.click(
        fn=validate_api_key,
        inputs=[provider, api_key],
        outputs=[api_status, model_dropdown, model_ids]
    )
    
    # Rule type change
    rule_type.change(
        fn=update_rule_type_info,
        inputs=[rule_type],
        outputs=[rule_type_info]
    )
    
    rule_type.change(
        fn=update_globs_visibility,
        inputs=[rule_type],
        outputs=[globs]
    )
    
    # Generate rule
    generate_btn.click(
        fn=generate_rule,
        inputs=[
            provider, 
            api_key, 
            model_dropdown, 
            model_ids, 
            rule_type, 
            description, 
            content, 
            globs, 
            referenced_files, 
            prompt, 
            temperature
        ],
        outputs=[generation_status, rule_output]
    )
    
    # Download rule
    def download_rule(rule, description):
        if not rule:
            return None
        
        # Create file name from description
        file_name = description.lower().replace(" ", "-").replace("/", "-")
        if not file_name:
            file_name = "cursor-rule"
        
        return {
            "name": f"{file_name}.mdc",
            "data": rule
        }
    
    download_btn.click(
        fn=download_rule,
        inputs=[rule_output, description],
        outputs=[gr.File()]
    )

# Launch the app
if __name__ == "__main__":
    demo.launch(
        server_name="0.0.0.0",
        server_port=int(os.environ.get("PORT", 7860)),
        share=True
    )