Update app.py

app.py

@@ -2,41 +2,58 @@ import os
 import json
 import time
 import asyncio
-import threading
 import logging
-import numpy as np
-import pandas as pd
-import cv2
-import nltk
+import hashlib
 from datetime import datetime
+from typing import List, Dict, Optional, Union
 from concurrent.futures import ThreadPoolExecutor
-from fastapi import FastAPI, HTTPException, Request, UploadFile, File
-from fastapi.responses import StreamingResponse, HTMLResponse, FileResponse
+
+from fastapi import FastAPI, HTTPException, Request, UploadFile, File, WebSocket, WebSocketDisconnect
+from fastapi.responses import StreamingResponse, HTMLResponse, FileResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
-from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
-from diffusers import StableDiffusionPipeline
+from fastapi.security import APIKeyHeader
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
 from langdetect import detect, DetectorFactory
+import numpy as np
+import pandas as pd
+import cv2
 import torch
-from tensorflow.keras.models import Sequential
-from tensorflow.keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPooling2D
-from sklearn.ensemble import RandomForestClassifier
-from sklearn.metrics import accuracy_score
+from PIL import Image
 import moviepy.editor as mp
-from PIL import Image, ImageDraw, ImageFont
-from pydantic import BaseModel
-from typing import List, Dict, Optional
+
+# تحميل نماذج الذكاء الاصطناعي
+from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
+from diffusers import StableDiffusionPipeline, EulerDiscreteScheduler
+from tensorflow.keras.models import load_model
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
 
 # التهيئة الأساسية
 DetectorFactory.seed = 0
-app = FastAPI()
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("MarkAI")
+
+app = FastAPI(title="MarkAI - الذكاء الاصطناعي المتكامل", version="2.0")
+
+# إعدادات CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
 # تهيئة مجلدات التخزين
 os.makedirs("uploads", exist_ok=True)
-os.makedirs("memory", exist_ok=True)
-os.makedirs("projects", exist_ok=True)
+os.makedirs("memory/conversations", exist_ok=True)
+os.makedirs("memory/projects", exist_ok=True)
+os.makedirs("memory/code", exist_ok=True)
+os.makedirs("memory/backups", exist_ok=True)
 
-# 1. نماذج اللغات المدعومة (خفيفة الوزن)
+# 1. نماذج اللغات المدعومة (محدثة)
 LANGUAGE_MODELS = {
     "en": "gpt2-medium",
     "ar": "arbml/gpt2-arabic-poetry",
@@ -45,314 +62,686 @@ LANGUAGE_MODELS = {
     "fr": "dbmdz/gpt2-french",
     "de": "dbmdz/gpt2-german",
     "it": "LorenzoDeMattei/GePpeTto",
-    "hi": "surajpai/GPT2-Hindi"
+    "hi": "surajpai/GPT2-Hindi",
+    "code": "codeparrot/codeparrot-small"
 }
 
-# 2. نظام الذاكرة والتعلم التلقائي
+# 2. نظام الأمان والمفاتيح
+API_KEY_HEADER = APIKeyHeader(name="X-API-KEY")
+
+def load_api_keys():
+    try:
+        with open("memory/api_keys.json", "r") as f:
+            return json.load(f)
+    except:
+        return {}
+
+def save_api_keys(keys):
+    with open("memory/api_keys.json", "w") as f:
+        json.dump(keys, f)
+
+def authenticate(api_key: str):
+    keys = load_api_keys()
+    return api_key in keys.values()
+
+# 3. نظام الذاكرة المتقدم
 class AIMemory:
     def __init__(self):
-        self.memory_file = "memory/interactions.json"
-        self.projects_file = "memory/projects.json"
-        self.code_snippets_file = "memory/code_snippets.json"
-        self.interactions = self._load_data(self.memory_file, [])
-        self.projects = self._load_data(self.projects_file, [])
-        self.code_snippets = self._load_data(self.code_snippets_file, [])
-        
-    def _load_data(self, file_path, default):
-        if os.path.exists(file_path):
-            with open(file_path, "r", encoding="utf-8") as f:
-                return json.load(f)
-        return default
-    
-    def save_interaction(self, interaction_type: str, data: dict):
-        if interaction_type == "chat":
-            self.interactions.append(data)
-            self._save_data(self.memory_file, self.interactions)
-        elif interaction_type == "project":
-            self.projects.append(data)
-            self._save_data(self.projects_file, self.projects)
-        elif interaction_type == "code":
-            self.code_snippets.append(data)
-            self._save_data(self.code_snippets_file, self.code_snippets)
-    
-    def _save_data(self, file_path, data):
-        with open(file_path, "w", encoding="utf-8") as f:
-            json.dump(data, f, ensure_ascii=False, indent=2)
+        self.conversations = {}
+        self.projects = {}
+        self.code_repository = {}
+        self.load_all_data()
+        
+    def load_all_data(self):
+        """تحميل جميع البيانات من الملفات"""
+        # تحميل المحادثات
+        for conv_file in os.listdir("memory/conversations"):
+            if conv_file.endswith(".json"):
+                conv_id = conv_file.split(".")[0]
+                with open(f"memory/conversations/{conv_file}", "r", encoding="utf-8") as f:
+                    self.conversations[conv_id] = json.load(f)
+        
+        # تحميل المشاريع
+        if os.path.exists("memory/projects/projects.json"):
+            with open("memory/projects/projects.json", "r", encoding="utf-8") as f:
+                self.projects = json.load(f)
+        
+        # تحميل مستودع الأكواد
+        if os.path.exists("memory/code/code_repository.json"):
+            with open("memory/code/code_repository.json", "r", encoding="utf-8") as f:
+                self.code_repository = json.load(f)
+    
+    def create_conversation(self, initial_prompt: str) -> str:
+        """إنشاء محادثة جديدة مع تسمية تلقائية"""
+        conv_id = hashlib.md5(f"{initial_prompt}{datetime.now()}".encode()).hexdigest()[:10]
+        conv_name = initial_prompt[:30] + "..." if len(initial_prompt) > 30 else initial_prompt
+        
+        conversation = {
+            "id": conv_id,
+            "name": conv_name,
+            "created_at": str(datetime.now()),
+            "updated_at": str(datetime.now()),
+            "messages": [],
+            "context": [],
+            "status": "active"
+        }
+        
+        self.conversations[conv_id] = conversation
+        self.save_conversation(conv_id)
+        return conv_id
+    
+    def save_conversation(self, conv_id: str):
+        """حفظ محادثة معينة"""
+        if conv_id in self.conversations:
+            with open(f"memory/conversations/{conv_id}.json", "w", encoding="utf-8") as f:
+                json.dump(self.conversations[conv_id], f, ensure_ascii=False, indent=2)
+    
+    def add_message(self, conv_id: str, role: str, content: str, metadata: dict = {}):
+        """إضافة رسالة إلى المحادثة"""
+        if conv_id not in self.conversations:
+            raise ValueError("المحادثة غير موجودة")
+            
+        message = {
+            "role": role,
+            "content": content,
+            "timestamp": str(datetime.now()),
+            "metadata": metadata
+        }
+        
+        self.conversations[conv_id]["messages"].append(message)
+        self.conversations[conv_id]["updated_at"] = str(datetime.now())
+        self.save_conversation(conv_id)
+    
+    def get_conversation_context(self, conv_id: str, max_messages: int = 10) -> List[dict]:
+        """الحصول على سياق المحادثة"""
+        if conv_id not in self.conversations:
+            return []
+            
+        return self.conversations[conv_id]["messages"][-max_messages:]
+    
+    def create_project(self, name: str, description: str, project_type: str) -> str:
+        """إنشاء مشروع جديد"""
+        project_id = hashlib.md5(f"{name}{datetime.now()}".encode()).hexdigest()[:8]
+        
+        project = {
+            "id": project_id,
+            "name": name,
+            "description": description,
+            "type": project_type,
+            "created_at": str(datetime.now()),
+            "updated_at": str(datetime.now()),
+            "status": "active",
+            "files": [],
+            "conversations": []
+        }
+        
+        self.projects[project_id] = project
+        self.save_projects()
+        return project_id
+    
+    def save_projects(self):
+        """حفظ جميع المشاريع"""
+        with open("memory/projects/projects.json", "w", encoding="utf-8") as f:
+            json.dump(self.projects, f, ensure_ascii=False, indent=2)
+    
+    def save_code_snippet(self, code: str, language: str, purpose: str, metadata: dict = {}):
+        """حفظ جزء من الكود في المستودع"""
+        code_id = hashlib.md5(f"{code}{datetime.now()}".encode()).hexdigest()[:8]
+        
+        snippet = {
+            "id": code_id,
+            "code": code,
+            "language": language,
+            "purpose": purpose,
+            "metadata": metadata,
+            "created_at": str(datetime.now()),
+            "usage_count": 0
+        }
+        
+        self.code_repository[code_id] = snippet
+        self.save_code_repository()
+        return code_id
+    
+    def save_code_repository(self):
+        """حفظ مستودع الأكواد"""
+        with open("memory/code/code_repository.json", "w", encoding="utf-8") as f:
+            json.dump(self.code_repository, f, ensure_ascii=False, indent=2)
+    
+    def backup_data(self):
+        """إنشاء نسخة احتياطية لجميع البيانات"""
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        backup_dir = f"memory/backups/{timestamp}"
+        os.makedirs(backup_dir, exist_ok=True)
+        
+        # نسخ المحادثات
+        os.makedirs(f"{backup_dir}/conversations", exist_ok=True)
+        for conv_id, conv_data in self.conversations.items():
+            with open(f"{backup_dir}/conversations/{conv_id}.json", "w", encoding="utf-8") as f:
+                json.dump(conv_data, f, ensure_ascii=False, indent=2)
+        
+        # نسخ المشاريع
+        with open(f"{backup_dir}/projects.json", "w", encoding="utf-8") as f:
+            json.dump(self.projects, f, ensure_ascii=False, indent=2)
+        
+        # نسخ الأكواد
+        with open(f"{backup_dir}/code_repository.json", "w", encoding="utf-8") as f:
+            json.dump(self.code_repository, f, ensure_ascii=False, indent=2)
+        
+        return backup_dir
 
 memory = AIMemory()
 
-# 3. نظام التقييم الذاتي
-def evaluate_response(prompt: str, response: str) -> float:
-    """يقيم الجودة بين 0-1 بناءً على عدة معايير"""
-    length_score = min(len(response) / 100, 1.0)
-    unique_words = len(set(response.split()))
-    diversity_score = min(unique_words / 20, 1.0)
-    return (length_score + diversity_score) / 2
+# 4. نظام التقييم والتحليل
+class AnalyticsEngine:
+    def __init__(self):
+        self.sentiment_model = pipeline("sentiment-analysis")
+        self.tfidf = TfidfVectorizer()
+        
+    def analyze_sentiment(self, text: str) -> dict:
+        """تحليل المشاعر للنص"""
+        try:
+            result = self.sentiment_model(text)[0]
+            return {
+                "sentiment": result["label"],
+                "score": result["score"],
+                "positive": result["label"] == "POSITIVE",
+                "negative": result["label"] == "NEGATIVE"
+            }
+        except:
+            # Fallback basic sentiment analysis
+            positive_words = ["good", "great", "excellent", "happy", "جيد", "رائع", "ممتاز", "سعيد"]
+            negative_words = ["bad", "terrible", "awful", "sad", "سيء", "فظيع", "مزعج", "حزين"]
+            
+            positive_count = sum(text.lower().count(word) for word in positive_words)
+            negative_count = sum(text.lower().count(word) for word in negative_words)
+            
+            if positive_count > negative_count:
+                return {"sentiment": "POSITIVE", "score": positive_count/(positive_count+negative_count+1)}
+            elif negative_count > positive_count:
+                return {"sentiment": "NEGATIVE", "score": negative_count/(positive_count+negative_count+1)}
+            else:
+                return {"sentiment": "NEUTRAL", "score": 0.5}
+    
+    def evaluate_response(self, prompt: str, response: str) -> dict:
+        """تقييم جودة الرد"""
+        # تحليل طول الرد
+        length_score = min(len(response.split()) / 100, 1.0)
+        
+        # تحليل التنوع
+        unique_words = len(set(response.split()))
+        diversity_score = min(unique_words / 50, 1.0)
+        
+        # تحليل الصلة بالموضوع
+        try:
+            vectors = self.tfidf.fit_transform([prompt, response])
+            relevance_score = cosine_similarity(vectors[0:1], vectors[1:2])[0][0]
+        except:
+            relevance_score = 0.7  # قيمة افتراضية في حالة الخطأ
+            
+        # تحليل المشاعر
+        sentiment = self.analyze_sentiment(response)
+        
+        return {
+            "length_score": length_score,
+            "diversity_score": diversity_score,
+            "relevance_score": relevance_score,
+            "sentiment": sentiment,
+            "overall_score": (length_score + diversity_score + relevance_score + sentiment["score"]) / 4
+        }
+
+analytics = AnalyticsEngine()
 
-# 4. المحرك الأساسي
+# 5. المحرك الأساسي للذكاء الاصطناعي
 class AIEngine:
     def __init__(self):
-        self.executor = ThreadPoolExecutor(max_workers=4)
-        self.text_models = {}
-        self.image_model = None
-        self.code_model = None
-        self.video_model = None
-        
-    async def load_text_model(self, model_name: str):
-        if model_name not in self.text_models:
+        self.executor = ThreadPoolExecutor(max_workers=8)
+        self.models = {}
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        
+    async def load_model(self, model_type: str, model_name: str = None):
+        """تحميل نموذج معين"""
+        if model_type not in self.models:
             try:
-                tokenizer = AutoTokenizer.from_pretrained(model_name)
-                model = AutoModelForCausalLM.from_pretrained(model_name)
-                self.text_models[model_name] = {"tokenizer": tokenizer, "model": model}
+                if model_type == "text":
+                    model_name = model_name or LANGUAGE_MODELS.get("en")
+                    tokenizer = AutoTokenizer.from_pretrained(model_name)
+                    model = AutoModelForCausalLM.from_pretrained(model_name).to(self.device)
+                    self.models[model_type] = {"tokenizer": tokenizer, "model": model}
+                
+                elif model_type == "image":
+                    scheduler = EulerDiscreteScheduler.from_pretrained("stabilityai/stable-diffusion-2", subfolder="scheduler")
+                    model = StableDiffusionPipeline.from_pretrained(
+                        "stabilityai/stable-diffusion-2",
+                        scheduler=scheduler,
+                        torch_dtype=torch.float16
+                    ).to(self.device)
+                    self.models[model_type] = model
+                
+                elif model_type == "code":
+                    tokenizer = AutoTokenizer.from_pretrained(LANGUAGE_MODELS["code"])
+                    model = AutoModelForCausalLM.from_pretrained(LANGUAGE_MODELS["code"]).to(self.device)
+                    self.models[model_type] = {"tokenizer": tokenizer, "model": model}
+                
+                logger.info(f"تم تحميل النموذج بنجاح: {model_type}")
             except Exception as e:
-                logging.error(f"Failed to load model {model_name}: {str(e)}")
+                logger.error(f"خطأ في تحميل النموذج: {str(e)}")
                 raise
-        return self.text_models[model_name]
+        
+        return self.models[model_type]
     
-    async def load_image_model(self):
-        if not self.image_model:
-            try:
-                self.image_model = StableDiffusionPipeline.from_pretrained(
-                    "stabilityai/stable-diffusion-2-base",
-                    torch_dtype=torch.float16
-                )
-            except Exception as e:
-                logging.error(f"Failed to load image model: {str(e)}")
-                raise
-        return self.image_model
+    async def generate_text(self, prompt: str, lang: str = None, max_length: int = 300) -> str:
+        """توليد نص بناء على المطالبة"""
+        if not lang:
+            lang = detect(prompt)
+        
+        model_name = LANGUAGE_MODELS.get(lang, LANGUAGE_MODELS["en"])
+        model = await self.load_model("text", model_name)
+        
+        inputs = model["tokenizer"](prompt, return_tensors="pt").to(self.device)
+        outputs = model["model"].generate(**inputs, max_length=max_length, do_sample=True, top_k=50, top_p=0.95)
+        
+        return model["tokenizer"].decode(outputs[0], skip_special_tokens=True)
     
-    async def generate_code(self, prompt: str, language: str):
+    async def generate_code(self, prompt: str, language: str = "python", max_length: int = 500) -> str:
         """توليد كود برمجي"""
-        model = await self.load_text_model("codeparrot/codeparrot-small")
-        inputs = model["tokenizer"](f"# {language}\n# {prompt}\n", return_tensors="pt")
-        outputs = model["model"].generate(**inputs, max_length=200)
-        return model["tokenizer"].decode(outputs[0], skip_special_tokens=True)
+        model = await self.load_model("code")
+        
+        prompt = f"# Language: {language}\n# Description: {prompt}\n# Code:\n"
+        inputs = model["tokenizer"](prompt, return_tensors="pt").to(self.device)
+        outputs = model["model"].generate(**inputs, max_length=max_length, do_sample=True, top_k=50, top_p=0.95)
+        
+        generated_code = model["tokenizer"].decode(outputs[0], skip_special_tokens=True)
+        
+        # حفظ الكود في المستودع
+        code_id = memory.save_code_snippet(
+            code=generated_code,
+            language=language,
+            purpose=prompt[:100],
+            metadata={"generated_at": str(datetime.now())}
+        )
+        
+        return generated_code
+    
+    async def generate_image(self, prompt: str, save_path: str = None) -> str:
+        """توليد صورة من النص"""
+        model = await self.load_model("image")
+        
+        if not save_path:
+            save_path = f"uploads/generated_image_{int(time.time())}.png"
+            
+        image = model(prompt).images[0]
+        image.save(save_path)
+        
+        return save_path
     
-    async def generate_video(self, prompt: str):
-        """توليد فيديو من نص"""
-        # محاكاة لتوليد الفيديو (في الإصدار الحقيقي سيتم استخدام مكتبة مثل moviepy)
-        video_path = f"uploads/generated_video_{int(time.time())}.mp4"
-        clip = mp.VideoFileClip("assets/blank_video.mp4").set_duration(5)
-        txt_clip = mp.TextClip(prompt, fontsize=24, color='white').set_position('center').set_duration(5)
+    async def generate_video(self, prompt: str, duration: int = 5, fps: int = 24) -> str:
+        """توليد فيديو من النص (محاكاة)"""
+        save_path = f"uploads/generated_video_{int(time.time())}.mp4"
+        
+        # إنشاء فيديو مع نص
+        clip = mp.VideoFileClip("assets/blank_video.mp4").set_duration(duration)
+        txt_clip = mp.TextClip(prompt, fontsize=24, color='white', size=clip.size).set_position('center').set_duration(duration)
         video = mp.CompositeVideoClip([clip, txt_clip])
-        video.write_videofile(video_path, fps=24)
-        return video_path
+        video.write_videofile(save_path, fps=fps)
+        
+        return save_path
+    
+    async def analyze_code(self, code: str, language: str = "python") -> dict:
+        """تحليل الكود وإعطاء تقييم"""
+        # تحليل أساسي للكود
+        analysis = {
+            "length": len(code.split("\n")),
+            "complexity": "low",
+            "quality": "medium",
+            "issues": [],
+            "suggestions": []
+        }
+        
+        # تحليل أولي
+        if len(code.split("\n")) > 50:
+            analysis["complexity"] = "high"
+            analysis["suggestions"].append("Consider breaking this into smaller functions/modules")
+        
+        if "TODO" in code or "FIXME" in code:
+            analysis["issues"].append("Contains unfinished tasks (TODO/FIXME)")
+            analysis["quality"] = "low"
+        
+        if language == "python" and "print(" in code:
+            analysis["suggestions"].append("Consider using logging instead of print statements for production code")
+        
+        return analysis
+    
+    async def improve_code(self, code: str, language: str, improvements: List[str]) -> str:
+        """تحسين الكود بناء على طلبات محددة"""
+        improved_code = code
+        
+        # تطبيق التحسينات الأساسية
+        if "add_comments" in improvements:
+            improved_code = f"# Improved by MarkAI at {datetime.now()}\n# Original code with enhancements\n\n{improved_code}"
+        
+        if "optimize" in improvements:
+            improved_code = improved_code.replace("for i in range(len(", "for item in ")
+            improved_code = improved_code.replace(".append(", " += [")
+        
+        if "add_error_handling" in improvements and language == "python":
+            improved_code = f"try:\n    {improved_code.replace('\n', '\n    ')}\nexcept Exception as e:\n    print(f\"An error occurred: {e}\")"
+        
+        return improved_code
 
 engine = AIEngine()
 
-# 5. نظام التفكير الظاهر
-def thinking_process(lang: str, task_type: str):
-    """يعرض خطوات التفكير حسب اللغة ونوع المهمة"""
-    steps = {
-        "text": {
-            "ar": [
-                "🔍 جاري تحليل طلبك...",
-                "🧠 جاري معالجة النص...",
-                "📚 جاري البحث في المعرفة...",
-                "✨ جاري توليد الإجابة..."
-            ],
-            "en": [
-                "🔍 Analyzing your request...",
-                "🧠 Processing text...",
-                "📚 Searching knowledge...",
-                "✨ Generating answer..."
-            ]
-        },
-        "code": {
-            "ar": [
-                "🔍 تحليل متطلبات الكود...",
-                "🧠 جاري كتابة الخوارزمية...",
-                "📚 جاري تحسين الكود...",
-                "✨ جاري توليد الكود النهائي..."
-            ],
-            "en": [
-                "🔍 Analyzing code requirements...",
-                "🧠 Writing algorithm...",
-                "📚 Optimizing code...",
-                "✨ Generating final code..."
-            ]
-        },
-        "image": {
-            "ar": [
-                "🔍 تحليل وصف الصورة...",
-                "🧠 جاري تكوين المفاهيم...",
-                "🎨 جاري رسم الصورة...",
-                "✨ جاري تنقيح التفاصيل..."
-            ],
-            "en": [
-                "🔍 Analyzing image description...",
-                "🧠 Composing concepts...",
-                "🎨 Drawing image...",
-                "✨ Refining details..."
-            ]
-        },
-        "video": {
-            "ar": [
-                "🔍 تحليل سيناريو الفيديو...",
-                "🎬 جاري إعداد المشاهد...",
-                "🎞️ جاري تركيب الفيديو...",
-                "✨ جاري إضافة المؤثرات..."
-            ],
-            "en": [
-                "🔍 Analyzing video scenario...",
-                "🎬 Preparing scenes...",
-                "🎞️ Composing video...",
-                "✨ Adding effects..."
-            ]
+# 6. نظام التفكير والتخطيط
+class ThinkingEngine:
+    def __init__(self):
+        self.planning_steps = {
+            "text": {
+                "ar": [
+                    "🔍 تحليل الطلب والمتطلبات...",
+                    "🧠 معالجة البيانات والبحث...",
+                    "📚 استرجاع المعلومات ذات الصلة...",
+                    "✨ توليد الإجابة المثلى..."
+                ],
+                "en": [
+                    "🔍 Analyzing request and requirements...",
+                    "🧠 Processing data and researching...",
+                    "📚 Retrieving relevant information...",
+                    "✨ Generating optimal response..."
+                ]
+            },
+            "code": {
+                "ar": [
+                    "🔍 تحليل متطلبات الكود...",
+                    "🧠 تصميم الخوارزمية...",
+                    "📚 البحث عن الحلول المثلى...",
+                    "✨ كتابة وتوليد الكود..."
+                ],
+                "en": [
+                    "🔍 Analyzing code requirements...",
+                    "🧠 Designing algorithm...",
+                    "📚 Researching optimal solutions...",
+                    "✨ Writing and generating code..."
+                ]
+            },
+            "image": {
+                "ar": [
+                    "🔍 تحليل وصف الصورة...",
+                    "🧠 تكوين المفاهيم الفنية...",
+                    "🎨 رسم العناصر الأساسية...",
+                    "✨ إضافة اللمسات النهائية..."
+                ],
+                "en": [
+                    "🔍 Analyzing image description...",
+                    "🧠 Composing artistic concepts...",
+                    "🎨 Sketching basic elements...",
+                    "✨ Adding final touches..."
+                ]
+            },
+            "video": {
+                "ar": [
+                    "🔍 تحليل السيناريو...",
+                    "🎬 إعداد القصة والمشاهد...",
+                    "🎞️ تركيب العناصر المرئية...",
+                    "✨ إضافة المؤثرات والصوت..."
+                ],
+                "en": [
+                    "🔍 Analyzing scenario...",
+                    "🎬 Preparing storyboard and scenes...",
+                    "🎞️ Composing visual elements...",
+                    "✨ Adding effects and sound..."
+                ]
+            },
+            "project": {
+                "ar": [
+                    "🔍 تحليل متطلبات المشروع...",
+                    "📝 تحديد الهيكل الأساسي...",
+                    "🛠️ إعداد الملفات والموارد...",
+                    "✨ إنشاء المشروع الجديد..."
+                ],
+                "en": [
+                    "🔍 Analyzing project requirements...",
+                    "📝 Defining basic structure...",
+                    "🛠️ Preparing files and resources...",
+                    "✨ Creating new project..."
+                ]
+            }
         }
-    }
-    return steps.get(task_type, steps["text"]).get(lang, steps["text"]["en"])
+    
+    def get_thinking_steps(self, task_type: str, lang: str = "en") -> List[str]:
+        """الحصول على خطوات التفكير حسب نوع المهمة واللغة"""
+        return self.planning_steps.get(task_type, self.planning_steps["text"]).get(lang, self.planning_steps["text"]["en"])
+    
+    async def generate_plan(self, prompt: str, task_type: str = "text") -> dict:
+        """إنشاء خطة تنفيذية للمهمة"""
+        lang = detect(prompt)
+        steps = self.get_thinking_steps(task_type, lang)
+        
+        plan = {
+            "task": prompt,
+            "type": task_type,
+            "language": lang,
+            "steps": steps,
+            "estimated_time": "30 seconds",  # يمكن جعل هذا أكثر دقة
+            "required_resources": ["CPU", "GPU"] if task_type in ["image", "video"] else ["CPU"],
+            "created_at": str(datetime.now())
+        }
+        
+        return plan
+
+thinker = ThinkingEngine()
 
-# 6. نماذج طلبات API
+# 7. نماذج طلبات API
 class GenerationRequest(BaseModel):
     prompt: str
-    content_type: str = "text"  # text, code, image, video
-    language: Optional[str] = None  # للكود البرمجي
+    content_type: str = "text"  # text, code, image, video, project
+    language: Optional[str] = None
+    conversation_id: Optional[str] = None
+    improvements: Optional[List[str]] = None
+
+class ConversationRequest(BaseModel):
+    initial_prompt: str
+    project_id: Optional[str] = None
 
 class ProjectRequest(BaseModel):
     name: str
     description: str
-    project_type: str  # web, mobile, desktop, ai
+    project_type: str  # web, mobile, desktop, ai, other
 
 class CodeImprovementRequest(BaseModel):
     code: str
     language: str
-    improvements: List[str]
+    improvements: List[str] = Field(..., example=["add_comments", "optimize", "add_error_handling"])
 
-# 7. نقاط النهاية الأساسية
-@app.post("/api/generate")
-async def generate(request: GenerationRequest):
-    def stream_response():
-        try:
-            # اكتشاف اللغة
-            lang = detect(request.prompt)
-            model_name = LANGUAGE_MODELS.get(lang, "gpt2-medium")
-            
-            # عرض عملية التفكير
-            steps = thinking_process(lang, request.content_type)
-            for step in steps:
-                yield f"data: {step}\n\n"
-                time.sleep(1)
+# 8. نظام إدارة المحادثات عبر WebSocket
+class ConnectionManager:
+    def __init__(self):
+        self.active_connections: Dict[str, WebSocket] = {}
+    
+    async def connect(self, conversation_id: str, websocket: WebSocket):
+        await websocket.accept()
+        self.active_connections[conversation_id] = websocket
+    
+    def disconnect(self, conversation_id: str):
+        if conversation_id in self.active_connections:
+            del self.active_connections[conversation_id]
+    
+    async def send_message(self, conversation_id: str, message: str):
+        if conversation_id in self.active_connections:
+            await self.active_connections[conversation_id].send_text(message)
+
+manager = ConnectionManager()
+
+# 9. نقاط النهاية الأساسية
+@app.post("/api/conversation/start")
+async def start_conversation(request: ConversationRequest):
+    """بدء محادثة جديدة"""
+    conv_id = memory.create_conversation(request.initial_prompt)
+    
+    if request.project_id and request.project_id in memory.projects:
+        memory.projects[request.project_id]["conversations"].append(conv_id)
+        memory.save_projects()
+    
+    # إضافة الرسالة الأولى
+    memory.add_message(
+        conv_id=conv_id,
+        role="user",
+        content=request.initial_prompt,
+        metadata={"type": "text", "project_id": request.project_id}
+    )
+    
+    return {"conversation_id": conv_id, "name": memory.conversations[conv_id]["name"]}
+
+@app.websocket("/api/conversation/ws/{conversation_id}")
+async def websocket_conversation(websocket: WebSocket, conversation_id: str):
+    """محادثة في الوقت الحقيقي عبر WebSocket"""
+    await manager.connect(conversation_id, websocket)
+    
+    try:
+        while True:
+            data = await websocket.receive_text()
+            message = json.loads(data)
             
-            # توليد المحتوى حسب النوع
-            if request.content_type == "text":
-                model = await engine.load_text_model(model_name)
-                inputs = model["tokenizer"](request.prompt, return_tensors="pt")
-                outputs = model["model"].generate(**inputs, max_length=300)
-                response = model["tokenizer"].decode(outputs[0], skip_special_tokens=True)
-                score = evaluate_response(request.prompt, response)
+            if message["type"] == "user_message":
+                # حفظ رسالة المستخدم
+                memory.add_message(
+                    conv_id=conversation_id,
+                    role="user",
+                    content=message["content"],
+                    metadata={"type": message.get("content_type", "text")}
+                )
                 
-            elif request.content_type == "code":
-                response = await engine.generate_code(request.prompt, request.language or "python")
-                score = 0.9  # درجة ثقة عالية للكود
+                # إنشاء خطة للرد
+                content_type = message.get("content_type", "text")
+                plan = await thinker.generate_plan(message["content"], content_type)
                 
-            elif request.content_type == "image":
-                pipe = await engine.load_image_model()
-                image = pipe(request.prompt).images[0]
-                image_path = f"uploads/generated_image_{int(time.time())}.png"
-                image.save(image_path)
-                response = f"IMAGE_GENERATED:{image_path}"
-                score = 0.85
+                # إرسال خطوات التفكير
+                for step in plan["steps"]:
+                    await manager.send_message(conversation_id, json.dumps({
+                        "type": "thinking",
+                        "content": step
+                    }))
+                    await asyncio.sleep(1)
                 
-            elif request.content_type == "video":
-                video_path = await engine.generate_video(request.prompt)
-                response = f"VIDEO_GENERATED:{video_path}"
-                score = 0.8
+                # توليد الرد
+                if content_type == "text":
+                    response = await engine.generate_text(message["content"])
+                elif content_type == "code":
+                    response = await engine.generate_code(message["content"], message.get("language", "python"))
+                elif content_type == "image":
+                    image_path = await engine.generate_image(message["content"])
+                    response = f"IMAGE_GENERATED:{image_path}"
+                elif content_type == "video":
+                    video_path = await engine.generate_video(message["content"])
+                    response = f"VIDEO_GENERATED:{video_path}"
+                else:
+                    response = "نوع المحتوى غير مدعوم"
                 
-            else:
-                raise HTTPException(status_code=400, detail="نوع المحتوى غير مدعوم")
-            
-            # حفظ التفاعل
-            memory.save_interaction("chat", {
-                "prompt": request.prompt,
-                "response": response,
-                "type": request.content_type,
-                "language": lang,
-                "timestamp": str(datetime.now()),
-                "confidence": score
-            })
-            
-            yield f"data: FINAL_RESPONSE:{response}:{score}\n\n"
-        
-        except Exception as e:
-            logging.error(f"Error in generation: {str(e)}")
-            yield f"data: ERROR:{str(e)}\n\n"
-
-    return StreamingResponse(stream_response(), media_type="text/event-stream")
-
-# 8. إدارة المشاريع
-@app.post("/api/create_project")
-async def create_project(request: ProjectRequest):
-    try:
-        project_dir = f"projects/{request.name.replace(' ', '_')}"
-        os.makedirs(project_dir, exist_ok=True)
-        
-        # إنشاء ملفات المشروع الأساسية
-        with open(f"{project_dir}/README.md", "w") as f:
-            f.write(f"# {request.name}\n\n{request.description}")
-            
-        memory.save_interaction("project", {
-            "name": request.name,
-            "type": request.project_type,
-            "path": project_dir,
-            "created_at": str(datetime.now()),
-            "status": "active"
-        })
-        
-        return {"status": "success", "project_path": project_dir}
+                # تحليل الرد
+                evaluation = analytics.evaluate_response(message["content"], response)
+                
+                # حفظ الرد
+                memory.add_message(
+                    conv_id=conversation_id,
+                    role="assistant",
+                    content=response,
+                    metadata={
+                        "type": content_type,
+                        "evaluation": evaluation,
+                        "plan": plan
+                    }
+                )
+                
+                # إرسال الرد النهائي
+                await manager.send_message(conversation_id, json.dumps({
+                    "type": "assistant_response",
+                    "content": response,
+                    "evaluation": evaluation
+                }))
+                
+    except WebSocketDisconnect:
+        manager.disconnect(conversation_id)
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        logger.error(f"WebSocket error: {str(e)}")
+        await manager.send_message(conversation_id, json.dumps({
+            "type": "error",
+            "content": f"حدث خطأ: {str(e)}"
+        }))
 
-# 9. تحسين الكود
-@app.post("/api/improve_code")
+@app.post("/api/project/create")
+async def create_project(request: ProjectRequest, api_key: str = Depends(API_KEY_HEADER)):
+    """إنشاء مشروع جديد"""
+    if not authenticate(api_key):
+        raise HTTPException(status_code=403, detail="غير مصرح به")
+    
+    project_id = memory.create_project(request.name, request.description, request.project_type)
+    
+    # إنشاء مجلد المشروع
+    project_dir = f"projects/{project_id}"
+    os.makedirs(project_dir, exist_ok=True)
+    
+    # إنشاء ملفات أساسية
+    with open(f"{project_dir}/README.md", "w", encoding="utf-8") as f:
+        f.write(f"# {request.name}\n\n{request.description}\n\nCreated by MarkAI at {datetime.now()}")
+    
+    return {"project_id": project_id, "path": project_dir}
+
+@app.post("/api/code/improve")
 async def improve_code(request: CodeImprovementRequest):
-    try:
-        improved_code = f"""{request.code}
-        
-# التحسينات المطبقة:
-# {' | '.join(request.improvements)}
-# تم تحسين الكود بواسطة MarkAI في {datetime.now()}
-"""
-        
-        memory.save_interaction("code", {
+    """تحسين الكود المقدم"""
+    analysis = await engine.analyze_code(request.code, request.language)
+    improved_code = await engine.improve_code(request.code, request.language, request.improvements)
+    
+    # حفظ الكود المحسن
+    code_id = memory.save_code_snippet(
+        code=improved_code,
+        language=request.language,
+        purpose="Improved code",
+        metadata={
             "original_code": request.code,
-            "improved_code": improved_code,
-            "language": request.language,
             "improvements": request.improvements,
-            "timestamp": str(datetime.now())
-        })
-        
-        return {"status": "success", "improved_code": improved_code}
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-# 10. تحليل المشاعر
-@app.post("/api/analyze_sentiment")
-async def analyze_sentiment(text: str):
-    try:
-        # محاكاة لتحليل المشاعر (في الإصدار الحقيقي سيتم استخدام نموذج متخصص)
-        positive_words = ["جيد", "رائع", "ممتاز", "سعيد"]
-        negative_words = ["سيء", "مزعج", "حزين", "غاضب"]
-        
-        positive_count = sum(text.count(word) for word in positive_words)
-        negative_count = sum(text.count(word) for word in negative_words)
-        
-        sentiment = "neutral"
-        if positive_count > negative_count:
-            sentiment = "positive"
-        elif negative_count > positive_count:
-            sentiment = "negative"
-        
-        score = (positive_count - negative_count) / len(text.split())
-        
-        return {
-            "sentiment": sentiment,
-            "score": score,
-            "positive_words": positive_count,
-            "negative_words": negative_count
+            "analyzed_at": str(datetime.now())
         }
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+    )
+    
+    return {
+        "improved_code": improved_code,
+        "analysis": analysis,
+        "code_id": code_id
+    }
+
+@app.get("/api/conversation/list")
+async def list_conversations(project_id: Optional[str] = None):
+    """الحصول على قائمة المحادثات"""
+    if project_id and project_id in memory.projects:
+        convs = [memory.conversations[cid] for cid in memory.projects[project_id]["conversations"] if cid in memory.conversations]
+    else:
+        convs = list(memory.conversations.values())
+    
+    return {"conversations": convs}
+
+@app.get("/api/project/list")
+async def list_projects():
+    """الحصول على قائمة المشاريع"""
+    return {"projects": list(memory.projects.values())}
+
+@app.get("/api/code/list")
+async def list_code_snippets(language: Optional[str] = None):
+    """الحصول على قائمة الأكواد المحفوظة"""
+    snippets = list(memory.code_repository.values())
+    
+    if language:
+        snippets = [s for s in snippets if s["language"].lower() == language.lower()]
+    
+    return {"snippets": snippets}
+
+# 10. نظام النسخ الاحتياطي التلقائي
+async def backup_scheduler():
+    while True:
+        await asyncio.sleep(3600)  # كل ساعة
+        try:
+            backup_dir = memory.backup_data()
+            logger.info(f"تم إنشاء نسخة احتياطية في: {backup_dir}")
+        except Exception as e:
+            logger.error(f"فشل النسخ الاحتياطي: {str(e)}")
 
 # 11. واجهة المستخدم
 app.mount("/static", StaticFiles(directory="static"), name="static")
@@ -363,50 +752,28 @@ templates = Jinja2Templates(directory="templates")
 async def read_root(request: Request):
     return templates.TemplateResponse("index.html", {"request": request})
 
-# 12. نقاط نهاية إضافية
-@app.get("/api/memory")
-async def get_memory():
-    return {
-        "chat_history": memory.interactions[-10:],
-        "projects": memory.projects,
-        "code_snippets": memory.code_snippets
-    }
-
-@app.get("/api/download/{file_type}/{filename}")
-async def download_file(file_type: str, filename: str):
-    file_path = f"uploads/{filename}"
-    if os.path.exists(file_path):
-        return FileResponse(file_path)
-    raise HTTPException(status_code=404, detail="File not found")
-
-# 13. نظام النسخ الاحتياطي التلقائي
-def backup_data():
-    try:
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        for data_type, data in [("chat", memory.interactions), 
-                               ("projects", memory.projects),
-                               ("code", memory.code_snippets)]:
-            backup_path = f"memory/{data_type}_backup_{timestamp}.json"
-            with open(backup_path, "w", encoding="utf-8") as f:
-                json.dump(data, f, ensure_ascii=False, indent=2)
-    except Exception as e:
-        logging.error(f"Backup failed: {str(e)}")
-
-# تشغيل النسخ الاحتياطي كل ساعة
-async def backup_scheduler():
-    while True:
-        await asyncio.sleep(3600)
-        backup_data()
+@app.get("/chat/{conversation_id}", response_class=HTMLResponse)
+async def chat_interface(request: Request, conversation_id: str):
+    if conversation_id not in memory.conversations:
+        raise HTTPException(status_code=404, detail="المحادثة غير موجودة")
+    
+    return templates.TemplateResponse("chat.html", {
+        "request": request,
+        "conversation": memory.conversations[conversation_id]
+    })
 
-# بدء المهمة الجانبية
+# 12. بدء المهام الجانبية
 @app.on_event("startup")
 async def startup_event():
     asyncio.create_task(backup_scheduler())
+    
     # تحميل النماذج الأساسية مسبقاً
-    await engine.load_text_model("gpt2-medium")
-    await engine.load_image_model()
+    await engine.load_model("text")
+    await engine.load_model("code")
+    
+    logger.info("تم بدء تشغيل MarkAI بنجاح")
 
-# 14. تشغيل التطبيق
+# 13. تشغيل التطبيق
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(app, host="0.0.0.0", port=7860, reload=True)