Initial commit

EXAMPLES.md

@@ -0,0 +1,587 @@
+# Exemples d'utilisation - AI Code Assistant
+
+## 🔌 Intégrations API
+
+### 1. Utiliser l'API depuis Python
+
+```python
+import requests
+import json
+
+API_URL = "http://localhost:9001"
+
+# Exemple 1: Chat simple
+def ask_ai(question, model="qwen2.5-coder:7b"):
+    response = requests.post(
+        f"{API_URL}/chat",
+        json={
+            "messages": [{"role": "user", "content": question}],
+            "model": model,
+            "stream": False
+        }
+    )
+    return response.json()["response"]
+
+# Utilisation
+result = ask_ai("Écris une fonction pour valider un email")
+print(result)
+
+
+# Exemple 2: Exécuter du code
+def run_code(code, language="python"):
+    response = requests.post(
+        f"{API_URL}/execute",
+        json={"code": code, "language": language}
+    )
+    result = response.json()
+    
+    if result["success"]:
+        return result["stdout"]
+    else:
+        return f"Erreur: {result['stderr']}"
+
+# Utilisation
+code = """
+def fibonacci(n):
+    if n <= 1:
+        return n
+    return fibonacci(n-1) + fibonacci(n-2)
+
+print(fibonacci(10))
+"""
+
+output = run_code(code)
+print(output)
+
+
+# Exemple 3: Analyse de code
+def analyze_code(code, language="python"):
+    response = requests.post(
+        f"{API_URL}/analyze-code",
+        json={"code": code, "language": language}
+    )
+    return response.json()["analysis"]
+
+# Utilisation
+code_to_analyze = """
+def divide(a, b):
+    return a / b
+"""
+
+analysis = analyze_code(code_to_analyze)
+print(analysis)
+```
+
+### 2. WebSocket en Python
+
+```python
+import asyncio
+import websockets
+import json
+
+async def chat_websocket():
+    uri = "ws://localhost:9001/ws/chat"
+    
+    async with websockets.connect(uri) as websocket:
+        # Envoyer un message
+        message = {
+            "message": "Explique les decorators Python",
+            "model": "qwen2.5-coder:7b"
+        }
+        await websocket.send(json.dumps(message))
+        
+        # Recevoir la réponse en streaming
+        full_response = ""
+        while True:
+            response = await websocket.recv()
+            data = json.loads(response)
+            
+            if data["type"] == "stream":
+                full_response += data["content"]
+                print(data["content"], end="", flush=True)
+            
+            elif data["type"] == "done":
+                print("\n\nRéponse complète reçue!")
+                break
+            
+            elif data["type"] == "error":
+                print(f"\nErreur: {data['content']}")
+                break
+
+# Exécuter
+asyncio.run(chat_websocket())
+```
+
+### 3. Intégration JavaScript/Node.js
+
+```javascript
+// chat.js - Utilisation depuis Node.js
+const axios = require('axios');
+
+const API_URL = 'http://localhost:9001';
+
+// Chat simple
+async function askAI(question, model = 'qwen2.5-coder:7b') {
+    const response = await axios.post(`${API_URL}/chat`, {
+        messages: [{ role: 'user', content: question }],
+        model: model,
+        stream: false
+    });
+    
+    return response.data.response;
+}
+
+// Exécution de code
+async function executeCode(code, language = 'python') {
+    const response = await axios.post(`${API_URL}/execute`, {
+        code: code,
+        language: language
+    });
+    
+    return response.data;
+}
+
+// Utilisation
+(async () => {
+    // Question à l'IA
+    const answer = await askAI('Crée une fonction pour trier un array');
+    console.log(answer);
+    
+    // Exécuter du code
+    const result = await executeCode('print("Hello from AI!")');
+    console.log(result.stdout);
+})();
+```
+
+### 4. WebSocket depuis le navigateur
+
+```javascript
+// Dans votre page HTML
+const ws = new WebSocket('ws://localhost:9001/ws/chat');
+
+ws.onopen = () => {
+    console.log('Connecté au serveur');
+    
+    // Envoyer un message
+    ws.send(JSON.stringify({
+        message: 'Explique les promises en JavaScript',
+        model: 'qwen2.5-coder:7b'
+    }));
+};
+
+ws.onmessage = (event) => {
+    const data = JSON.parse(event.data);
+    
+    if (data.type === 'stream') {
+        // Afficher le contenu au fur et à mesure
+        document.getElementById('response').innerHTML += data.content;
+    } else if (data.type === 'done') {
+        console.log('Réponse complète');
+    } else if (data.type === 'error') {
+        console.error('Erreur:', data.content);
+    }
+};
+
+ws.onerror = (error) => {
+    console.error('Erreur WebSocket:', error);
+};
+```
+
+## 🛠️ Scripts utilitaires
+
+### Script de génération automatique de tests
+
+```python
+#!/usr/bin/env python3
+"""
+Génère automatiquement des tests unitaires pour un fichier Python
+"""
+
+import requests
+import sys
+import os
+
+API_URL = "http://localhost:9001"
+
+def generate_tests(code_file):
+    # Lire le code
+    with open(code_file, 'r') as f:
+        code = f.read()
+    
+    # Demander à l'IA de générer les tests
+    prompt = f"""
+Génère des tests unitaires complets avec pytest pour ce code:
+
+```python
+{code}
+```
+
+Inclus:
+- Tests pour tous les cas normaux
+- Tests pour les cas limites
+- Tests pour les erreurs attendues
+- Fixtures si nécessaire
+"""
+    
+    response = requests.post(
+        f"{API_URL}/chat",
+        json={
+            "messages": [{"role": "user", "content": prompt}],
+            "model": "code-expert",
+            "stream": False
+        }
+    )
+    
+    tests = response.json()["response"]
+    
+    # Sauvegarder les tests
+    test_file = f"test_{os.path.basename(code_file)}"
+    
+    # Extraire le code des blocs markdown
+    import re
+    code_blocks = re.findall(r'```python\n(.*?)```', tests, re.DOTALL)
+    
+    if code_blocks:
+        with open(test_file, 'w') as f:
+            f.write(code_blocks[0])
+        print(f"✅ Tests générés: {test_file}")
+    else:
+        print("❌ Impossible d'extraire les tests")
+        print(tests)
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print("Usage: python generate_tests.py <fichier.py>")
+        sys.exit(1)
+    
+    generate_tests(sys.argv[1])
+```
+
+### Script de revue de code automatique
+
+```python
+#!/usr/bin/env python3
+"""
+Effectue une revue de code automatique sur un fichier
+"""
+
+import requests
+import sys
+from pathlib import Path
+
+API_URL = "http://localhost:9001"
+
+def review_file(filepath):
+    # Lire le fichier
+    code = Path(filepath).read_text()
+    language = filepath.split('.')[-1]
+    
+    # Analyser avec l'IA
+    response = requests.post(
+        f"{API_URL}/analyze-code",
+        json={"code": code, "language": language}
+    )
+    
+    analysis = response.json()["analysis"]
+    
+    # Afficher la revue
+    print(f"\n{'='*60}")
+    print(f"📝 Revue de code: {filepath}")
+    print(f"{'='*60}\n")
+    print(analysis)
+    print(f"\n{'='*60}\n")
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print("Usage: python code_review.py <fichier>")
+        sys.exit(1)
+    
+    review_file(sys.argv[1])
+```
+
+### Script de documentation automatique
+
+```python
+#!/usr/bin/env python3
+"""
+Génère automatiquement de la documentation pour un fichier de code
+"""
+
+import requests
+import sys
+
+API_URL = "http://localhost:9001"
+
+def generate_docs(code_file):
+    with open(code_file, 'r') as f:
+        code = f.read()
+    
+    prompt = f"""
+Génère une documentation complète en français pour ce code:
+
+```python
+{code}
+```
+
+Inclus:
+- Description générale du module
+- Documentation de chaque fonction/classe
+- Exemples d'utilisation
+- Notes importantes
+- Format: docstrings Google style
+"""
+    
+    response = requests.post(
+        f"{API_URL}/chat",
+        json={
+            "messages": [{"role": "user", "content": prompt}],
+            "model": "code-expert",
+            "stream": False
+        }
+    )
+    
+    docs = response.json()["response"]
+    
+    # Sauvegarder
+    doc_file = f"{code_file}.md"
+    with open(doc_file, 'w') as f:
+        f.write(f"# Documentation - {code_file}\n\n")
+        f.write(docs)
+    
+    print(f"✅ Documentation générée: {doc_file}")
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print("Usage: python generate_docs.py <fichier.py>")
+        sys.exit(1)
+    
+    generate_docs(sys.argv[1])
+```
+
+## 🔄 Intégration Git Hooks
+
+### Pre-commit hook pour revue automatique
+
+```bash
+#!/bin/bash
+# .git/hooks/pre-commit
+
+# Revue automatique des fichiers Python modifiés
+
+echo "🔍 Revue de code automatique..."
+
+# Trouver les fichiers Python modifiés
+PYTHON_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep '\.py$')
+
+if [ -z "$PYTHON_FILES" ]; then
+    echo "Aucun fichier Python à vérifier"
+    exit 0
+fi
+
+# Analyser chaque fichier
+for file in $PYTHON_FILES; do
+    echo "Analyse: $file"
+    
+    # Appeler l'API d'analyse
+    CODE=$(cat "$file")
+    ANALYSIS=$(curl -s -X POST http://localhost:9001/analyze-code \
+        -H "Content-Type: application/json" \
+        -d "{\"code\": $(echo "$CODE" | jq -Rs .), \"language\": \"python\"}" \
+        | jq -r '.analysis')
+    
+    # Vérifier si des problèmes critiques sont détectés
+    if echo "$ANALYSIS" | grep -qi "CRITIQUE\|ERREUR\|BUG"; then
+        echo "⚠️  Problèmes détectés dans $file:"
+        echo "$ANALYSIS"
+        echo ""
+        
+        read -p "Voulez-vous continuer le commit ? (o/n) " -n 1 -r
+        echo
+        if [[ ! $REPLY =~ ^[Oo]$ ]]; then
+            exit 1
+        fi
+    fi
+done
+
+echo "✅ Revue terminée"
+exit 0
+```
+
+## 🎯 Cas d'usage avancés
+
+### 1. Assistant de refactoring
+
+```python
+def refactor_code(code, instructions):
+    prompt = f"""
+Code actuel:
+```python
+{code}
+```
+
+Instructions de refactoring: {instructions}
+
+Fournis le code refactoré en suivant les best practices.
+"""
+    
+    response = requests.post(
+        f"{API_URL}/chat",
+        json={
+            "messages": [{"role": "user", "content": prompt}],
+            "model": "code-expert",
+            "stream": False
+        }
+    )
+    
+    return response.json()["response"]
+
+# Exemple
+old_code = """
+def calc(x, y, op):
+    if op == '+':
+        return x + y
+    elif op == '-':
+        return x - y
+    elif op == '*':
+        return x * y
+    elif op == '/':
+        return x / y
+"""
+
+refactored = refactor_code(old_code, "Utilise un dict avec des lambdas")
+print(refactored)
+```
+
+### 2. Générateur de migrations DB
+
+```python
+def generate_migration(old_schema, new_schema):
+    prompt = f"""
+Ancien schéma:
+{old_schema}
+
+Nouveau schéma:
+{new_schema}
+
+Génère une migration Alembic pour passer de l'ancien au nouveau schéma.
+"""
+    
+    response = requests.post(
+        f"{API_URL}/chat",
+        json={
+            "messages": [{"role": "user", "content": prompt}],
+            "model": "code-expert",
+            "stream": False
+        }
+    )
+    
+    return response.json()["response"]
+```
+
+### 3. Détection de code dupliqué
+
+```python
+def find_duplicates(project_dir):
+    import os
+    
+    files_content = {}
+    
+    # Lire tous les fichiers Python
+    for root, dirs, files in os.walk(project_dir):
+        for file in files:
+            if file.endswith('.py'):
+                filepath = os.path.join(root, file)
+                with open(filepath, 'r') as f:
+                    files_content[filepath] = f.read()
+    
+    # Demander à l'IA d'analyser
+    prompt = f"""
+Analyse ces fichiers et identifie le code dupliqué:
+
+{json.dumps(files_content, indent=2)}
+
+Liste:
+1. Les blocs de code dupliqués
+2. Les fonctions similaires qui pourraient être mutualisées
+3. Des suggestions de refactoring
+"""
+    
+    response = requests.post(
+        f"{API_URL}/chat",
+        json={
+            "messages": [{"role": "user", "content": prompt}],
+            "model": "code-expert",
+            "stream": False
+        }
+    )
+    
+    return response.json()["response"]
+```
+
+## 📱 Intégration VS Code
+
+### Extension VS Code custom
+
+```json
+// .vscode/tasks.json
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "AI Code Review",
+            "type": "shell",
+            "command": "python",
+            "args": [
+                "${workspaceFolder}/scripts/code_review.py",
+                "${file}"
+            ],
+            "presentation": {
+                "reveal": "always",
+                "panel": "new"
+            }
+        },
+        {
+            "label": "Generate Tests",
+            "type": "shell",
+            "command": "python",
+            "args": [
+                "${workspaceFolder}/scripts/generate_tests.py",
+                "${file}"
+            ]
+        }
+    ]
+}
+```
+
+## 🔥 Performance Tips
+
+### Batch processing de fichiers
+
+```python
+async def analyze_multiple_files(files):
+    import aiohttp
+    import asyncio
+    
+    async with aiohttp.ClientSession() as session:
+        tasks = []
+        
+        for filepath in files:
+            with open(filepath, 'r') as f:
+                code = f.read()
+            
+            task = session.post(
+                f"{API_URL}/analyze-code",
+                json={"code": code, "language": "python"}
+            )
+            tasks.append(task)
+        
+        results = await asyncio.gather(*tasks)
+        
+        return [await r.json() for r in results]
+
+# Utilisation
+files = ['file1.py', 'file2.py', 'file3.py']
+results = asyncio.run(analyze_multiple_files(files))
+```
+
+Bon coding avec votre assistant IA ! 🚀