Initial commit

app.py

@@ -15,15 +15,29 @@ logger = logging.getLogger(__name__)
 class ChristopherAI:
     def __init__(self):
         self.pipeline = None
+        self.tokenizer = None
+        self.model = None
         self.db_path = "christopher.db"
+        self.supported_languages = {
+            "Python": {"ext": "py", "comment": "#", "multiline_start": '"""', "multiline_end": '"""'},
+            "JavaScript": {"ext": "js", "comment": "//", "multiline_start": "/*", "multiline_end": "*/"},
+            "Java": {"ext": "java", "comment": "//", "multiline_start": "/*", "multiline_end": "*/"},
+            "C++": {"ext": "cpp", "comment": "//", "multiline_start": "/*", "multiline_end": "*/"},
+            "C": {"ext": "c", "comment": "//", "multiline_start": "/*", "multiline_end": "*/"},
+            "PHP": {"ext": "php", "comment": "//", "multiline_start": "/*", "multiline_end": "*/"},
+            "Go": {"ext": "go", "comment": "//", "multiline_start": "/*", "multiline_end": "*/"},
+            "Rust": {"ext": "rs", "comment": "//", "multiline_start": "/*", "multiline_end": "*/"},
+            "HTML": {"ext": "html", "comment": "<!--", "multiline_start": "<!--", "multiline_end": "-->"},
+            "CSS": {"ext": "css", "comment": "/*", "multiline_start": "/*", "multiline_end": "*/"}
+        }
         
     def setup_environment(self):
         """تنظیم محیط و احراز هویت"""
         logger.info("Setting up environment")
         
         # تنظیم timeout ها
-        os.environ["HF_HUB_ETAG_TIMEOUT"] = "120"
-        os.environ["HF_HUB_DOWNLOAD_TIMEOUT"] = "120"
+        os.environ["HF_HUB_ETAG_TIMEOUT"] = "180"
+        os.environ["HF_HUB_DOWNLOAD_TIMEOUT"] = "180"
         
         # احراز هویت (اختیاری)
         hf_token = os.getenv("HF_TOKEN", "")
@@ -35,56 +49,57 @@ class ChristopherAI:
                 logger.warning(f"HF authentication failed: {e}")
     
     def load_model(self):
-        """بارگذاری مدل سبک برای Spaces رایگان"""
-        logger.info("Loading lightweight model")
+        """بارگذاری مدل بهینه برای فارسی"""
+        logger.info("Loading optimized model for Persian")
         
-        try:
-            # استفاده از مدل بسیار سبک و کارآمد
-            model_name = "microsoft/DialoGPT-small"
-            
-            # بارگذاری با کمترین مصرف حافظه
-            tokenizer = AutoTokenizer.from_pretrained(model_name)
-            if tokenizer.pad_token is None:
-                tokenizer.pad_token = tokenizer.eos_token
-            
-            model = AutoModelForCausalLM.from_pretrained(
-                model_name,
-                torch_dtype=torch.float32,  # استفاده از float32 برای سازگاری بیشتر
-                low_cpu_mem_usage=True,
-                device_map=None  # فقط CPU
-            )
-            
-            # ایجاد pipeline ساده
-            self.pipeline = pipeline(
-                "text-generation",
-                model=model,
-                tokenizer=tokenizer,
-                device=-1,  # فورس CPU
-                framework="pt"
-            )
-            
-            logger.info("Lightweight model loaded successfully")
-            
-        except Exception as e:
-            logger.error(f"Model loading failed: {e}")
-            # fallback به مدل ساده‌تر
+        model_options = [
+            "microsoft/DialoGPT-medium",  # ~355M parameters
+            "distilgpt2",  # ~82M parameters  
+            "microsoft/DialoGPT-small",  # ~117M parameters
+            "gpt2"  # ~124M parameters - fallback
+        ]
+        
+        for model_name in model_options:
             try:
-                logger.info("Using fallback: GPT2 model")
+                logger.info(f"Trying to load: {model_name}")
+                
+                # بارگذاری tokenizer
+                self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+                if self.tokenizer.pad_token is None:
+                    self.tokenizer.pad_token = self.tokenizer.eos_token
+                
+                # بارگذاری مدل با تنظیمات بهینه
+                self.model = AutoModelForCausalLM.from_pretrained(
+                    model_name,
+                    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+                    low_cpu_mem_usage=True,
+                    device_map="auto" if torch.cuda.is_available() else None
+                )
+                
+                # ایجاد pipeline
+                device = 0 if torch.cuda.is_available() else -1
                 self.pipeline = pipeline(
-                    "text-generation", 
-                    model="gpt2",
-                    device=-1,
-                    framework="pt"
+                    "text-generation",
+                    model=self.model,
+                    tokenizer=self.tokenizer,
+                    device=device,
+                    framework="pt",
+                    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32
                 )
-                logger.info("Fallback model loaded")
-            except Exception as e2:
-                logger.error(f"All models failed: {e2}")
-                # آخرین گزینه: استفاده از template-based generation
-                self.pipeline = None
-                logger.info("Using template-based generation")
+                
+                logger.info(f"Successfully loaded: {model_name}")
+                break
+                
+            except Exception as e:
+                logger.error(f"Failed to load {model_name}: {e}")
+                continue
+        
+        if self.pipeline is None:
+            logger.error("All models failed to load")
+            raise Exception("Could not load any model")
     
     def init_database(self):
-        """ایجاد دیتابیس ساده"""
+        """ایجاد دیتابیس"""
         logger.info("Initializing database")
         try:
             with sqlite3.connect(self.db_path) as conn:
@@ -100,12 +115,12 @@ class ChristopherAI:
                     )
                 ''')
                 conn.commit()
-                logger.info("Database initialized")
+                logger.info("Database initialized successfully")
         except Exception as e:
-            logger.error(f"Database error: {e}")
+            logger.error(f"Database initialization error: {e}")
     
     def save_conversation(self, user_input, task_type, language, response):
-        """ذخیره مکالمه"""
+        """ذخیره مکالمه در دیتابیس"""
         try:
             with sqlite3.connect(self.db_path) as conn:
                 cursor = conn.cursor()
@@ -115,10 +130,10 @@ class ChristopherAI:
                 ''', (user_input, task_type, language, response))
                 conn.commit()
         except Exception as e:
-            logger.error(f"Save error: {e}")
+            logger.error(f"Save conversation error: {e}")
     
-    def get_history(self, limit=5):
-        """دریافت تاریخچه (محدود برای صرفه‌جویی در حافظه)"""
+    def get_history(self, limit=10):
+        """دریافت تاریخچه مکالمات"""
         try:
             with sqlite3.connect(self.db_path) as conn:
                 cursor = conn.cursor()
@@ -131,135 +146,241 @@ class ChristopherAI:
                 
                 records = cursor.fetchall()
                 if not records:
-                    return "هیچ تاریخچه‌ای یافت نشد."
+                    return "📋 هیچ تاریخچه‌ای یافت نشد."
                 
-                history_text = "📋 **آخرین درخواست‌ها:**\n\n"
+                history_text = "📋 **تاریخچه درخواست‌های اخیر:**\n\n"
                 for i, record in enumerate(records, 1):
                     user_input, task_type, lang, code, timestamp = record
-                    history_text += f"**{i}. {timestamp}**\n"
-                    history_text += f"🔸 {task_type} - {lang}\n"
-                    history_text += f"🔸 {user_input[:80]}{'...' if len(user_input) > 80 else ''}\n"
-                    history_text += "─" * 30 + "\n\n"
+                    history_text += f"**{i}. {timestamp.split('.')[0]}**\n"
+                    history_text += f"🔹 **نوع وظیفه:** {task_type}\n"
+                    history_text += f"🔹 **زبان:** {lang}\n"
+                    history_text += f"🔹 **درخواست:** {user_input[:100]}{'...' if len(user_input) > 100 else ''}\n"
+                    history_text += "─" * 50 + "\n\n"
                 
                 return history_text
                 
         except Exception as e:
-            return f"خطا در دریافت تاریخچه: {str(e)}"
+            return f"❌ خطا در دریافت تاریخچه: {str(e)}"
+    
+    def create_persian_prompt(self, user_input, programming_language, task_type):
+        """ایجاد prompt فارسی برای مدل"""
+        
+        lang_info = self.supported_languages.get(programming_language, self.supported_languages["Python"])
+        
+        if task_type == "تولید کد جدید":
+            prompt = f"""شما یک برنامه‌نویس حرفه‌ای هستید. لطفاً برای درخواست زیر کد {programming_language} بنویسید:
+
+درخواست: {user_input}
+
+کد {programming_language}:
+```{programming_language.lower()}
+"""
+        
+        elif task_type == "رفع اشکال کد":
+            prompt = f"""شما یک برنامه‌نویس حرفه‌ای هستید. کد زیر را بررسی کرده و اشکالات آن را برطرف کنید:
+
+کد {programming_language} با مشکل:
+{user_input}
+
+کد اصلاح شده:
+```{programming_language.lower()}
+"""
+        
+        elif task_type == "توضیح کد":
+            prompt = f"""شما یک برنامه‌نویس حرفه‌ای هستید. کد زیر را به زبان فارسی توضیح دهید:
+
+کد {programming_language}:
+{user_input}
+
+توضیح به فارسی:
+"""
+        
+        elif task_type == "بهبود کد":
+            prompt = f"""شما یک برنامه‌نویس حرفه‌ای هستید. کد زیر را بهبود دهید و بهینه‌تر کنید:
+
+کد {programming_language} اولیه:
+{user_input}
+
+کد بهبود یافته:
+```{programming_language.lower()}
+"""
+        
+        elif task_type == "اضافه کردن قابلیت":
+            prompt = f"""شما یک برنامه‌نویس حرفه‌ای هستید. به کد زیر قابلیت جدید اضافه کنید:
+
+کد {programming_language} موجود:
+{user_input}
+
+کد با قابلیت جدید:
+```{programming_language.lower()}
+"""
+        
+        else:  # تحلیل کد
+            prompt = f"""شما یک برنامه‌نویس حرفه‌ای هستید. کد زیر را تحلیل کرده و نقاط قوت و ضعف آن را بیان کنید:
+
+کد {programming_language}:
+{user_input}
+
+تحلیل کد:
+"""
+        
+        return prompt
     
-    def generate_with_template(self, user_input, programming_language, task_type):
-        """تولید کد با استفاده از template (برای زمانی که مدل کار نکند)"""
+    def generate_code_with_model(self, user_input, programming_language, task_type):
+        """تولید کد با استفاده از مدل"""
+        try:
+            prompt = self.create_persian_prompt(user_input, programming_language, task_type)
+            
+            # تنظیمات تولید
+            generation_kwargs = {
+                "max_new_tokens": 300,
+                "temperature": 0.7,
+                "do_sample": True,
+                "top_p": 0.9,
+                "top_k": 50,
+                "repetition_penalty": 1.1,
+                "pad_token_id": self.tokenizer.eos_token_id,
+                "num_return_sequences": 1
+            }
+            
+            # تولید پاسخ
+            response = self.pipeline(prompt, **generation_kwargs)
+            generated_text = response[0]['generated_text']
+            
+            # استخراج پاسخ (حذف prompt از ابتدا)
+            result = generated_text[len(prompt):].strip()
+            
+            # پردازش و تمیز کردن پاسخ
+            if "```" in result:
+                # اگر کد در markdown باشد، آن را استخراج کن
+                parts = result.split("```")
+                if len(parts) > 2:
+                    result = parts[1].strip()
+                    if result.startswith(programming_language.lower()):
+                        result = result[len(programming_language.lower()):].strip()
+            
+            return result if result else "متأسفانه نتوانستم پاسخ مناسبی تولید کنم."
+            
+        except Exception as e:
+            logger.error(f"Model generation error: {e}")
+            return self.generate_fallback_response(user_input, programming_language, task_type)
+    
+    def generate_fallback_response(self, user_input, programming_language, task_type):
+        """تولید پاسخ جایگزین در صورت خرابی مدل"""
+        lang_info = self.supported_languages.get(programming_language, self.supported_languages["Python"])
+        
         templates = {
             "Python": {
-                "تولید کد جدید": f"""# کد Python برای: {user_input}
+                "تولید کد جدید": f"""{lang_info['comment']} کد Python برای: {user_input}
 
 def main():
-    # {user_input}
-    # کد شما اینجا قرار می‌گیرد
+    {lang_info['comment']} {user_input}
+    {lang_info['comment']} TODO: پیاده‌سازی منطق مورد نیاز
     pass
 
 if __name__ == "__main__":
     main()
 
-# توضیح:
-# این یک قالب ساده برای شروع کدنویسی است
-# لطفاً کد مناسب را جایگزین کنید
-""",
-                "رفع اشکال کد": f"""# بررسی کد برای رفع اشکال:
-
-# کد اصلی:
-{user_input}
+{lang_info['multiline_start']}
+توضیح:
+- این یک قالب پایه برای شروع کدنویسی است
+- لطفاً منطق مناسب را جایگزین کنید
+- از بهترین شیوه‌های Python استفاده کنید
+{lang_info['multiline_end']}""",
+                
+                "رفع اشکال کد": f"""{lang_info['comment']} بررسی کد برای رفع اشکال:
+{lang_info['comment']} کد اصلی: {user_input}
 
-# نکات احتمالی:
-# 1. بررسی syntax
-# 2. بررسی indentation
-# 3. بررسی نام متغیرها
-# 4. بررسی import ها
-""",
-                "توضیح کد": f"""# توضیح کد Python:
+{lang_info['multiline_start']}
+نکات بررسی:
+1. syntax و indentation
+2. نام‌گذاری متغیرها
+3. import های مورد نیاز
+4. منطق الگوریتم
+5. مدیریت خطا
+{lang_info['multiline_end']}""",
+                
+                "توضیح کد": f"""{lang_info['multiline_start']}
+توضیح کد Python:
 
+کد مورد بررسی:
 {user_input}
 
-# این کد:
-# - عملکرد اصلی: [توضیح کلی]
-# - ورودی: [نوع ورودی]
-# - خروجی: [نوع خروجی]
-# - پیچیدگی: [زمانی/فضایی]
-""",
+تحلیل:
+- هدف: [توضیح عملکرد کلی]
+- ورودی: [نوع و توضیح ورودی‌ها]
+- خروجی: [نوع و توضیح خروجی‌ها]
+- پیچیدگی زمانی: [Big O notation]
+- پیچیدگی فضایی: [استفاده از حافظه]
+- نکات مهم: [نکات خاص کد]
+{lang_info['multiline_end']}"""
             },
+            
             "JavaScript": {
-                "تولید کد جدید": f"""// کد JavaScript برای: {user_input}
+                "تولید کد جدید": f"""{lang_info['comment']} کد JavaScript برای: {user_input}
 
 function main() {{
-    // {user_input}
-    // کد شما اینجا قرار می‌گیرد
+    {lang_info['comment']} {user_input}
+    {lang_info['comment']} TODO: پیاده‌سازی منطق مورد نیاز
 }}
 
+{lang_info['comment']} اجرای تابع
 main();
 
-/* توضیح:
- * این یک قالب ساده برای شروع کدنویسی است
- * لطفاً کد مناسب را جایگزین کنید
- */
-""",
+{lang_info['multiline_start']}
+توضیح:
+- این یک قالب پایه برای شروع کدنویسی JavaScript است
+- از ES6+ features استفاده کنید
+- کد را مدولار و خوانا نگه دارید
+{lang_info['multiline_end']}""",
             }
         }
         
         # انتخاب template مناسب
         lang_templates = templates.get(programming_language, templates["Python"])
-        return lang_templates.get(task_type, f"# کد {programming_language} برای: {user_input}\n\n// لطفاً کد مناسب را اینجا بنویسید")
+        default_template = f"""{lang_info['comment']} کد {programming_language} برای: {user_input}
+
+{lang_info['comment']} TODO: پیاده‌سازی کد مناسب
+
+{lang_info['multiline_start']}
+این یک قالب پایه است.
+لطفاً کد مناسب را بر اساس درخواست خود پیاده‌سازی کنید.
+{lang_info['multiline_end']}"""
+        
+        return lang_templates.get(task_type, default_template)
     
-    def generate_code(self, user_input, programming_language, task_type):
-        """تولید کد با مدل یا template"""
+    def process_request(self, user_input, task_type, programming_language):
+        """پردازش درخواست کاربر"""
+        
+        # بررسی ورودی
+        if not user_input or not user_input.strip():
+            return "⚠️ لطفاً متن درخواست خود را وارد کنید."
+        
+        # نمایش تاریخچه
+        if task_type == "نمایش تاریخچه":
+            return self.get_history()
+        
+        # تنظیم زبان پیش‌فرض
+        if not programming_language or programming_language not in self.supported_languages:
+            programming_language = "Python"
+        
+        # تولید پاسخ
         try:
-            if self.pipeline is None:
-                # استفاده از template
-                result = self.generate_with_template(user_input, programming_language, task_type)
+            if self.pipeline:
+                result = self.generate_code_with_model(user_input, programming_language, task_type)
             else:
-                # تولید با مدل
-                if task_type == "تولید کد جدید":
-                    prompt = f"Generate {programming_language} code for: {user_input}\n\n```{programming_language.lower()}\n"
-                elif task_type == "رفع اشکال کد":
-                    prompt = f"Fix this {programming_language} code:\n{user_input}\n\nFixed code:\n```{programming_language.lower()}\n"
-                elif task_type == "توضیح کد":
-                    prompt = f"Explain this {programming_language} code in Persian:\n{user_input}\n\nتوضیح:"
-                else:
-                    prompt = f"Improve this {programming_language} code:\n{user_input}\n\nImproved code:\n```{programming_language.lower()}\n"
-                
-                # تولید با پارامترهای محدود برای صرفه‌جویی در حافظه
-                response = self.pipeline(
-                    prompt,
-                    max_length=len(prompt.split()) + 150,  # طول محدود
-                    num_return_sequences=1,
-                    temperature=0.7,
-                    do_sample=True,
-                    pad_token_id=50256  # GPT2 pad token
-                )
-                
-                result = response[0]['generated_text'][len(prompt):].strip()
+                result = self.generate_fallback_response(user_input, programming_language, task_type)
             
             # ذخیره در دیتابیس
             self.save_conversation(user_input, task_type, programming_language, result)
+            
             return result
             
         except Exception as e:
-            logger.error(f"Generation error: {e}")
-            # fallback به template
-            return self.generate_with_template(user_input, programming_language, task_type)
-    
-    def process_request(self, user_input, task_type, programming_language):
-        """پردازش درخواست"""
-        if not user_input or not user_input.strip():
-            return "لطفاً متن درخواست خود را وارد کنید."
-        
-        if task_type == "نمایش تاریخچه":
-            return self.get_history()
-        
-        if not programming_language or not programming_language.strip():
-            programming_language = "Python"  # پیش‌فرض
-        
-        return self.generate_code(user_input, programming_language, task_type)
+            logger.error(f"Request processing error: {e}")
+            return f"❌ خطا در پردازش درخواست: {str(e)}"
 
-# ایجاد instance
+# ایجاد instance global
 christopher = ChristopherAI()
 
 def gradio_interface(user_input, task_type, programming_language):
@@ -267,95 +388,135 @@ def gradio_interface(user_input, task_type, programming_language):
     return christopher.process_request(user_input, task_type, programming_language)
 
 def main():
-    """تابع اصلی"""
+    """تابع اصلی برنامه"""
     try:
-        logger.info("🚀 Starting Christopher AI (Lightweight)")
+        logger.info("🚀 راه‌اندازی کریستوفر - دستیار کدنویسی فارسی")
         
-        # راه‌اندازی
+        # راه‌اندازی اولیه
         christopher.setup_environment()
         christopher.init_database()
         christopher.load_model()
         
         # آزادسازی حافظه
         gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
         
-        logger.info("🎯 Creating simple Gradio interface")
+        logger.info("✅ راه‌اندازی کامل شد")
         
-        # رابط ساده برای کاهش مصرف حافظه
-        interface = gr.Interface(
-            fn=gradio_interface,
-            inputs=[
-                gr.Textbox(
-                    label="📝 درخواست یا کد شما",
-                    placeholder="مثال: تابع محاسبه فاکتوریل بنویس",
-                    lines=4
-                ),
-                gr.Dropdown(
-                    choices=[
-                        "تولید کد جدید",
-                        "رفع اشکال کد", 
-                        "توضیح کد",
-                        "بهبود کد",
-                        "نمایش تاریخچه"
-                    ],
-                    label="🎯 نوع وظیفه",
-                    value="تولید کد جدید"
-                ),
-                gr.Textbox(
-                    label="🔧 زبان برنامه‌نویسی",
-                    placeholder="Python, JavaScript, Java, ...",
-                    value="Python"
-                )
-            ],
-            outputs=gr.Textbox(
-                label="📤 پاسخ کریستوفر",
-                lines=10,
-                show_copy_button=True
-            ),
-            title="🤖 کریستوفر - دستیار کدنویسی (نسخه سبک)",
-            description="""
-            ### 🚀 دستیار هوشمند کدنویسی برای Spaces رایگان
+        # ایجاد رابط Gradio
+        with gr.Blocks(
+            theme=gr.themes.Soft(),
+            title="کریستوفر - دستیار کدنویسی فارسی"
+        ) as interface:
             
-            **قابلیت‌ها:**
+            gr.Markdown("""
+            # 🤖 کریستوفر - دستیار هوشمند کدنویسی
+            ### 🇮🇷 پشتیبانی کامل از زبان فارسی
+            
+            **قابلیت‌های کریستوفر:**
             - 💻 تولید کد از توضیحات فارسی
-            - 🔧 رفع اشکالات کد  
-            - 📚 توضیح کد به فارسی
-            - ⚡ بهبود کد
-            - 📋 تاریخچه درخواست‌ها
+            - 🔧 رفع اشکالات و دیباگ کد
+            - 📚 توضیح کد به زبان فارسی
+            - ⚡ بهبود و بهینه‌سازی کد
+            - 🔄 اضافه کردن قابلیت‌های جدید
+            - 🔍 تحلیل و بررسی کد
+            - 📋 ذخیره و مشاهده تاریخچه
             
-            *نسخه بهینه شده برای حافظه محدود*
-            """,
-            examples=[
-                ["تابع محاسبه فاکتوری�� بنویس", "تولید کد جدید", "Python"],
-                ["function hello() { console.log('hi') }", "توضیح کد", "JavaScript"],
-                ["", "نمایش تاریخچه", ""]
-            ],
-            theme=gr.themes.Soft(),
-            allow_flagging="never"
-        )
+            **زبان‌های پشتیبانی شده:** Python, JavaScript, Java, C++, C, PHP, Go, Rust, HTML, CSS
+            """)
+            
+            with gr.Row():
+                with gr.Column(scale=2):
+                    user_input = gr.Textbox(
+                        label="📝 درخواست شما (به فارسی)",
+                        placeholder="مثال: یک تابع برای محاسبه فاکتوریل بنویس که از recursion استفاده کند",
+                        lines=4,
+                        max_lines=8
+                    )
+                    
+                    with gr.Row():
+                        task_type = gr.Dropdown(
+                            choices=[
+                                "تولید کد جدید",
+                                "رفع اشکال کد",
+                                "توضیح کد",
+                                "بهبود کد",
+                                "اضافه کردن قابلیت",
+                                "تحلیل کد",
+                                "نمایش تاریخچه"
+                            ],
+                            label="🎯 نوع وظیفه",
+                            value="تولید کد جدید"
+                        )
+                        
+                        programming_language = gr.Dropdown(
+                            choices=list(christopher.supported_languages.keys()),
+                            label="💾 زبان برنامه‌نویسی",
+                            value="Python"
+                        )
+                    
+                    submit_btn = gr.Button("🚀 اجرا", variant="primary", size="lg")
+                
+                with gr.Column(scale=3):
+                    output = gr.Textbox(
+                        label="📤 پاسخ کریستوفر",
+                        lines=15,
+                        max_lines=25,
+                        show_copy_button=True,
+                        container=True
+                    )
+            
+            # مثال‌هایی برای کاربران
+            gr.Examples(
+                examples=[
+                    ["یک تابع برای مرتب‌سازی لیست اعداد به روش bubble sort بنویس", "تولید کد جدید", "Python"],
+                    ["function factorial(n) {\n  if (n <= 1) return 1;\n  return n * factorial(n-1);\n}", "توضیح کد", "JavaScript"],
+                    ["def add(a, b):\nreturn a + b\n\nprint add(5, 3)", "رفع اشکال کد", "Python"],
+                    ["یک کلاس Calculator با عملیات پایه ریاضی بساز", "تولید کد جدید", "Java"],
+                    ["", "نمایش تاریخچه", ""]
+                ],
+                inputs=[user_input, task_type, programming_language]
+            )
+            
+            # اتصال دکمه submit
+            submit_btn.click(
+                fn=gradio_interface,
+                inputs=[user_input, task_type, programming_language],
+                outputs=output
+            )
+            
+            # اجرای خودکار با Enter
+            user_input.submit(
+                fn=gradio_interface,
+                inputs=[user_input, task_type, programming_language],
+                outputs=output
+            )
         
-        logger.info("🌟 Launching interface")
+        logger.info("🌟 راه‌اندازی رابط کاربری")
         interface.launch(
             server_name="0.0.0.0",
             server_port=7860,
             show_error=True,
             share=False,
             debug=False,
-            max_threads=2  # محدود کردن thread ها
+            max_threads=4
         )
         
     except Exception as e:
-        logger.error(f"❌ Startup failed: {e}")
-        # اجرای اضطراری بدون مدل
+        logger.error(f"❌ خطا در راه‌اندازی: {e}")
+        
+        # رابط اضطراری
         simple_interface = gr.Interface(
-            fn=lambda x, y, z: f"خطا در بارگذاری مدل. درخواست شما: {x}",
+            fn=lambda x, y, z: f"⚠️ خطا در بارگذاری مدل.\n\nدرخواست شما: {x}\nنوع وظیفه: {y}\nزبان: {z}\n\nلطفاً دوباره تلاش کنید.",
             inputs=[
-                gr.Textbox(label="درخواست"),
-                gr.Dropdown(choices=["تولید کد جدید"], value="تولید کد جدید"),
-                gr.Textbox(label="زبان", value="Python")
+                gr.Textbox(label="📝 درخواست", placeholder="درخواست خود را وارد کنید"),
+                gr.Dropdown(choices=["تولید کد جدید"], value="تولید کد جدید", label="🎯 نوع وظیفه"),
+                gr.Dropdown(choices=["Python"], value="Python", label="💾 زبان")
             ],
-            outputs=gr.Textbox(label="پاسخ"),
-            title="کریستوفر - حالت اضطراری"
+            outputs=gr.Textbox(label="📤 پاسخ", lines=10),
+            title="🤖 کریستوفر - حالت اضطراری",
+            description="مدل در حال بارگذاری است. لطفاً کمی صبر کنید."
         )
         simple_interface.launch(server_name="0.0.0.0", server_port=7860)