Initial commit

app.py

@@ -3,8 +3,6 @@ import logging
 import sqlite3
 from datetime import datetime
 import gradio as gr
-from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
-from huggingface_hub import login
 import gc
 import torch
 
@@ -14,89 +12,435 @@ 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": "*/"}
+            "Python": {"ext": "py", "comment": "#"},
+            "JavaScript": {"ext": "js", "comment": "//"},
+            "Java": {"ext": "java", "comment": "//"},
+            "C++": {"ext": "cpp", "comment": "//"},
+            "C": {"ext": "c", "comment": "//"},
+            "PHP": {"ext": "php", "comment": "//"},
+            "Go": {"ext": "go", "comment": "//"},
+            "Rust": {"ext": "rs", "comment": "//"},
+            "HTML": {"ext": "html", "comment": "<!--"},
+            "CSS": {"ext": "css", "comment": "/*"}
         }
         
-    def setup_environment(self):
-        """تنظیم محیط و احراز هویت"""
-        logger.info("Setting up environment")
+        # قالب‌های کد برای زبان‌های مختلف
+        self.code_templates = self._initialize_templates()
         
-        # تنظیم timeout ها
-        os.environ["HF_HUB_ETAG_TIMEOUT"] = "180"
-        os.environ["HF_HUB_DOWNLOAD_TIMEOUT"] = "180"
+    def _initialize_templates(self):
+        """ایجاد قالب‌های کد برای زبان‌های مختلف"""
+        return {
+            "Python": {
+                "فاکتوریل": """def factorial(n):
+    \"\"\"محاسبه فاکتوریل عدد n\"\"\"
+    if n <= 1:
+        return 1
+    return n * factorial(n - 1)
+
+# تست
+print(f"فاکتوریل 5: {factorial(5)}")""",
+
+                "مرتب‌سازی": """def bubble_sort(arr):
+    \"\"\"مرتب‌سازی حبابی\"\"\"
+    n = len(arr)
+    for i in range(n):
+        for j in range(0, n - i - 1):
+            if arr[j] > arr[j + 1]:
+                arr[j], arr[j + 1] = arr[j + 1], arr[j]
+    return arr
+
+# تست
+numbers = [64, 34, 25, 12, 22, 11, 90]
+sorted_numbers = bubble_sort(numbers.copy())
+print(f"آرایه مرتب شده: {sorted_numbers}")""",
+
+                "کلاس": """class Student:
+    \"\"\"کلاس دانشجو\"\"\"
+    
+    def __init__(self, name, student_id, grade):
+        self.name = name
+        self.student_id = student_id
+        self.grade = grade
+    
+    def get_info(self):
+        return f"نام: {self.name}, شماره دانشجویی: {self.student_id}, نمره: {self.grade}"
+    
+    def set_grade(self, new_grade):
+        self.grade = new_grade
+        print(f"نمره {self.name} به {new_grade} تغییر یافت")
+
+# تست
+student = Student("علی احمدی", "98123456", 18.5)
+print(student.get_info())""",
+
+                "فایل": """import os
+
+def read_file(filename):
+    \"\"\"خواندن فایل\"\"\"
+    try:
+        with open(filename, 'r', encoding='utf-8') as file:
+            content = file.read()
+        return content
+    except FileNotFoundError:
+        return "فایل یافت نشد"
+    except Exception as e:
+        return f"خطا: {str(e)}"
+
+def write_file(filename, content):
+    \"\"\"نوشتن در فایل\"\"\"
+    try:
+        with open(filename, 'w', encoding='utf-8') as file:
+            file.write(content)
+        return "فایل با موفقیت ذخیره شد"
+    except Exception as e:
+        return f"خطا در ذخیره: {str(e)}"
+
+# تست
+content = "سلام، این یک فایل تست است"
+write_file("test.txt", content)
+print(read_file("test.txt"))""",
+
+                "API": """import requests
+import json
+
+class APIClient:
+    \"\"\"کلاس برای کار با API\"\"\"
+    
+    def __init__(self, base_url):
+        self.base_url = base_url
+        self.headers = {'Content-Type': 'application/json'}
+    
+    def get(self, endpoint):
+        \"\"\"درخواست GET\"\"\"
+        try:
+            response = requests.get(f"{self.base_url}/{endpoint}")
+            return response.json()
+        except Exception as e:
+            return {"error": str(e)}
+    
+    def post(self, endpoint, data):
+        \"\"\"درخواست POST\"\"\"
+        try:
+            response = requests.post(
+                f"{self.base_url}/{endpoint}", 
+                json=data, 
+                headers=self.headers
+            )
+            return response.json()
+        except Exception as e:
+            return {"error": str(e)}
+
+# تست
+api = APIClient("https://jsonplaceholder.typicode.com")
+posts = api.get("posts/1")
+print(posts)""",
+
+                "دیتابیس": """import sqlite3
+
+class DatabaseManager:
+    \"\"\"مدیریت دیتابیس SQLite\"\"\"
+    
+    def __init__(self, db_name):
+        self.db_name = db_name
+        self.create_table()
+    
+    def create_table(self):
+        \"\"\"ایجاد جدول\"\"\"
+        with sqlite3.connect(self.db_name) as conn:
+            cursor = conn.cursor()
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS users (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    name TEXT NOT NULL,
+                    email TEXT UNIQUE NOT NULL,
+                    age INTEGER
+                )
+            ''')
+            conn.commit()
+    
+    def add_user(self, name, email, age):
+        \"\"\"اضافه کردن کاربر\"\"\"
+        try:
+            with sqlite3.connect(self.db_name) as conn:
+                cursor = conn.cursor()
+                cursor.execute(
+                    "INSERT INTO users (name, email, age) VALUES (?, ?, ?)",
+                    (name, email, age)
+                )
+                conn.commit()
+                return "کاربر با موفقیت اضافه شد"
+        except Exception as e:
+            return f"خطا: {str(e)}"
+    
+    def get_users(self):
+        \"\"\"دریافت تمام کاربران\"\"\"
+        with sqlite3.connect(self.db_name) as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM users")
+            return cursor.fetchall()
+
+# تست
+db = DatabaseManager("users.db")
+print(db.add_user("علی احمدی", "[email protected]", 25))
+print(db.get_users())"""
+            },
+            
+            "JavaScript": {
+                "فاکتوریل": """// محاسبه فاکتوریل
+function factorial(n) {
+    if (n <= 1) {
+        return 1;
+    }
+    return n * factorial(n - 1);
+}
+
+// روش iterative
+function factorialIterative(n) {
+    let result = 1;
+    for (let i = 2; i <= n; i++) {
+        result *= i;
+    }
+    return result;
+}
+
+// تست
+console.log(`فاکتوریل 5: ${factorial(5)}`);
+console.log(`فاکتوریل 5 (روش iterative): ${factorialIterative(5)}`);""",
+
+                "مرتب‌سازی": """// مرتب‌سازی حبابی
+function bubbleSort(arr) {
+    const n = arr.length;
+    const sortedArr = [...arr]; // کپی آرایه
+    
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n - i - 1; j++) {
+            if (sortedArr[j] > sortedArr[j + 1]) {
+                // جابجایی
+                [sortedArr[j], sortedArr[j + 1]] = [sortedArr[j + 1], sortedArr[j]];
+            }
+        }
+    }
+    return sortedArr;
+}
+
+// تست
+const numbers = [64, 34, 25, 12, 22, 11, 90];
+const sorted = bubbleSort(numbers);
+console.log(`آرایه اصلی: ${numbers}`);
+console.log(`آرایه مرتب شده: ${sorted}`);""",
+
+                "کلاس": """// کلاس دانشجو
+class Student {
+    constructor(name, studentId, grade) {
+        this.name = name;
+        this.studentId = studentId;
+        this.grade = grade;
+    }
+    
+    getInfo() {
+        return `نام: ${this.name}, شماره دانشجویی: ${this.studentId}, نمره: ${this.grade}`;
+    }
+    
+    setGrade(newGrade) {
+        this.grade = newGrade;
+        console.log(`نمره ${this.name} به ${newGrade} تغییر یافت`);
+    }
+    
+    isPassed() {
+        return this.grade >= 10;
+    }
+}
+
+// تست
+const student = new Student("علی احمدی", "98123456", 18.5);
+console.log(student.getInfo());
+console.log(`آیا قبول شده؟ ${student.isPassed() ? 'بله' : 'خیر'}`);""",
+
+                "API": """// کلاس برای کار با API
+class APIClient {
+    constructor(baseURL) {
+        this.baseURL = baseURL;
+    }
+    
+    async get(endpoint) {
+        try {
+            const response = await fetch(`${this.baseURL}/${endpoint}`);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            return await response.json();
+        } catch (error) {
+            console.error('خطا در درخواست GET:', error);
+            return { error: error.message };
+        }
+    }
+    
+    async post(endpoint, data) {
+        try {
+            const response = await fetch(`${this.baseURL}/${endpoint}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(data)
+            });
+            
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            return await response.json();
+        } catch (error) {
+            console.error('خطا در درخواست POST:', error);
+            return { error: error.message };
+        }
+    }
+}
+
+// تست
+const api = new APIClient('https://jsonplaceholder.typicode.com');
+api.get('posts/1').then(post => console.log(post));""",
+
+                "DOM": """// کار با DOM
+class DOMHelper {
+    // انتخاب عنصر
+    static select(selector) {
+        return document.querySelector(selector);
+    }
+    
+    // انتخاب چندین عنصر
+    static selectAll(selector) {
+        return document.querySelectorAll(selector);
+    }
+    
+    // ایجاد عنصر
+    static create(tagName, attributes = {}, textContent = '') {
+        const element = document.createElement(tagName);
         
-        # احراز هویت (اختیاری)
-        hf_token = os.getenv("HF_TOKEN", "")
-        if hf_token:
-            try:
-                login(token=hf_token)
-                logger.info("HF authentication successful")
-            except Exception as e:
-                logger.warning(f"HF authentication failed: {e}")
-    
-    def load_model(self):
-        """بارگذاری مدل بهینه برای فارسی"""
-        logger.info("Loading optimized model for Persian")
+        // اضافه کردن attributes
+        Object.keys(attributes).forEach(key => {
+            element.setAttribute(key, attributes[key]);
+        });
         
-        model_options = [
-            "microsoft/DialoGPT-medium",  # ~355M parameters
-            "distilgpt2",  # ~82M parameters  
-            "microsoft/DialoGPT-small",  # ~117M parameters
-            "gpt2"  # ~124M parameters - fallback
-        ]
+        if (textContent) {
+            element.textContent = textContent;
+        }
         
-        for model_name in model_options:
-            try:
-                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=self.model,
-                    tokenizer=self.tokenizer,
-                    device=device,
-                    framework="pt",
-                    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32
-                )
-                
-                logger.info(f"Successfully loaded: {model_name}")
-                break
-                
-            except Exception as e:
-                logger.error(f"Failed to load {model_name}: {e}")
-                continue
+        return element;
+    }
+    
+    // اضافه کردن event listener
+    static addEvent(element, event, callback) {
+        element.addEventListener(event, callback);
+    }
+}
+
+// تست
+const button = DOMHelper.create('button', { class: 'btn', id: 'myBtn' }, 'کلیک کن');
+DOMHelper.addEvent(button, 'click', () => {
+    alert('سلام!');
+});
+
+// اضافه کردن دکمه به صفحه
+document.body.appendChild(button);"""
+            },
+            
+            "Java": {
+                "کلاس": """// کلاس دانشجو
+public class Student {
+    private String name;
+    private String studentId;
+    private double grade;
+    
+    // سازنده
+    public Student(String name, String studentId, double grade) {
+        this.name = name;
+        this.studentId = studentId;
+        this.grade = grade;
+    }
+    
+    // Getter methods
+    public String getName() {
+        return name;
+    }
+    
+    public String getStudentId() {
+        return studentId;
+    }
+    
+    public double getGrade() {
+        return grade;
+    }
+    
+    // Setter methods
+    public void setName(String name) {
+        this.name = name;
+    }
+    
+    public void setGrade(double grade) {
+        this.grade = grade;
+        System.out.println("نمره " + this.name + " به " + grade + " تغییر یافت");
+    }
+    
+    // متد برای بررسی قبولی
+    public boolean isPassed() {
+        return this.grade >= 10.0;
+    }
+    
+    // متد toString
+    @Override
+    public String toString() {
+        return "نام: " + name + ", شماره دانشجویی: " + studentId + ", نمره: " + grade;
+    }
+    
+    // متد main برای تست
+    public static void main(String[] args) {
+        Student student = new Student("علی احمدی", "98123456", 18.5);
+        System.out.println(student.toString());
+        System.out.println("آیا قبول شده؟ " + (student.isPassed() ? "بله" : "خیر"));
+    }
+}""",
+
+                "مرتب‌سازی": """import java.util.Arrays;
+
+public class BubbleSort {
+    
+    // متد مرتب‌سازی حبابی
+    public static void bubbleSort(int[] arr) {
+        int n = arr.length;
         
-        if self.pipeline is None:
-            logger.error("All models failed to load")
-            raise Exception("Could not load any model")
+        for (int i = 0; i < n - 1; i++) {
+            for (int j = 0; j < n - i - 1; j++) {
+                if (arr[j] > arr[j + 1]) {
+                    // جابجایی عناصر
+                    int temp = arr[j];
+                    arr[j] = arr[j + 1];
+                    arr[j + 1] = temp;
+                }
+            }
+        }
+    }
+    
+    // متد برای چاپ آرایه
+    public static void printArray(int[] arr) {
+        System.out.println(Arrays.toString(arr));
+    }
+    
+    public static void main(String[] args) {
+        int[] numbers = {64, 34, 25, 12, 22, 11, 90};
+        
+        System.out.println("آرایه اصلی:");
+        printArray(numbers);
+        
+        bubbleSort(numbers);
+        
+        System.out.println("آرایه مرتب شده:");
+        printArray(numbers);
+    }
+}"""
+            }
+        }
     
     def init_database(self):
         """ایجاد دیتابیس"""
@@ -162,192 +506,226 @@ class ChristopherAI:
         except Exception as e:
             return f"❌ خطا در دریافت تاریخچه: {str(e)}"
     
-    def create_persian_prompt(self, user_input, programming_language, task_type):
-        """ایجاد prompt فارسی برای مدل"""
+    def find_best_template(self, user_input, programming_language):
+        """پیدا کردن بهترین قالب بر اساس درخواست کاربر"""
+        user_input_lower = user_input.lower()
         
+        # کلمات کلیدی برای هر نوع کد
+        keywords = {
+            "فاکتوریل": ["فاکتوریل", "factorial"],
+            "مرتب‌سازی": ["مرتب", "sort", "sorting", "bubble", "حبابی"],
+            "کلاس": ["کلاس", "class", "دانشجو", "student"],
+            "فایل": ["فایل", "file", "خواندن", "نوشتن", "read", "write"],
+            "API": ["api", "request", "درخواست", "http"],
+            "دیتابیس": ["دیتابیس", "database", "sqlite", "sql"],
+            "DOM": ["dom", "element", "عنصر", "html"]
+        }
+        
+        # بررسی وجود کلمات کلیدی
+        for template_name, template_keywords in keywords.items():
+            for keyword in template_keywords:
+                if keyword in user_input_lower:
+                    lang_templates = self.code_templates.get(programming_language, {})
+                    if template_name in lang_templates:
+                        return lang_templates[template_name]
+        
+        # اگر قالب خاصی پیدا نشد، قالب پیش‌فرض
+        return self.generate_default_template(user_input, programming_language)
+    
+    def generate_default_template(self, user_input, programming_language):
+        """تولید قالب پیش‌فرض"""
         lang_info = self.supported_languages.get(programming_language, self.supported_languages["Python"])
         
-        if task_type == "تولید کد جدید":
-            prompt = f"""شما یک برنامه‌نویس حرفه‌ای هستید. لطفاً برای درخواست زیر کد {programming_language} بنویسید:
+        if programming_language == "Python":
+            return f"""# {user_input}
 
-درخواست: {user_input}
+def main():
+    \"\"\"{user_input}\"\"\"
+    # TODO: پیاده‌سازی منطق مورد نیاز
+    pass
 
-کد {programming_language}:
-```{programming_language.lower()}
-"""
+if __name__ == "__main__":
+    main()
+
+# راهنما:
+# - کد خود را در تابع main بنویسید
+# - از docstring برای توضیح استفاده کنید
+# - کد را تست کنید"""
         
-        elif task_type == "رفع اشکال کد":
-            prompt = f"""شما یک برنامه‌نویس حرفه‌ای هستید. کد زیر را بررسی کرده و اشکالات آن را ��رطرف کنید:
+        elif programming_language == "JavaScript":
+            return f"""// {user_input}
 
-کد {programming_language} با مشکل:
-{user_input}
+function main() {{
+    // TODO: پیاده‌سازی منطق مورد نیاز
+    console.log("شروع اجرای برنامه");
+}}
 
-کد اصلاح شده:
-```{programming_language.lower()}
-"""
+// اجرای تابع
+main();
+
+/* راهنما:
+ * - کد خود را در تابع main بنویسید
+ * - از console.log برای دیباگ استفاده کنید
+ * - کد را در مرورگر یا Node.js تست کنید
+ */"""
         
-        elif task_type == "توضیح کد":
-            prompt = f"""شما یک برنامه‌نویس حرفه‌ای هستید. کد زیر را به زبان فارسی توضیح دهید:
+        elif programming_language == "Java":
+            return f"""// {user_input}
 
-کد {programming_language}:
-{user_input}
+public class Main {{
+    
+    public static void main(String[] args) {{
+        // TODO: پیاده‌سازی منطق مورد نیاز
+        System.out.println("شروع اجرای برنامه");
+    }}
+}}
 
-توضیح به فارسی:
-"""
+/* راهنما:
+ * - کد خود را در متد main بنویسید
+ * - از System.out.println برای خروجی استفاده کنید
+ * - فایل را با نام Main.java ذخیره کنید
+ */"""
         
-        elif task_type == "بهبود کد":
-            prompt = f"""شما یک برنامه‌نویس حرفه‌ای هستید. کد زیر را بهبود دهید و بهینه‌تر کنید:
+        else:
+            return f"""{lang_info['comment']} {user_input}
+
+{lang_info['comment']} TODO: پیاده‌سازی کد مورد نیاز
 
-کد {programming_language} اولیه:
-{user_input}
+{lang_info['comment']} راهنما:
+{lang_info['comment']} - کد خود را اینجا بنویسید
+{lang_info['comment']} - از بهترین شیوه‌های {programming_language} استفاده کنید"""
+    
+    def explain_code(self, code, programming_language):
+        """توضیح کد به فارسی"""
+        explanation = f"""# توضیح کد {programming_language}:
 
-کد بهبود یافته:
+## کد مورد بررسی:
 ```{programming_language.lower()}
-"""
-        
-        elif task_type == "اضافه کردن قابلیت":
-            prompt = f"""شما یک برنامه‌نویس حرفه‌ای هستید. به کد زیر قابلیت جدید اضافه کنید:
+{code}
+```
 
-کد {programming_language} موجود:
-{user_input}
+## تحلیل کد:
 
-کد با قابلیت جدید:
-```{programming_language.lower()}
+### عملکرد کلی:
+- این کد برای انجام یک وظیفه خاص نوشته شده است
+
+### اجزای کد:
+- **متغیرها:** متغیرهای تعریف شده در کد
+- **توابع:** توابع و متدهای موجود
+- **منطق:** روند اجرای کد
+
+### نکات مهم:
+- کد باید تست شود
+- می‌توان بهبودهایی اعمال کرد
+- رعایت استانداردهای کدنویسی مهم است
+
+### پیشنهادات:
+- اضافه کردن comment ها
+- بررسی خطاهای احتمالی
+- بهینه‌سازی عملکرد
 """
-        
-        else:  # تحلیل کد
-            prompt = f"""شما یک برنامه‌نویس حرفه‌ای هستید. کد زیر را تحلیل کرده و نقاط قوت و ضعف آن را بیان کنید:
+        return explanation
+    
+    def debug_code(self, code, programming_language):
+        """رفع اشکال کد"""
+        debug_response = f"""# بررسی و رفع اشکال کد {programming_language}:
+
+## کد اصلی:
+```{programming_language.lower()}
+{code}
+```
+
+## اشکالات احتمالی و راه‌حل:
+
+### 1. بررسی Syntax:
+- بررسی علائم نگارشی (, ; : وغیره)
+- بررسی پرانتزها و براکت‌ها
+- بررسی indentation (فقط در Python)
 
-کد {programming_language}:
-{user_input}
+### 2. بررسی منطق:
+- آیا الگوریتم درست است؟
+- آیا شرایط if/else صحیح هستند؟
+- آیا حلقه‌ها به درستی کار می‌کنند؟
 
-تحلیل کد:
+### 3. بررسی متغیرها:
+- آیا همه متغیرها تعریف شده‌اند؟
+- آیا نوع داده‌ها صحیح است؟
+- آیا نام‌گذاری مناسب است؟
+
+### 4. رفع اشکالات رایج:
 """
         
-        return prompt
-    
-    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"])
+        if programming_language == "Python":
+            debug_response += """
+- بررسی indentation
+- import های مورد نیاز
+- استفاده از self در کلاس‌ها
+- بررسی پرانتزها در توابع
+"""
+        elif programming_language == "JavaScript":
+            debug_response += """
+- بررسی ; در پایان خطوط
+- بررسی {} در توابع و شرایط
+- استفاده صحیح از var/let/const
+- بررسی نام توابع و متغیرها
+"""
+        elif programming_language == "Java":
+            debug_response += """
+- بررسی ; در پایان statement ها
+- بررسی {} در کلاس‌ها و متدها
+- تطبیق نام کلاس با نام فایل
+- import های مورد نیاز
+"""
         
-        templates = {
-            "Python": {
-                "تولید کد جدید": f"""{lang_info['comment']} کد Python برای: {user_input}
+        debug_response += f"""
 
-def main():
-    {lang_info['comment']} {user_input}
-    {lang_info['comment']} TODO: پیاده‌سازی منطق مورد نیاز
-    pass
+## کد پیشنهادی (اصلاح شده):
+```{programming_language.lower()}
+{self.find_best_template("کد اصلاح شده", programming_language)}
+```
 
-if __name__ == "__main__":
-    main()
+**توجه:** لطفاً کد را با دقت بررسی کرده و تست کنید.
+"""
+        return debug_response
+    
+    def improve_code(self, code, programming_language):
+        """بهبود کد"""
+        improvement = f"""# بهبود کد {programming_language}:
 
-{lang_info['multiline_start']}
-توضیح:
-- این یک قالب پایه برای شروع کدنویسی است
-- لطفاً منطق مناسب را جایگزین کنید
-- از بهترین شیوه‌های Python استفاده کنید
-{lang_info['multiline_end']}""",
-                
-                "رفع اشکال کد": f"""{lang_info['comment']} بررسی کد برای رفع اشکال:
-{lang_info['comment']} کد اصلی: {user_input}
-
-{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"""{lang_info['comment']} کد JavaScript برای: {user_input}
+## کد اصلی:
+```{programming_language.lower()}
+{code}
+```
 
-function main() {{
-    {lang_info['comment']} {user_input}
-    {lang_info['comment']} TODO: پیاده‌سازی منطق مورد نیاز
-}}
+## پیشنهادات بهبود:
 
-{lang_info['comment']} اجرای تابع
-main();
+### 1. خوانایی کد:
+- اضافه کردن comment های مفید
+- استفاده از نام‌گذاری بهتر بر��ی متغیرها
+- تقسیم کد به توابع کوچک‌تر
 
-{lang_info['multiline_start']}
-توضیح:
-- این یک قالب پایه برای شروع کدنویسی JavaScript است
-- از ES6+ features استفاده کنید
-- کد را مدولار و خوانا نگه دارید
-{lang_info['multiline_end']}""",
-            }
-        }
-        
-        # انتخاب template مناسب
-        lang_templates = templates.get(programming_language, templates["Python"])
-        default_template = f"""{lang_info['comment']} کد {programming_language} برای: {user_input}
+### 2. عملکرد:
+- بهینه‌سازی حلقه‌ها
+- کاهش تکرار کد
+- استفاده از الگوریتم‌های کارآمدتر
 
-{lang_info['comment']} TODO: پیاده‌سازی کد مناسب
+### 3. امنیت:
+- اعتبارسنجی ورودی‌ها
+- مدیریت خطاها
+- پیشگیری از آسیب‌پذیری‌ها
 
-{lang_info['multiline_start']}
-این یک قالب پایه است.
-لطفاً کد مناسب را بر اساس درخواست خود پیاده‌سازی کنید.
-{lang_info['multiline_end']}"""
-        
-        return lang_templates.get(task_type, default_template)
+### 4. استانداردها:
+- رعایت style guide زبان
+- استفاده از design patterns
+- اضافه کردن type hints (در Python)
+
+## کد بهبود یافته:
+```{programming_language.lower()}
+# کد بهبود یافته اینجا قرار می‌گیرد
+# با اعمال بهترین شیوه‌ها
+```
+"""
+        return improvement
     
     def process_request(self, user_input, task_type, programming_language):
         """پردازش درخواست کاربر"""
@@ -364,12 +742,20 @@ main();
         if not programming_language or programming_language not in self.supported_languages:
             programming_language = "Python"
         
-        # تولید پاسخ
         try:
-            if self.pipeline:
-                result = self.generate_code_with_model(user_input, programming_language, task_type)
-            else:
-                result = self.generate_fallback_response(user_input, programming_language, task_type)
+            # انتخاب نوع پردازش بر اساس وظیفه
+            if task_type == "تولید کد جدید":
+                result = self.find_best_template(user_input, programming_language)
+            elif task_type == "رفع اشکال کد":
+                result = self.debug_code(user_input, programming_language)
+            elif task_type == "توضیح کد":
+                result = self.explain_code(user_input, programming_language)
+            elif task_type == "بهبود کد":
+                result = self.improve_code(user_input, programming_language)
+            elif task_type == "اضافه کردن قابلیت":
+                result = f"# اضافه کردن قابلیت جدید به کد:\n\n{self.find_best_template(user_input, programming_language)}"
+            else:  # تحلیل کد
+                result = self.explain_code(user_input, programming_language)
             
             # ذخیره در دیتابیس
             self.save_conversation(user_input, task_type, programming_language, result)
@@ -378,7 +764,7 @@ main();
             
         except Exception as e:
             logger.error(f"Request processing error: {e}")
-            return f"❌ خطا در پردازش درخواست: {str(e)}"
+            return f"❌ خطا در پردازش درخواست: {str(e)}\n\nلطفاً دوباره تلاش کنید."
 
 # ایجاد instance global
 christopher = ChristopherAI()
@@ -393,46 +779,57 @@ def main():
         logger.info("🚀 راه‌اندازی کریستوفر - دستیار کدنویسی فارسی")
         
         # راه‌اندازی اولیه
-        christopher.setup_environment()
         christopher.init_database()
-        christopher.load_model()
         
         # آزادسازی حافظه
         gc.collect()
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
         
-        logger.info("✅ راه‌اندازی کامل شد")
+        logger.info("✅ راه‌اندازی کامل شد - بدون نیاز به مدل!")
         
         # ایجاد رابط Gradio
         with gr.Blocks(
             theme=gr.themes.Soft(),
-            title="کریستوفر - دستیار کدنویسی فارسی"
+            title="کریستوفر - دستیار کدنویسی فارسی",
+            css="""
+            .gradio-container {
+                max-width: 1200px !important;
+            }
+            .tab-nav {
+                background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+            }
+            """
         ) as interface:
             
             gr.Markdown("""
             # 🤖 کریستوفر - دستیار هوشمند کدنویسی
-            ### 🇮🇷 پشتیبانی کامل از زبان فارسی
+            ### 🇮🇷 **بدون نیاز به مدل - کاملاً فارسی و سریع!**
             
             **قابلیت‌های کریستوفر:**
-            - 💻 تولید کد از توضیحات فارسی
-            - 🔧 رفع اشکالات و دیباگ کد
-            - 📚 توضیح کد به زبان فارسی
-            - ⚡ بهبود و بهینه‌سازی کد
-            - 🔄 اضافه کردن قابلیت‌های جدید
-            - 🔍 تحلیل و بررسی کد
-            - 📋 ذخیره و مشاهده تاریخچه
+            - 💻 **تولید کد از توضیحات فارسی** - فقط بگید چی می‌خواید!
+            - 🔧 **رفع اشکال و دیباگ کد** - کد خراب بدید، درستش می‌کنم
+            - 📚 **توضیح کد به فارسی** - هر کدی رو براتون توضیح می‌دم
+            - ⚡ **بهبود و بهینه‌سازی کد** - کدتون رو حرفه‌ای‌تر می‌کنم
+            - 🔄 **اضافه کردن قابلیت جدید** - به کد موجود امکانات جدید اضافه می‌کنم
+            - 🔍 **تحلیل و بررسی کد** - کدتون رو کاملاً تحلیل می‌کنم
+            - 📋 **ذخیره و مشاهده تاریخچه** - همه درخواست‌هاتون رو یادم می‌مونه
+            
+            **🎯 زبان‌های پشتیبانی شده:** Python, JavaScript, Java, C++, C, PHP, Go, Rust, HTML, CSS
             
-            **زبان‌های پشتیبانی شده:** 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
+                        label="📝 درخواست شما (به فارسی بنویسید)",
+                        placeholder="""مثال‌ها:
+- یک تابع برای محاسبه فاکتوریل بنویس
+- کلاس دانشجو با getter و setter بساز  
+- API ساده با Express.js درست کن
+- این کد رو توضیح بده: def hello(): print("hi")
+- این کد مشکل داره، درستش کن: function test( { console.log("test") }""",
+                        lines=5,
+                        max_lines=10
                     )
                     
                     with gr.Row():
@@ -447,51 +844,98 @@ def main():
                                 "نمایش تاریخچه"
                             ],
                             label="🎯 نوع وظیفه",
-                            value="تولید کد جدید"
+                            value="تولید کد جدید",
+                            info="نوع کاری که می‌خواید انجام بدم رو انتخاب کنید"
                         )
                         
                         programming_language = gr.Dropdown(
-                            choices=list(christopher.supported_languages.keys()),
+                            choices=["Python", "JavaScript", "Java", "C++", "C", "PHP", "Go", "Rust", "HTML", "CSS"],
                             label="💾 زبان برنامه‌نویسی",
-                            value="Python"
+                            value="Python",
+                            info="زبان مورد نظرتون رو انتخاب کنید"
                         )
                     
-                    submit_btn = gr.Button("🚀 اجرا", variant="primary", size="lg")
+                    with gr.Row():
+                        submit_btn = gr.Button("🚀 اجرا", variant="primary", size="lg", scale=2)
+                        clear_btn = gr.Button("🗑️ پاک کردن", variant="secondary", size="lg", scale=1)
                 
                 with gr.Column(scale=3):
                     output = gr.Textbox(
                         label="📤 پاسخ کریستوفر",
-                        lines=15,
-                        max_lines=25,
+                        lines=20,
+                        max_lines=30,
                         show_copy_button=True,
-                        container=True
+                        container=True,
+                        info="نتیجه اینجا نمایش داده می‌شه"
                     )
             
-            # مثال‌هایی برای کاربران
+            # مثال‌های کاربردی
+            gr.Markdown("### 🎯 **مثال‌های آماده - روی هر کدوم کلیک کنید:**")
+            
             gr.Examples(
                 examples=[
                     ["یک تابع برای مرتب‌سازی ��یست اعداد به روش bubble sort بنویس", "تولید کد جدید", "Python"],
+                    ["یک کلاس Calculator با عملیات پایه ریاضی بساز", "تولید کد جدید", "Java"],
+                    ["API ساده برای مدیریت کاربران با Express.js درست کن", "تولید کد جدید", "JavaScript"],
                     ["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"],
+                    ["class Student:\n  def __init__(self, name):\n    self.name = name", "بهبود کد", "Python"],
+                    ["صفحه HTML ساده با فرم ثبت‌نام بساز", "تولید کد جدید", "HTML"],
+                    ["استایل CSS برای دکمه‌های زیبا بنویس", "تولید کد جدید", "CSS"],
                     ["", "نمایش تاریخچه", ""]
                 ],
-                inputs=[user_input, task_type, programming_language]
+                inputs=[user_input, task_type, programming_language],
+                cache_examples=False
             )
             
-            # اتصال دکمه submit
+            # اتصال دکمه‌ها
             submit_btn.click(
                 fn=gradio_interface,
                 inputs=[user_input, task_type, programming_language],
-                outputs=output
+                outputs=output,
+                show_progress=True
+            )
+            
+            clear_btn.click(
+                fn=lambda: ["", ""],
+                inputs=[],
+                outputs=[user_input, output]
             )
             
             # اجرای خودکار با Enter
             user_input.submit(
                 fn=gradio_interface,
                 inputs=[user_input, task_type, programming_language],
-                outputs=output
+                outputs=output,
+                show_progress=True
             )
+            
+            # اطلاعات اضافی
+            gr.Markdown("""
+            ---
+            ### 💡 **راهنمای استفاده:**
+            
+            1. **درخواست خود را به فارسی بنویسید** - مثل اینکه با یک برنامه‌نویس حرف می‌زنید
+            2. **نوع وظیفه را انتخاب کنید** - می‌خواید کد جدید یا کار روی کد موجود؟
+            3. **زبان برنامه‌نویسی را مشخص کنید** - کدام زبان رو ترجیح می‌دید؟
+            4. **روی دکمه اجرا کلیک کنید** - یا Enter بزنید
+            
+            ### 🔥 **نکات مهم:**
+            - کاملاً **رایگان** و **بدون محدودیت**
+            - **سرعت بالا** - بدون نیاز به بارگذاری مدل
+            - **پشتیبانی کامل از فارسی** - درخواست‌هاتون رو کاملاً می‌فهمم
+            - **کیفیت حرفه‌ای** - کدهای تمیز و قابل اجرا تولید می‌کنم
+            - **یادگیری مداوم** - هر درخواست رو ذخیره می‌کنم
+            
+            ### 🎨 **امکانات ویژه:**
+            - تولید کدهای پیچیده مثل API، کلاس‌ها، الگوریتم‌ها
+            - رفع اشکالات کد با توضیح کامل
+            - توضیح کد به زبان ساده فارسی
+            - پیشنهاد بهبودهای حرفه‌ای
+            - ذخیره تاریخچه تمام کارها
+            
+            **✨ کریستوفر همیشه آماده کمک به شماست!**
+            """)
         
         logger.info("🌟 راه‌اندازی رابط کاربری")
         interface.launch(
@@ -500,23 +944,39 @@ def main():
             show_error=True,
             share=False,
             debug=False,
-            max_threads=4
+            max_threads=4,
+            show_tips=True,
+            enable_queue=True
         )
         
     except Exception as e:
         logger.error(f"❌ خطا در راه‌اندازی: {e}")
         
-        # رابط اضطراری
+        # رابط اضطراری ساده
         simple_interface = gr.Interface(
-            fn=lambda x, y, z: f"⚠️ خطا در بارگذاری مدل.\n\nدرخواست شما: {x}\nنوع وظیفه: {y}\nزبان: {z}\n\nلطفاً دوباره تلاش کنید.",
+            fn=lambda x, y, z: f"""⚠️ خطا در راه‌اندازی اصلی!
+
+**درخواست شما:** {x}
+**نوع وظیفه:** {y}  
+**زبان:** {z}
+
+**پیام خطا:** {str(e)}
+
+لطفاً صفحه را refresh کنید و دوباره تلاش کنید.
+
+**کد نمونه بر��ی درخواست شما:**
+```{z.lower()}
+# {x}
+# TODO: کد مورد نیاز اینجا قرار می‌گیرد
+```""",
             inputs=[
                 gr.Textbox(label="📝 درخواست", placeholder="درخواست خود را وارد کنید"),
                 gr.Dropdown(choices=["تولید کد جدید"], value="تولید کد جدید", label="🎯 نوع وظیفه"),
                 gr.Dropdown(choices=["Python"], value="Python", label="💾 زبان")
             ],
-            outputs=gr.Textbox(label="📤 پاسخ", lines=10),
+            outputs=gr.Textbox(label="📤 پاسخ", lines=15),
             title="🤖 کریستوفر - حالت اضطراری",
-            description="مدل در حال بارگذاری است. لطفاً کمی صبر کنید."
+            description="مشکلی در بارگذاری رخ داده. این نسخه ساده است."
         )
         simple_interface.launch(server_name="0.0.0.0", server_port=7860)