From 0c859a5b51ede3d81d50690751476f605a39df2b Mon Sep 17 00:00:00 2001 From: Alexandre Gut Date: Tue, 31 Mar 2026 13:10:44 +0200 Subject: [PATCH] Initial commit --- .gitignore | 49 ++ DEBUG.md | 300 ++++++++ EXAMPLES.md | 587 ++++++++++++++++ FEATURES.md | 53 ++ IA-Locale-Code-WSL.md | 1079 ++++++++++++++++++++++++++++ INSTALL.md | 338 +++++++++ LANGUAGES.md | 159 +++++ QUICK-COMMANDS.md | 214 ++++++ QUICKSTART.md | 210 ++++++ README.md | 410 +++++++++++ TROUBLESHOOTING.md | 238 +++++++ backend/main.py | 341 +++++++++ backend/requirements.txt | 6 + frontend/index.html | 1446 ++++++++++++++++++++++++++++++++++++++ start.sh | 151 ++++ stop.sh | 40 ++ 16 files changed, 5621 insertions(+) create mode 100644 .gitignore create mode 100644 DEBUG.md create mode 100644 EXAMPLES.md create mode 100644 FEATURES.md create mode 100644 IA-Locale-Code-WSL.md create mode 100644 INSTALL.md create mode 100644 LANGUAGES.md create mode 100644 QUICK-COMMANDS.md create mode 100644 QUICKSTART.md create mode 100644 README.md create mode 100644 TROUBLESHOOTING.md create mode 100644 backend/main.py create mode 100644 backend/requirements.txt create mode 100644 frontend/index.html create mode 100644 start.sh create mode 100644 stop.sh diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..5f12947 --- /dev/null +++ b/.gitignore @@ -0,0 +1,49 @@ +# ── Node.js / React ─────────────────────────────────────────────────────────── +node_modules/ +dist/ +build/ +.next/ +.nuxt/ +.vite/ +*.tsbuildinfo + +# ── Python ──────────────────────────────────────────────────────────────────── +__pycache__/ +*.py[cod] +venv/ +.venv/ +env/ + +# ── Secrets ──────────────────────────────────────────────────────────────────── +.env +.env.* +.env.local +.env.production +secret.env +*.secret +credentials.json + +# ── Logs ────────────────────────────────────────────────────────────────────── +*.log +logs/ +npm-debug.log* +yarn-debug.log* + +# ── Modèles IA (trop lourds) ────────────────────────────────────────────────── +*.gguf +*.bin +*.safetensors +models/ + +# ── Cache ───────────────────────────────────────────────────────────────────── +.cache/ +.parcel-cache/ +.pytest_cache/ +.coverage + +# ── IDE ─────────────────────────────────────────────────────────────────────── +.vscode/ +.idea/ +*.swp +.DS_Store +Thumbs.db diff --git a/DEBUG.md b/DEBUG.md new file mode 100644 index 0000000..9e5881f --- /dev/null +++ b/DEBUG.md @@ -0,0 +1,300 @@ +# 🔍 Guide de Debug - AI Code Assistant + +## 🛠️ Outils de debug intégrés + +### 1. Console du navigateur (F12) + +**Ouvrir la console :** +- Windows/Linux : `F12` ou `Ctrl+Shift+I` +- Mac : `Cmd+Option+I` + +**Dans l'onglet Console, tu verras :** + +#### Messages normaux ✅ +``` +🚀 Initialisation de l'application... +📡 Réponse /models: 200 +✅ Modèles chargés: 2 +🔌 Tentative de connexion WebSocket à: ws://localhost:9001/ws/chat +✅ WebSocket connecté +📨 Message WebSocket: stream +✅ Réponse complète reçue +``` + +#### Messages d'erreur ❌ +``` +❌ Erreur chargement modèles: TypeError... +❌ Erreur WebSocket: ... +🔴 Erreur React: ... +❌ Erreur rendu message: ... +``` + +### 2. Bandeau d'erreur dans l'UI + +Si une erreur se produit, un bandeau rouge apparaît en haut avec : +- Le message d'erreur +- Un bouton ✕ pour fermer + +### 3. Message backend non accessible + +Si le backend ne répond pas, un message s'affiche au centre : +- Instructions pour démarrer le backend +- Lien vers les logs (F12) + +## 🐛 Problèmes courants et solutions + +### Problème 1 : UI plante quand l'IA génère du code + +**Symptômes :** +- Page devient blanche/bleue +- Erreur dans la console : `Cannot read properties of undefined` + +**Causes possibles :** +1. Caractère spécial non échappé dans le code +2. Balise HTML mal fermée +3. Erreur Prism.js + +**Solution :** +✅ **Corrigé dans cette version !** +- Échappement HTML complet +- Try/catch autour du rendu +- Message d'erreur au lieu de crash + +**Si ça arrive quand même :** +1. Ouvrir F12 → Console +2. Copier l'erreur exacte +3. Rafraîchir la page (Ctrl+F5) +4. Relancer + +### Problème 2 : WebSocket ne connecte pas + +**Dans la console :** +``` +❌ Erreur WebSocket: ... +🔌 WebSocket déconnecté, reconnexion dans 3s... +``` + +**Vérifications :** + +```bash +# 1. Le backend tourne-t-il ? +curl http://localhost:9001/health + +# 2. Voir les logs backend +cat /tmp/fastapi.log + +# 3. Processus Python actif ? +ps aux | grep "python main.py" +``` + +**Solution :** +```bash +cd backend +. venv/bin/activate +python main.py +``` + +Tu dois voir : +``` +INFO: Uvicorn running on http://0.0.0.0:9001 +``` + +### Problème 3 : Code ne s'affiche pas correctement + +**Symptômes :** +- Blocs de code sans couleur +- Caractères bizarres (< >) + +**Dans la console, chercher :** +``` +❌ Erreur Prism.js: ... +``` + +**Solution :** +1. Rafraîchir la page (Ctrl+F5) +2. Vider le cache navigateur +3. Vérifier connexion internet (Prism.js vient du CDN) + +### Problème 4 : Boutons Copier/Tester ne marchent pas + +**Dans la console :** +``` +❌ Erreur copyCode: ... +Élément code introuvable: code-X-Y +``` + +**Solution :** +✅ **Corrigé !** Les boutons ont maintenant : +- Vérification que l'élément existe +- Try/catch pour éviter les crashes +- Logs détaillés + +**Test manuel :** +```javascript +// Dans la console (F12) +window.copyCode('code-0-0') +// Doit afficher une erreur claire si l'ID n'existe pas +``` + +### Problème 5 : Messages ne s'affichent pas + +**Dans la console :** +``` +❌ Erreur rendu message: ... +``` + +**Ce que tu verras dans l'UI :** +- Avatar ⚠️ +- "Erreur d'affichage du message" +- Début du message brut + +**Solution :** +1. Noter l'erreur exacte dans la console +2. Copier le message qui cause problème +3. Relancer le chat + +## 📊 Workflow de debug complet + +### Étape 1 : Ouvrir la console (F12) + +Avant même de tester, ouvre la console pour voir les logs en temps réel. + +### Étape 2 : Envoyer un message test simple + +``` +Écris une fonction Python qui dit bonjour +``` + +**Dans la console, tu devrais voir :** +``` +📨 Message WebSocket: stream +📨 Message WebSocket: stream +... +✅ Réponse complète reçue +``` + +### Étape 3 : Si erreur, identifier le type + +#### Type 1 : Backend (réseau) +``` +❌ Erreur WebSocket: ... +ou +Failed to load resource: net::ERR_CONNECTION_REFUSED +``` +→ Le backend n'est pas démarré + +#### Type 2 : Rendu (React) +``` +🔴 Erreur React: ... +ou +❌ Erreur rendu message: ... +``` +→ Problème d'affichage du contenu + +#### Type 3 : Fonctions (boutons) +``` +❌ Erreur copyCode: ... +``` +→ Problème avec les boutons d'action + +### Étape 4 : Copier les logs + +```bash +# Dans la console (F12), clic droit → Save as... +# Ou copier manuellement les erreurs +``` + +## 🔬 Tests avancés + +### Test 1 : Vérifier que tout est chargé + +Dans la console : +```javascript +// Vérifier React +console.log('React:', typeof React); // doit afficher "object" + +// Vérifier Prism +console.log('Prism:', typeof Prism); // doit afficher "object" + +// Vérifier l'API +fetch('http://localhost:9001/health') + .then(r => r.json()) + .then(d => console.log('Backend:', d)); +``` + +### Test 2 : Vérifier WebSocket manuellement + +```javascript +const ws = new WebSocket('ws://localhost:9001/ws/chat'); +ws.onopen = () => console.log('WS OK'); +ws.onerror = (e) => console.error('WS Error:', e); +``` + +### Test 3 : Tester le rendu d'un message + +```javascript +// Dans la console +const testMsg = { + role: 'assistant', + content: 'Test ```python\nprint("hello")\n```' +}; + +// Voir si ça plante +console.log('Test:', testMsg); +``` + +## 📝 Logs à envoyer si besoin d'aide + +Si tu as un problème, copie et envoie : + +### 1. Logs console navigateur +``` +[Tous les messages rouges ❌ et 🔴] +``` + +### 2. Logs backend +```bash +cat /tmp/fastapi.log +``` + +### 3. État du système +```bash +# Processus actifs +ps aux | grep -E "python|ollama" + +# Ports utilisés +netstat -tlnp | grep -E "9000|9001" + +# Version Python +python3 --version +``` + +## 🎯 Checklist avant de demander de l'aide + +- [ ] Console ouverte (F12) pour voir les logs +- [ ] Backend lancé et accessible (curl http://localhost:9001/health) +- [ ] WebSocket connecté (point vert en bas à droite) +- [ ] Copié les erreurs exactes de la console +- [ ] Testé avec un message simple d'abord +- [ ] Rafraîchi la page (Ctrl+F5) +- [ ] Vidé le cache si nécessaire + +## 💡 Astuces + +1. **Logs en temps réel** : Laisse toujours F12 ouvert quand tu utilises l'app +2. **Preserve log** : Dans F12, coche "Preserve log" pour garder les logs même après refresh +3. **Filtre console** : Tu peux filtrer par "Error" ou "Warning" dans la console +4. **Network tab** : Onglet Network dans F12 pour voir les requêtes HTTP/WebSocket +5. **React DevTools** : Installe React DevTools pour debug React spécifiquement + +--- + +**La nouvelle version a :** +✅ Échappement HTML complet +✅ Try/catch partout +✅ Logs détaillés avec émojis +✅ Messages d'erreur clairs +✅ Bandeau d'erreur visible +✅ Pas de crash, juste des erreurs visibles + +**Plus d'écran bleu ! 🎉** diff --git a/EXAMPLES.md b/EXAMPLES.md new file mode 100644 index 0000000..999beaa --- /dev/null +++ b/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 ") + 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 ") + 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 ") + 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 ! 🚀 diff --git a/FEATURES.md b/FEATURES.md new file mode 100644 index 0000000..4656d28 --- /dev/null +++ b/FEATURES.md @@ -0,0 +1,53 @@ +# 🎨 Nouvelles fonctionnalités - Coloration syntaxique + +## ✨ Améliorations apportées + +### 1. 📋 Blocs de code colorés +Tous les langages sont supportés avec coloration : +- Python, JavaScript, TypeScript, JSX, TSX +- HTML, CSS, JSON, YAML, Markdown +- Bash, SQL, Java, C, C++, Go, Rust, PHP, Ruby + +### 2. 🎯 Boutons sur chaque bloc +- **📋 Copier** : Copie dans le presse-papier +- **▶ Tester** : Ouvre l'éditeur avec le code + +### 3. 💻 Éditeur amélioré +- Sélecteur de langage +- Bouton "Effacer" +- Meilleur design +- Sortie colorée (vert=succès, rouge=erreur) + +## 🧪 Tester maintenant + +### Prompt 1 : Python +``` +Écris une fonction Python pour calculer Fibonacci +``` + +### Prompt 2 : React +``` +Crée un compteur React avec hooks +``` + +### Prompt 3 : Multiple +``` +Crée une todo list avec HTML, CSS et JavaScript +``` + +## 🎨 Couleurs + +- **Violet** : Mots-clés (def, if, async) +- **Vert** : Strings +- **Bleu** : Fonctions +- **Rouge** : Nombres +- **Jaune** : Opérateurs + +## 💡 Utilisation + +1. Demander du code à l'IA +2. Code affiché avec coloration +3. Cliquer "📋 Copier" ou "▶ Tester" +4. Si "Tester" : modifier et exécuter + +🎉 Profitez de votre éditeur coloré ! diff --git a/IA-Locale-Code-WSL.md b/IA-Locale-Code-WSL.md new file mode 100644 index 0000000..ad7e618 --- /dev/null +++ b/IA-Locale-Code-WSL.md @@ -0,0 +1,1079 @@ +# Guide complet : IA locale pour le code sur Windows WSL + +Guide d'installation d'une IA locale performante orientée développement sur Windows avec WSL2 et GPU NVIDIA. + +## Prérequis + +- Windows 10/11 (version 21H2 ou supérieure) +- Carte graphique NVIDIA avec 8GB+ VRAM +- WSL2 installé +- Au moins 50GB d'espace disque libre + +--- + +## Étape 1 : Configuration WSL2 avec support GPU + +### 1.1 Installer/Mettre à jour WSL2 + +Ouvrir PowerShell en **administrateur** : + +```powershell +# Installer WSL2 avec Ubuntu +wsl --install -d Ubuntu-22.04 + +# Ou mettre à jour WSL si déjà installé +wsl --update +``` + +Redémarrer si nécessaire, puis lancer Ubuntu depuis le menu démarrer. + +### 1.2 Installer les drivers NVIDIA pour WSL + +**Sur Windows** (pas dans WSL) : + +1. Télécharger les derniers drivers NVIDIA : https://www.nvidia.com/Download/index.aspx +2. Installer normalement sur Windows +3. Les drivers WSL sont inclus automatiquement + +**Vérification dans WSL** : + +```bash +# Lancer WSL Ubuntu +wsl + +# Vérifier que le GPU est détecté +nvidia-smi +``` + +Tu devrais voir ton GPU et la version CUDA. + +### 1.3 Configurer WSL pour plus de RAM + +Créer/éditer le fichier `.wslconfig` dans Windows : + +**Sur Windows**, créer `C:\Users\VOTRE_NOM\.wslconfig` : + +```ini +[wsl2] +memory=16GB +processors=8 +swap=8GB +localhostForwarding=true + +[experimental] +sparseVhd=true +``` + +Redémarrer WSL : + +```powershell +wsl --shutdown +wsl +``` + +--- + +## Étape 2 : Installation de Docker dans WSL + +```bash +# Mise à jour du système +sudo apt update && sudo apt upgrade -y + +# Installer les dépendances +sudo apt install -y \ + ca-certificates \ + curl \ + gnupg \ + lsb-release + +# Ajouter le repository Docker +sudo mkdir -p /etc/apt/keyrings +curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg + +echo \ + "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \ + $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null + +# Installer Docker +sudo apt update +sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin + +# Ajouter votre user au groupe docker +sudo usermod -aG docker $USER + +# Activer Docker au démarrage +sudo systemctl enable docker +sudo systemctl start docker + +# IMPORTANT : Se déconnecter et reconnecter pour appliquer les permissions +exit +``` + +Relancer WSL et vérifier : + +```bash +docker --version +docker run hello-world +``` + +### 2.1 Installer NVIDIA Container Toolkit + +```bash +# Ajouter le repository NVIDIA +distribution=$(. /etc/os-release;echo $ID$VERSION_ID) +curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg + +curl -s -L https://nvidia.github.io/libnvidia-container/$distribution/libnvidia-container.list | \ + sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \ + sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list + +# Installer le toolkit +sudo apt update +sudo apt install -y nvidia-container-toolkit + +# Configurer Docker pour utiliser le GPU +sudo nvidia-ctk runtime configure --runtime=docker +sudo systemctl restart docker + +# Tester le GPU dans Docker +docker run --rm --gpus all nvidia/cuda:12.0.0-base-ubuntu22.04 nvidia-smi +``` + +--- + +## Étape 3 : Installer Ollama + +```bash +# Télécharger et installer Ollama +curl -fsSL https://ollama.com/install.sh | sh + +# Démarrer le service Ollama +ollama serve & + +# Attendre 5 secondes que le serveur démarre +sleep 5 + +# Vérifier que Ollama fonctionne +ollama list +``` + +### 3.1 Télécharger les modèles optimisés pour le code + +```bash +# Qwen2.5 Coder - Le meilleur rapport qualité/vitesse +ollama pull qwen2.5-coder:7b + +# DeepSeek Coder V2 - Excellente qualité (plus lourd) +ollama pull deepseek-coder-v2:16b + +# Llama 3.1 - Bon généraliste +ollama pull llama3.1:8b + +# Modèle d'embeddings pour le RAG +ollama pull nomic-embed-text +``` + +### 3.2 Tester un modèle + +```bash +# Test simple +ollama run qwen2.5-coder:7b "Écris une fonction Python pour calculer Fibonacci" +``` + +--- + +## Étape 4 : Installer Open WebUI avec support GPU + +```bash +# Lancer Open WebUI avec GPU NVIDIA +docker run -d \ + --gpus all \ + -p 3000:8080 \ + --add-host=host.docker.internal:host-gateway \ + -v open-webui:/app/backend/data \ + --name open-webui \ + --restart always \ + ghcr.io/open-webui/open-webui:cuda + +# Vérifier que le container tourne +docker ps + +# Voir les logs +docker logs open-webui +``` + +**Accéder à l'interface** : +- Ouvrir navigateur Windows : `http://localhost:3000` +- Créer un compte (local, pas de cloud) +- Les modèles Ollama seront détectés automatiquement + +--- + +## Étape 5 : Créer des modèles personnalisés pour le code + +### 5.1 Créer un Modelfile pour assistant code + +```bash +# Créer un dossier pour les modelfiles +mkdir -p ~/ollama-models +cd ~/ollama-models + +# Créer le fichier +cat > CodeExpert.modelfile << 'EOF' +FROM qwen2.5-coder:7b + +PARAMETER temperature 0.2 +PARAMETER top_p 0.95 +PARAMETER top_k 40 +PARAMETER num_ctx 8192 +PARAMETER repeat_penalty 1.1 + +SYSTEM """ +Tu es un expert en développement logiciel avec 15 ans d'expérience. + +RÈGLES : +- Écris du code propre, lisible et maintenable +- Inclus la gestion d'erreurs appropriée +- Ajoute des commentaires pour la logique complexe +- Suis les conventions du langage utilisé +- Propose des optimisations quand pertinent +- Utilise les design patterns appropriés +- Format : markdown avec syntax highlighting + +LANGAGES MAÎTRISÉS : +Python, JavaScript/TypeScript, Java, C++, Go, Rust, SQL, Shell + +SPÉCIALITÉS : +- Architecture logicielle +- Optimisation de performance +- Sécurité applicative +- Tests unitaires +- Clean Code +""" + +TEMPLATE """{{ if .System }}<|im_start|>system +{{ .System }}<|im_end|> +{{ end }}{{ if .Prompt }}<|im_start|>user +{{ .Prompt }}<|im_end|> +{{ end }}<|im_start|>assistant +""" +EOF + +# Créer le modèle custom +ollama create code-expert -f CodeExpert.modelfile + +# Tester +ollama run code-expert "Crée une API REST avec FastAPI pour gérer des utilisateurs" +``` + +### 5.2 Modelfile pour code review + +```bash +cat > CodeReviewer.modelfile << 'EOF' +FROM qwen2.5-coder:7b + +PARAMETER temperature 0.1 +PARAMETER top_p 0.9 +PARAMETER num_ctx 8192 + +SYSTEM """ +Tu es un expert en code review avec un œil pour les détails. + +ANALYSE : +1. 🐛 BUGS : Erreurs logiques, edge cases non gérés +2. 🔒 SÉCURITÉ : Injections SQL, XSS, secrets exposés +3. ⚡ PERFORMANCE : Complexité algorithmique, optimisations +4. 📖 LISIBILITÉ : Nommage, structure, commentaires +5. ✅ BEST PRACTICES : Patterns, conventions, maintenabilité + +FORMAT : +- Liste les problèmes par ordre de priorité +- Donne des suggestions concrètes +- Indique le niveau : CRITIQUE / IMPORTANT / SUGGESTION +""" +EOF + +ollama create code-reviewer -f CodeReviewer.modelfile +``` + +### 5.3 Modelfile pour debugging + +```bash +cat > Debugger.modelfile << 'EOF' +FROM deepseek-coder-v2:16b + +PARAMETER temperature 0.1 +PARAMETER top_p 0.95 +PARAMETER num_ctx 16384 + +SYSTEM """ +Tu es un expert en debugging et résolution de problèmes. + +MÉTHODOLOGIE : +1. Analyse le code et l'erreur fournie +2. Identifie la cause racine +3. Explique pourquoi le bug se produit +4. Propose une correction avec explication +5. Suggère des tests pour éviter la régression + +FOCUS : +- Stack traces +- Erreurs runtime +- Memory leaks +- Race conditions +- Edge cases +""" +EOF + +ollama create debugger -f Debugger.modelfile +``` + +--- + +## Étape 6 : Configuration VS Code avec Continue.dev + +### 6.1 Installer VS Code (si pas déjà fait) + +Sur Windows, télécharger depuis : https://code.visualstudio.com/ + +### 6.2 Installer l'extension WSL + +Dans VS Code : +1. Extensions (Ctrl+Shift+X) +2. Chercher "WSL" +3. Installer "WSL" par Microsoft + +### 6.3 Se connecter à WSL + +1. `Ctrl+Shift+P` → "WSL: Connect to WSL" +2. Ou cliquer sur le bouton vert en bas à gauche → "Connect to WSL" + +### 6.4 Installer Continue.dev + +Dans VS Code (connecté à WSL) : +1. Extensions → Chercher "Continue" +2. Installer "Continue - Codestral, Claude, and more" + +### 6.5 Configurer Continue + +Créer le fichier de config : + +```bash +mkdir -p ~/.continue +cat > ~/.continue/config.json << 'EOF' +{ + "models": [ + { + "title": "Code Expert", + "provider": "ollama", + "model": "code-expert", + "apiBase": "http://localhost:11434" + }, + { + "title": "Qwen Coder", + "provider": "ollama", + "model": "qwen2.5-coder:7b", + "apiBase": "http://localhost:11434" + }, + { + "title": "DeepSeek Coder", + "provider": "ollama", + "model": "deepseek-coder-v2:16b", + "apiBase": "http://localhost:11434" + } + ], + "tabAutocompleteModel": { + "title": "Qwen Fast Autocomplete", + "provider": "ollama", + "model": "qwen2.5-coder:7b", + "apiBase": "http://localhost:11434" + }, + "embeddingsProvider": { + "provider": "ollama", + "model": "nomic-embed-text", + "apiBase": "http://localhost:11434" + }, + "contextProviders": [ + { + "name": "code", + "params": {} + }, + { + "name": "docs", + "params": {} + }, + { + "name": "diff", + "params": {} + }, + { + "name": "terminal", + "params": {} + }, + { + "name": "problems", + "params": {} + }, + { + "name": "folder", + "params": {} + }, + { + "name": "codebase", + "params": {} + } + ], + "slashCommands": [ + { + "name": "edit", + "description": "Edit selected code" + }, + { + "name": "comment", + "description": "Write comments for selected code" + }, + { + "name": "share", + "description": "Export conversation to markdown" + }, + { + "name": "cmd", + "description": "Generate shell command" + } + ] +} +EOF +``` + +### 6.6 Utiliser Continue dans VS Code + +**Raccourcis clavier** : +- `Ctrl+L` : Ouvrir le chat Continue +- `Ctrl+I` : Edit inline (modifier le code sélectionné) +- `Ctrl+Shift+L` : Nouveau chat + +**Commandes slash** : +- `/edit` : Modifier le code sélectionné +- `/comment` : Ajouter des commentaires +- `/fix` : Corriger les erreurs +- `/test` : Générer des tests + +--- + +## Étape 7 : Optimisations avancées + +### 7.1 Script de démarrage automatique + +```bash +cat > ~/start-ai-stack.sh << 'EOF' +#!/bin/bash + +echo "🚀 Démarrage de la stack IA..." + +# Démarrer Ollama en arrière-plan +echo "📦 Démarrage Ollama..." +ollama serve > /dev/null 2>&1 & +sleep 3 + +# Vérifier que Ollama tourne +if curl -s http://localhost:11434/api/tags > /dev/null; then + echo "✅ Ollama démarré" +else + echo "❌ Erreur : Ollama n'a pas démarré" + exit 1 +fi + +# Démarrer Open WebUI si pas déjà lancé +if ! docker ps | grep -q open-webui; then + echo "🌐 Démarrage Open WebUI..." + docker start open-webui 2>/dev/null || \ + docker run -d \ + --gpus all \ + -p 3000:8080 \ + --add-host=host.docker.internal:host-gateway \ + -v open-webui:/app/backend/data \ + --name open-webui \ + --restart always \ + ghcr.io/open-webui/open-webui:cuda + echo "✅ Open WebUI démarré sur http://localhost:3000" +else + echo "✅ Open WebUI déjà actif" +fi + +echo "" +echo "🎉 Stack IA prête !" +echo "📊 GPU Status:" +nvidia-smi --query-gpu=name,memory.total,memory.used --format=csv,noheader,nounits +echo "" +echo "🔗 Accès:" +echo " - Open WebUI: http://localhost:3000" +echo " - Ollama API: http://localhost:11434" +echo "" +echo "📝 Modèles disponibles:" +ollama list +EOF + +chmod +x ~/start-ai-stack.sh +``` + +Utilisation : +```bash +~/start-ai-stack.sh +``` + +### 7.2 Créer un alias dans .bashrc + +```bash +echo "alias ai='~/start-ai-stack.sh'" >> ~/.bashrc +echo "alias ai-stop='docker stop open-webui && pkill ollama'" >> ~/.bashrc +source ~/.bashrc +``` + +Maintenant tu peux juste taper `ai` pour tout lancer. + +### 7.3 Monitoring GPU en temps réel + +```bash +# Installer nvtop pour monitoring GPU +sudo apt install -y nvtop + +# Lancer +nvtop +``` + +Ou utiliser : +```bash +watch -n 1 nvidia-smi +``` + +### 7.4 Script pour tester les performances + +```bash +cat > ~/benchmark-models.sh << 'EOF' +#!/bin/bash + +echo "🎯 Benchmark des modèles..." + +PROMPT="Écris une fonction Python qui implémente QuickSort avec commentaires" + +for MODEL in "qwen2.5-coder:7b" "code-expert" "deepseek-coder-v2:16b"; do + echo "" + echo "⏱️ Testing $MODEL..." + + START=$(date +%s) + ollama run $MODEL "$PROMPT" > /dev/null 2>&1 + END=$(date +%s) + + DURATION=$((END - START)) + echo "✅ $MODEL: ${DURATION}s" +done +EOF + +chmod +x ~/benchmark-models.sh +``` + +--- + +## Étape 8 : Utilisation avancée avec API + +### 8.1 Script Python pour interagir avec Ollama + +```bash +# Installer les dépendances Python +pip install ollama requests rich +``` + +```python +# Créer ~/ai_assistant.py +cat > ~/ai_assistant.py << 'EOF' +#!/usr/bin/env python3 +import ollama +from rich.console import Console +from rich.markdown import Markdown + +console = Console() + +def code_review(code: str, language: str = "python"): + """Effectue une review de code.""" + response = ollama.chat( + model='code-reviewer', + messages=[{ + 'role': 'user', + 'content': f'Review ce code {language}:\n\n```{language}\n{code}\n```' + }] + ) + + md = Markdown(response['message']['content']) + console.print(md) + +def debug_error(code: str, error: str, language: str = "python"): + """Debug une erreur.""" + response = ollama.chat( + model='debugger', + messages=[{ + 'role': 'user', + 'content': f''' +Code {language}: +```{language} +{code} +``` + +Erreur: +``` +{error} +``` + +Trouve et corrige le bug. +''' + }] + ) + + md = Markdown(response['message']['content']) + console.print(md) + +def generate_code(description: str, language: str = "python"): + """Génère du code.""" + response = ollama.chat( + model='code-expert', + messages=[{ + 'role': 'user', + 'content': f'Génère du code {language} pour: {description}' + }] + ) + + md = Markdown(response['message']['content']) + console.print(md) + +if __name__ == "__main__": + import sys + + if len(sys.argv) < 2: + print("Usage:") + print(" python ai_assistant.py review ") + print(" python ai_assistant.py debug ") + print(" python ai_assistant.py generate ''") + sys.exit(1) + + command = sys.argv[1] + + if command == "review" and len(sys.argv) >= 3: + with open(sys.argv[2]) as f: + code = f.read() + code_review(code) + + elif command == "generate" and len(sys.argv) >= 3: + generate_code(sys.argv[2]) + + else: + print("Commande invalide") +EOF + +chmod +x ~/ai_assistant.py +``` + +Utilisation : +```bash +# Review de code +python ~/ai_assistant.py review mon_script.py + +# Génération de code +python ~/ai_assistant.py generate "API REST avec authentification JWT" +``` + +### 8.2 API REST custom avec FastAPI + +```bash +pip install fastapi uvicorn +``` + +```python +# Créer ~/code_api.py +cat > ~/code_api.py << 'EOF' +from fastapi import FastAPI, HTTPException +from pydantic import BaseModel +import ollama + +app = FastAPI(title="Code AI API") + +class CodeRequest(BaseModel): + code: str + language: str = "python" + +class PromptRequest(BaseModel): + prompt: str + model: str = "code-expert" + +@app.post("/review") +async def review_code(request: CodeRequest): + """Review du code.""" + try: + response = ollama.chat( + model='code-reviewer', + messages=[{ + 'role': 'user', + 'content': f'Review ce code {request.language}:\n\n```{request.language}\n{request.code}\n```' + }] + ) + return {"review": response['message']['content']} + except Exception as e: + raise HTTPException(status_code=500, detail=str(e)) + +@app.post("/generate") +async def generate_code(request: PromptRequest): + """Génération de code.""" + try: + response = ollama.chat( + model=request.model, + messages=[{ + 'role': 'user', + 'content': request.prompt + }] + ) + return {"code": response['message']['content']} + except Exception as e: + raise HTTPException(status_code=500, detail=str(e)) + +@app.get("/models") +async def list_models(): + """Liste les modèles disponibles.""" + try: + models = ollama.list() + return {"models": [m['name'] for m in models['models']]} + except Exception as e: + raise HTTPException(status_code=500, detail=str(e)) + +if __name__ == "__main__": + import uvicorn + uvicorn.run(app, host="0.0.0.0", port=8000) +EOF +``` + +Lancer l'API : +```bash +python ~/code_api.py +``` + +Tester : +```bash +# Review de code +curl -X POST http://localhost:8000/review \ + -H "Content-Type: application/json" \ + -d '{"code": "def add(a,b):\n return a+b", "language": "python"}' + +# Générer du code +curl -X POST http://localhost:8000/generate \ + -H "Content-Type: application/json" \ + -d '{"prompt": "Fonction pour valider un email", "model": "code-expert"}' +``` + +--- + +## Étape 9 : Intégration RAG (Retrieval Augmented Generation) + +Pour que l'IA utilise ta documentation/codebase : + +```bash +pip install chromadb langchain +``` + +```python +# Créer ~/rag_codebase.py +cat > ~/rag_codebase.py << 'EOF' +#!/usr/bin/env python3 +import chromadb +from chromadb.config import Settings +import ollama +import os +from pathlib import Path + +class CodebaseRAG: + def __init__(self, codebase_path: str): + self.client = chromadb.Client(Settings( + chroma_db_impl="duckdb+parquet", + persist_directory="./chroma_db" + )) + self.collection = self.client.get_or_create_collection("codebase") + self.codebase_path = Path(codebase_path) + + def index_codebase(self): + """Indexe tous les fichiers de code.""" + extensions = ['.py', '.js', '.ts', '.java', '.cpp', '.go', '.rs'] + + for ext in extensions: + for file_path in self.codebase_path.rglob(f'*{ext}'): + try: + with open(file_path, 'r', encoding='utf-8') as f: + content = f.read() + + # Générer l'embedding avec Ollama + embedding_response = ollama.embeddings( + model='nomic-embed-text', + prompt=content + ) + + self.collection.add( + ids=[str(file_path)], + embeddings=[embedding_response['embedding']], + documents=[content], + metadatas=[{"path": str(file_path), "ext": ext}] + ) + print(f"✅ Indexé: {file_path}") + except Exception as e: + print(f"❌ Erreur {file_path}: {e}") + + def query_codebase(self, question: str, n_results: int = 3): + """Recherche dans la codebase.""" + # Générer l'embedding de la question + query_embedding = ollama.embeddings( + model='nomic-embed-text', + prompt=question + ) + + # Chercher les documents similaires + results = self.collection.query( + query_embeddings=[query_embedding['embedding']], + n_results=n_results + ) + + return results + + def ask(self, question: str): + """Pose une question sur la codebase.""" + # Récupérer les documents pertinents + results = self.query_codebase(question) + + # Construire le contexte + context = "\n\n".join([ + f"Fichier: {meta['path']}\n```\n{doc}\n```" + for doc, meta in zip(results['documents'][0], results['metadatas'][0]) + ]) + + # Générer la réponse avec le contexte + response = ollama.chat( + model='code-expert', + messages=[{ + 'role': 'system', + 'content': 'Tu es un expert qui répond aux questions sur une codebase. Utilise le contexte fourni.' + }, { + 'role': 'user', + 'content': f'''Contexte:\n{context}\n\nQuestion: {question}''' + }] + ) + + return response['message']['content'] + +if __name__ == "__main__": + import sys + + if len(sys.argv) < 3: + print("Usage:") + print(" python rag_codebase.py index ") + print(" python rag_codebase.py ask ''") + sys.exit(1) + + rag = CodebaseRAG("./chroma_db") + + if sys.argv[1] == "index": + rag.codebase_path = Path(sys.argv[2]) + rag.index_codebase() + print("✅ Indexation terminée") + + elif sys.argv[1] == "ask": + answer = rag.ask(sys.argv[2]) + print(answer) +EOF + +chmod +x ~/rag_codebase.py +``` + +Utilisation : +```bash +# Indexer un projet +python ~/rag_codebase.py index /chemin/vers/projet + +# Poser une question +python ~/rag_codebase.py ask "Comment fonctionne l'authentification dans ce projet ?" +``` + +--- + +## Étape 10 : Dépannage et optimisations + +### 10.1 Problèmes courants + +**Ollama ne démarre pas** : +```bash +# Vérifier les processus +ps aux | grep ollama + +# Tuer et relancer +pkill ollama +ollama serve & +``` + +**GPU non détecté** : +```bash +# Vérifier CUDA +nvidia-smi + +# Réinstaller nvidia-container-toolkit +sudo apt remove --purge nvidia-container-toolkit +sudo apt install nvidia-container-toolkit +sudo nvidia-ctk runtime configure --runtime=docker +sudo systemctl restart docker +``` + +**Open WebUI ne charge pas** : +```bash +# Voir les logs +docker logs open-webui + +# Redémarrer +docker restart open-webui + +# Si problème persistant, recréer +docker rm -f open-webui +# Puis relancer la commande docker run de l'étape 4 +``` + +**Manque de mémoire GPU** : +```bash +# Lister les processus GPU +nvidia-smi + +# Utiliser des modèles plus petits ou quantizés +ollama pull qwen2.5-coder:7b-q4_0 # Version plus légère +``` + +### 10.2 Optimiser les performances + +**Ajuster les paramètres Ollama** : + +```bash +# Créer un fichier de config Ollama +mkdir -p ~/.ollama +cat > ~/.ollama/config.json << 'EOF' +{ + "num_gpu": 1, + "gpu_layers": 35, + "num_thread": 8, + "num_ctx": 8192, + "batch_size": 512 +} +EOF +``` + +**Utiliser la quantization appropriée** : + +```bash +# Pour 8GB VRAM +ollama pull qwen2.5-coder:7b-q5_K_M # Meilleure qualité +ollama pull qwen2.5-coder:7b-q4_K_M # Équilibré +ollama pull qwen2.5-coder:7b-q3_K_M # Plus rapide, moins précis +``` + +### 10.3 Surveillance et monitoring + +```bash +# Script de monitoring +cat > ~/monitor-ai.sh << 'EOF' +#!/bin/bash + +echo "📊 Monitoring de l'IA" +echo "====================" +echo "" + +echo "🖥️ GPU:" +nvidia-smi --query-gpu=utilization.gpu,memory.used,memory.total,temperature.gpu --format=csv,noheader,nounits + +echo "" +echo "🐳 Docker Containers:" +docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}" + +echo "" +echo "📦 Ollama Service:" +if curl -s http://localhost:11434/api/tags > /dev/null; then + echo "✅ Running" + echo "Modèles chargés:" + curl -s http://localhost:11434/api/tags | python3 -m json.tool | grep '"name"' +else + echo "❌ Not running" +fi + +echo "" +echo "💾 Espace disque WSL:" +df -h / | tail -1 +EOF + +chmod +x ~/monitor-ai.sh +``` + +--- + +## Récapitulatif des commandes essentielles + +```bash +# Démarrer tout +ai # (alias créé précédemment) + +# Ou manuellement +ollama serve & +docker start open-webui + +# Arrêter tout +ai-stop # (alias créé précédemment) + +# Ou manuellement +docker stop open-webui +pkill ollama + +# Lister les modèles +ollama list + +# Utiliser un modèle en CLI +ollama run code-expert "ton prompt ici" + +# Monitoring +~/monitor-ai.sh +watch -n 1 nvidia-smi + +# Nettoyer l'espace disque +docker system prune -a +ollama rm # Supprimer un modèle non utilisé +``` + +--- + +## Accès et URLs + +- **Open WebUI** : http://localhost:3000 +- **Ollama API** : http://localhost:11434 +- **API REST custom** : http://localhost:8000 (si lancée) + +--- + +## Prochaines étapes recommandées + +1. **Personnaliser les modèles** avec tes propres Modelfiles +2. **Indexer ta codebase** avec le RAG +3. **Créer des prompts** spécialisés pour tes langages favoris +4. **Intégrer avec Git** pour des commits auto-générés +5. **Automatiser les tests** avec l'IA + +--- + +## Ressources + +- Documentation Ollama : https://ollama.ai/docs +- Open WebUI : https://docs.openwebui.com +- Continue.dev : https://continue.dev/docs +- Modèles Ollama : https://ollama.ai/library + +--- + +**🎉 Félicitations ! Ton IA locale est prête.** + +Teste-la avec : +```bash +ollama run code-expert "Crée une API REST complète avec FastAPI pour gérer des tâches avec authentification JWT" +``` diff --git a/INSTALL.md b/INSTALL.md new file mode 100644 index 0000000..c471672 --- /dev/null +++ b/INSTALL.md @@ -0,0 +1,338 @@ +# 🤖 AI Code Assistant - Interface Web Complète + +**Interface web locale style Claude avec FastAPI + React pour développement assisté par IA** + +![Version](https://img.shields.io/badge/version-1.0.0-blue) +![Python](https://img.shields.io/badge/python-3.10+-green) +![FastAPI](https://img.shields.io/badge/FastAPI-0.109-009688) +![License](https://img.shields.io/badge/license-MIT-orange) + +--- + +## 📦 Contenu du package + +``` +ai-code-assistant/ +├── 📖 README.md # Ce fichier +├── 📖 QUICKSTART.md # Guide de démarrage rapide +├── 📖 IA-Locale-Code-WSL.md # Guide complet d'installation Ollama sur WSL +├── 📖 EXAMPLES.md # Exemples d'utilisation avancée +│ +├── 🔧 backend/ +│ ├── main.py # Serveur FastAPI avec WebSocket +│ └── requirements.txt # Dépendances Python +│ +├── 🎨 frontend/ +│ └── index.html # Interface React complète (SPA) +│ +├── 🚀 start.sh # Script de démarrage automatique +└── 🛑 stop.sh # Script d'arrêt +``` + +--- + +## ✨ Fonctionnalités principales + +### 💬 Chat IA en temps réel +- Communication WebSocket avec streaming +- Réponses progressives token par token +- Support multi-modèles Ollama +- Historique des conversations +- Interface moderne style Claude + +### 💻 Éditeur de code intégré +- Éditeur Python avec coloration syntaxique +- Exécution de code en temps réel +- Affichage des résultats et erreurs +- Copie facile des blocs de code + +### 🎨 Design moderne +- Interface sombre avec effets de glassmorphisme +- Animations fluides et micro-interactions +- Typographie soignée (Space Grotesk + JetBrains Mono) +- Responsive design +- Grain texture overlay pour un aspect premium + +### 🔌 API REST complète +- Chat synchrone et asynchrone +- Exécution de code (Python, JS, Bash) +- Analyse de code avec IA +- Correction automatique de bugs +- Liste des modèles disponibles +- Health check endpoint + +--- + +## 🚀 Installation ultra-rapide + +### Prérequis +- **WSL2** avec Ubuntu 22.04+ +- **Python 3.10+** +- **Ollama** installé +- **GPU NVIDIA** 8GB+ (optionnel mais recommandé) + +### En 3 commandes + +```bash +# 1. Extraire l'archive +unzip ai-code-assistant.zip +cd ai-code-assistant + +# 2. Télécharger un modèle +ollama pull qwen2.5-coder:7b + +# 3. Lancer l'application +./start.sh +``` + +**C'est tout !** Ouvrez http://localhost:9000 dans votre navigateur 🎉 + +--- + +## 📚 Documentation + +### 📖 Guides disponibles + +1. **QUICKSTART.md** - Démarrage en 5 minutes + - Installation rapide + - Premiers tests + - Commandes essentielles + - Dépannage rapide + +2. **README.md** (dans le dossier) - Documentation complète + - Architecture détaillée + - Configuration avancée + - API endpoints + - Personnalisation + +3. **IA-Locale-Code-WSL.md** - Installation Ollama complète + - Configuration WSL2 + GPU + - Installation Ollama + - Création de modèles personnalisés + - Optimisations avancées + +4. **EXAMPLES.md** - Exemples d'intégration + - Utilisation de l'API en Python + - WebSocket avancé + - Scripts utilitaires + - Intégration Git hooks + - VS Code integration + +--- + +## 🎯 Utilisation + +### Interface Web + +1. **Lancer**: `./start.sh` +2. **Ouvrir**: http://localhost:9000 +3. **Discuter** avec l'IA dans la zone de chat +4. **Cliquer sur "Code"** pour ouvrir l'éditeur +5. **Tester du code** directement dans le navigateur + +### API + +```python +import requests + +# Chat simple +response = requests.post('http://localhost:9001/chat', json={ + "messages": [{"role": "user", "content": "Écris une fonction de tri"}], + "model": "qwen2.5-coder:7b", + "stream": False +}) +print(response.json()['response']) + +# Exécuter du code +response = requests.post('http://localhost:9001/execute', json={ + "code": "print('Hello AI!')", + "language": "python" +}) +print(response.json()['stdout']) +``` + +### WebSocket (temps réel) + +```javascript +const ws = new WebSocket('ws://localhost:9001/ws/chat'); + +ws.onmessage = (event) => { + const data = JSON.parse(event.data); + if (data.type === 'stream') { + console.log(data.content); // Affiche token par token + } +}; + +ws.send(JSON.stringify({ + message: 'Explique les closures', + model: 'qwen2.5-coder:7b' +})); +``` + +--- + +## 🎨 Captures d'écran + +L'interface offre: +- **Chat fluide** avec réponses en streaming +- **Syntaxe highlighting** pour le code +- **Boutons d'action** (Copier, Tester) sur les blocs de code +- **Éditeur latéral** qui s'ouvre en un clic +- **Design dark mode** avec accents violets +- **Animations subtiles** et professionnelles + +--- + +## 🔧 Configuration + +### Changer le modèle par défaut + +Éditer `frontend/index.html`: +```javascript +const [selectedModel, setSelectedModel] = useState('votre-modele'); +``` + +### Changer les couleurs + +Éditer `frontend/index.html`, section CSS: +```css +:root { + --accent-primary: #7c3aed; /* Couleur principale */ + --accent-secondary: #a78bfa; /* Couleur secondaire */ +} +``` + +### Ajouter des langages + +Éditer `backend/main.py`, fonction `execute_code`: +```python +elif request.language == "ruby": + result = subprocess.run(['ruby', temp_file], ...) +``` + +--- + +## 📡 Endpoints API + +| Endpoint | Méthode | Description | +|----------|---------|-------------| +| `/` | GET | Info API | +| `/models` | GET | Liste des modèles | +| `/chat` | POST | Chat (streaming ou non) | +| `/ws/chat` | WebSocket | Chat temps réel | +| `/execute` | POST | Exécuter du code | +| `/analyze-code` | POST | Analyser du code | +| `/fix-code` | POST | Corriger du code | +| `/health` | GET | Health check | + +Voir **EXAMPLES.md** pour des exemples détaillés. + +--- + +## 🐛 Dépannage + +### Backend ne démarre pas +```bash +# Vérifier les logs +cat /tmp/fastapi.log + +# Vérifier le port +lsof -i :8000 +``` + +### Ollama non accessible +```bash +# Redémarrer Ollama +pkill ollama +ollama serve & +``` + +### WebSocket déconnecté +```bash +# Vérifier la connexion +curl http://localhost:9001/health +``` + +Pour plus de détails, voir **QUICKSTART.md** section Dépannage. + +--- + +## 🚀 Fonctionnalités à venir + +- [ ] Sauvegarde des conversations +- [ ] Export markdown/PDF +- [ ] Support multi-langages (JS, Go, Rust) +- [ ] Debugger visuel +- [ ] Intégration Git +- [ ] Génération de tests automatique +- [ ] RAG sur votre codebase +- [ ] Thèmes personnalisables +- [ ] Mode collaboration + +--- + +## 📊 Performance + +Sur un GPU NVIDIA 8GB: +- **Latence**: < 100ms première réponse +- **Débit**: 40-60 tokens/sec +- **RAM**: ~2-3 GB +- **VRAM**: ~5-6 GB (selon le modèle) + +--- + +## 🤝 Contribution + +Suggestions et améliorations bienvenues ! + +Structure claire: +- **Backend FastAPI** modulaire +- **Frontend React** en SPA (single file) +- **WebSocket** pour temps réel +- **API REST** standard + +--- + +## 📄 Licence + +Projet open source - Utilisation libre + +--- + +## 🙏 Crédits + +- **Ollama** - Modèles LLM locaux +- **FastAPI** - Framework backend +- **React** - Interface utilisateur +- **Anthropic Claude** - Inspiration design + +--- + +## 📞 Support + +Pour toute question: +1. Consulter **QUICKSTART.md** pour les problèmes courants +2. Vérifier **EXAMPLES.md** pour les cas d'usage +3. Lire la doc Ollama: https://ollama.ai/docs + +--- + +**Développé avec ❤️ pour le développement assisté par IA en local** + +🚀 **Commencez maintenant**: `./start.sh` et ouvrez http://localhost:9000 + +--- + +## 📋 Checklist de démarrage + +- [ ] WSL2 installé et fonctionnel +- [ ] Python 3.10+ disponible +- [ ] Ollama installé (`ollama --version`) +- [ ] Modèle téléchargé (`ollama list`) +- [ ] GPU NVIDIA détecté (`nvidia-smi`) - optionnel +- [ ] Fichiers extraits et scripts exécutables +- [ ] Port 8000 et 8080 libres +- [ ] `./start.sh` lancé avec succès +- [ ] Interface accessible sur http://localhost:9000 + +✅ **Tout est OK ?** Profitez de votre assistant IA local ! diff --git a/LANGUAGES.md b/LANGUAGES.md new file mode 100644 index 0000000..2f6510e --- /dev/null +++ b/LANGUAGES.md @@ -0,0 +1,159 @@ +# 🎨 Langages supportés - Coloration syntaxique + +## ✅ Langages avec coloration complète + +### Web Frontend +- ✅ **HTML** (`html`, `markup`) +- ✅ **CSS** (`css`) +- ✅ **JavaScript** (`js`, `javascript`) +- ✅ **TypeScript** (`ts`, `typescript`) +- ✅ **JSX** (`jsx`) - React +- ✅ **TSX** (`tsx`) - React TypeScript + +### Backend +- ✅ **Python** (`python`, `py`) +- ✅ **Java** (`java`) +- ✅ **C** (`c`) +- ✅ **C++** (`cpp`, `c++`) +- ✅ **Go** (`go`) +- ✅ **Rust** (`rust`, `rs`) + +### Database & Config +- ✅ **SQL** (`sql`) +- ✅ **JSON** (`json`) +- ✅ **YAML** (`yaml`, `yml`) +- ✅ **Markdown** (`markdown`, `md`) + +### Scripting +- ✅ **Bash** (`bash`, `sh`, `shell`) + +## ❌ Langages NON supportés (sans coloration) + +- ❌ **PHP** - Retiré car cause des crashes +- ❌ **Ruby** - Retiré pour stabilité + +**Note** : Ces langages s'afficheront quand même, mais sans coloration syntaxique. + +## 🧪 Tester les langages + +### Python +``` +Écris une fonction Python pour calculer Fibonacci +``` + +### JavaScript +``` +Crée une fonction async/await pour fetch des données +``` + +### React (JSX) +``` +Crée un composant React avec useState +``` + +### TypeScript +``` +Écris une interface TypeScript pour un User +``` + +### SQL +``` +Écris une requête SQL pour les 10 meilleurs clients +``` + +### JSON +``` +Crée un exemple de configuration JSON pour une API +``` + +### HTML/CSS +``` +Crée un bouton stylé en HTML et CSS +``` + +### Bash +``` +Écris un script bash pour sauvegarder des fichiers +``` + +## 🎨 Couleurs par langage + +Tous les langages utilisent le même schéma de couleurs : + +| Type | Couleur | Exemple | +|------|---------|---------| +| Mots-clés | 🟣 Violet | `def`, `if`, `const`, `async` | +| Strings | 🟢 Vert | `"hello"`, `'world'` | +| Fonctions | 🔵 Bleu | `print()`, `fetch()` | +| Nombres | 🔴 Rouge | `42`, `3.14` | +| Commentaires | ⚪ Gris | `# comment`, `// comment` | +| Opérateurs | 🟡 Jaune | `+`, `-`, `=`, `=>` | + +## 💡 Astuces + +### 1. Spécifier le langage + +L'IA détecte automatiquement, mais tu peux préciser : +``` +Écris en JavaScript pur (pas TypeScript) une fonction... +``` + +### 2. Multi-langages + +Pour avoir plusieurs blocs : +``` +Crée une todo app avec HTML, CSS et JavaScript séparés +``` + +### 3. Code sans langage + +Si pas de langage détecté, le code s'affiche sans coloration mais reste lisible. + +## 🔧 Problèmes de coloration + +### Code affiché mais pas coloré ? + +**Console (F12) :** +``` +⚠️ Prism.js non chargé +ou +❌ Erreur coloration bloc X: ... +``` + +**Solutions :** +1. Rafraîchir (Ctrl+F5) +2. Vérifier connexion internet +3. Vider cache navigateur + +### Crash lors de la coloration ? + +**Symptôme :** WebSocket se déconnecte après génération de code + +**Dans la console :** +``` +❌ Erreur Prism.highlightElement: ... +🔌 WebSocket déconnecté +``` + +**Solution :** +✅ **Déjà corrigé !** +- Chaque bloc est colorié individuellement +- En cas d'erreur, le bloc reste visible sans coloration +- Le crash d'un bloc n'affecte pas les autres + +## 📊 Statistiques + +- **16 langages** avec coloration complète +- **20+ variantes** de syntaxe (py/python, js/javascript, etc.) +- **0 crash** même si un langage pose problème +- **Fallback automatique** si Prism.js ne charge pas + +## 🚀 Performances + +- Coloration en ~150ms +- Pas de ralentissement même avec plusieurs blocs +- Timeout de sécurité pour éviter le gel + +--- + +**Si tu demandes du PHP ou Ruby, le code s'affichera sans coloration mais sera parfaitement lisible !** diff --git a/QUICK-COMMANDS.md b/QUICK-COMMANDS.md new file mode 100644 index 0000000..2666638 --- /dev/null +++ b/QUICK-COMMANDS.md @@ -0,0 +1,214 @@ +# 🚀 Commandes rapides - START ICI + +## ⚡ Démarrage rapide (3 commandes) + +```bash +# 1. Aller dans le dossier +cd /mnt/e/My\ IA + +# 2. Tuer l'ancien processus sur le port 9001 (si existant) +fuser -k 9001/tcp 2>/dev/null + +# 3. Tout lancer +bash start.sh +``` + +**Ouvrir dans le navigateur** : http://localhost:9000 + +--- + +## 🔥 Si le script ne marche pas : Lancement manuel + +### Terminal 1 : Backend + +```bash +cd /mnt/e/My\ IA/backend + +# Créer venv si pas fait +python3 -m venv venv + +# Activer +. venv/bin/activate + +# Installer dépendances +pip install -r requirements.txt + +# LANCER +python main.py +``` + +Tu verras : +``` +INFO: Uvicorn running on http://0.0.0.0:9001 +``` + +### Terminal 2 : Frontend + +```bash +cd /mnt/e/My\ IA/frontend + +# LANCER +python3 -m http.server 9000 +``` + +### Navigateur + +Ouvrir : **http://localhost:9000** + +--- + +## 🛑 Arrêter tout + +```bash +# Méthode 1 : Script +bash stop.sh + +# Méthode 2 : Tuer les processus +pkill -f "python main.py" +pkill -f "http.server 9000" +pkill ollama + +# Méthode 3 : Par port +fuser -k 9001/tcp # Backend +fuser -k 9000/tcp # Frontend +``` + +--- + +## 🔍 Vérifier que tout tourne + +```bash +# Backend (doit retourner du JSON) +curl http://localhost:9001/health + +# Frontend (doit retourner du HTML) +curl http://localhost:9000 | head -5 + +# Ollama +curl http://localhost:11434/api/tags + +# Tout en un +cat > check.sh << 'EOF' +#!/bin/bash +echo "Backend (9001):" +curl -s http://localhost:9001/health | python3 -m json.tool 2>/dev/null || echo "❌ Non accessible" +echo -e "\nFrontend (9000):" +curl -s http://localhost:9000 | grep -q "/dev/null | head -3 || echo "❌ Non accessible" +EOF +chmod +x check.sh +bash check.sh +``` + +--- + +## 💡 Ports utilisés + +| Service | Port | URL | +|----------|------|-------------------------------| +| Backend | 9001 | http://localhost:9001 | +| Frontend | 9000 | http://localhost:9000 | +| Ollama | 11434| http://localhost:11434 | + +--- + +## 🐛 Résolution de problèmes + +### Erreur : Address already in use + +```bash +# Trouver ce qui utilise le port +lsof -i :9001 + +# Tuer le processus +fuser -k 9001/tcp + +# Ou tuer par PID +kill +``` + +### Backend ne démarre pas + +```bash +# Voir les erreurs +cd backend +. venv/bin/activate +python main.py + +# Réinstaller les dépendances +pip install --upgrade -r requirements.txt +``` + +### Frontend affiche page blanche + +```bash +# Vérifier que index.html existe +ls -la frontend/index.html + +# Si non, retélécharger l'archive +``` + +### WebSocket ne connecte pas + +Le backend doit tourner **avant** d'ouvrir le frontend. + +1. Lancer le backend +2. Attendre le message "Uvicorn running" +3. Puis ouvrir http://localhost:9000 + +--- + +## ✅ Checklist avant de commencer + +- [ ] WSL2 installé +- [ ] Python 3.10+ : `python3 --version` +- [ ] Ollama installé : `which ollama` +- [ ] Modèle téléchargé : `ollama list` +- [ ] Fichiers présents : `ls -la frontend/index.html` +- [ ] Ports libres : `lsof -i :9000` et `lsof -i :9001` → rien + +--- + +## 📱 Ouvrir dans le navigateur (Windows) + +```bash +# Depuis WSL +cmd.exe /c start http://localhost:9000 + +# Ou taper directement dans Windows : +# http://localhost:9000 +``` + +--- + +## 🎯 Si TOUT échoue : Réinstallation propre + +```bash +# 1. Tout arrêter +bash stop.sh +pkill -9 python +pkill -9 ollama + +# 2. Nettoyer +rm -rf backend/venv +rm /tmp/*.log +rm /tmp/ai-assistant-*.pid + +# 3. Retélécharger l'archive +# Télécharger ai-code-assistant.zip + +# 4. Extraire proprement +unzip -o ai-code-assistant.zip +cd ai-code-assistant + +# 5. Lancer +chmod +x *.sh +bash start.sh +``` + +--- + +**EN CAS DE DOUTE : Lance les commandes du Lancement manuel (Terminal 1 + Terminal 2)** + +C'est la méthode la plus fiable pour voir exactement ce qui se passe ! 🎉 diff --git a/QUICKSTART.md b/QUICKSTART.md new file mode 100644 index 0000000..d0a077b --- /dev/null +++ b/QUICKSTART.md @@ -0,0 +1,210 @@ +# 🚀 Guide de démarrage rapide - AI Code Assistant sur WSL + +## Installation en 5 minutes + +### Étape 1: Préparer l'environnement WSL + +```bash +# Ouvrir WSL Ubuntu +wsl + +# Mettre à jour le système +sudo apt update && sudo apt upgrade -y + +# Installer Python et dépendances +sudo apt install -y python3 python3-pip python3-venv + +# Vérifier l'installation +python3 --version # Doit être 3.10+ +``` + +### Étape 2: Créer la structure du projet + +```bash +# Créer le dossier principal +mkdir -p ~/ai-code-assistant +cd ~/ai-code-assistant + +# Créer la structure +mkdir -p backend frontend + +# Copier les fichiers fournis: +# - Copier main.py dans backend/ +# - Copier requirements.txt dans backend/ +# - Copier index.html dans frontend/ +# - Copier start.sh et stop.sh à la racine +``` + +### Étape 3: Installer et configurer + +```bash +# Rendre les scripts exécutables +chmod +x start.sh stop.sh + +# Vérifier qu'Ollama est installé +which ollama + +# Si pas installé: +curl -fsSL https://ollama.com/install.sh | sh + +# Télécharger les modèles +ollama pull qwen2.5-coder:7b +``` + +### Étape 4: Démarrer l'application + +```bash +# Lancer tout en une commande +./start.sh +``` + +**C'est tout !** 🎉 + +L'interface s'ouvrira automatiquement sur **http://localhost:9000** + +## ⚡ Commandes essentielles + +```bash +# Démarrer +./start.sh + +# Arrêter +./stop.sh + +# Redémarrer +./stop.sh && ./start.sh + +# Voir les logs en temps réel +tail -f /tmp/fastapi.log +``` + +## 🎯 Premier test + +1. Ouvrir http://localhost:9000 dans votre navigateur +2. Taper: `"Écris une fonction Python pour calculer Fibonacci"` +3. Voir la réponse s'afficher en temps réel +4. Cliquer sur "Tester" pour exécuter le code +5. Modifier et réexécuter + +## 🐛 Problèmes courants + +### "Port 8000 déjà utilisé" +```bash +# Tuer le processus +kill $(lsof -t -i :8000) +``` + +### "Ollama non accessible" +```bash +# Redémarrer Ollama +pkill ollama +ollama serve & +sleep 3 +``` + +### "Page blanche dans le navigateur" +```bash +# Vérifier que le frontend tourne +curl http://localhost:9000 + +# Si non, relancer +./stop.sh +./start.sh +``` + +## 📱 Accès depuis Windows + +L'application est accessible depuis Windows via: +- **http://localhost:9000** (WSL forward automatique) +- Ou **http://172.x.x.x:8080** (IP WSL, trouvez-la avec `ip addr`) + +## 🎨 Personnalisation rapide + +### Changer les couleurs + +Éditer `frontend/index.html`, section ` + + + +
+ + + + + \ No newline at end of file diff --git a/start.sh b/start.sh new file mode 100644 index 0000000..c080b90 --- /dev/null +++ b/start.sh @@ -0,0 +1,151 @@ +#!/bin/bash + +# Script de démarrage pour AI Code Assistant +# Compatible WSL + +echo "🚀 Démarrage de AI Code Assistant..." +echo "========================================" +echo "" + +# Couleurs +GREEN='\033[0;32m' +RED='\033[0;31m' +YELLOW='\033[1;33m' +NC='\033[0m' # No Color + +# Dossier du script +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" + +# Vérifier si Ollama tourne +echo "📦 Vérification d'Ollama..." +if ! curl -s http://localhost:11434/api/tags > /dev/null 2>&1; then + echo -e "${YELLOW}⚠️ Ollama n'est pas démarré. Démarrage...${NC}" + ollama serve > /tmp/ollama.log 2>&1 & + sleep 3 + + if curl -s http://localhost:11434/api/tags > /dev/null 2>&1; then + echo -e "${GREEN}✅ Ollama démarré${NC}" + else + echo -e "${RED}❌ Erreur: Impossible de démarrer Ollama${NC}" + echo "Vérifiez les logs: /tmp/ollama.log" + exit 1 + fi +else + echo -e "${GREEN}✅ Ollama déjà actif${NC}" +fi + +# Vérifier les modèles +echo "" +echo "🤖 Vérification des modèles..." +MODELS=$(ollama list | grep -c "code-expert\|qwen2.5-coder") +if [ "$MODELS" -eq 0 ]; then + echo -e "${YELLOW}⚠️ Aucun modèle de code détecté${NC}" + echo "Téléchargement de qwen2.5-coder:7b..." + ollama pull qwen2.5-coder:7b +fi + +# Installer les dépendances python3 si nécessaire +echo "" +echo "📚 Vérification des dépendances python3..." +cd "$SCRIPT_DIR/backend" + +if [ ! -d "venv" ]; then + echo "Création de l'environnement virtuel..." + python3 -m venv venv +fi + +# Utiliser . au lieu de source pour compatibilité sh +. venv/bin/activate + +if ! pip show fastapi > /dev/null 2>&1; then + echo "Installation des dépendances..." + pip install -q -r requirements.txt + echo -e "${GREEN}✅ Dépendances installées${NC}" +else + echo -e "${GREEN}✅ Dépendances OK${NC}" +fi + +# Démarrer le backend FastAPI +echo "" +echo "🔧 Démarrage du backend FastAPI..." +python3 main.py > /tmp/fastapi.log 2>&1 & +BACKEND_PID=$! + +# Attendre que le backend soit prêt +sleep 3 + +if kill -0 $BACKEND_PID 2>/dev/null; then + echo -e "${GREEN}✅ Backend démarré (PID: $BACKEND_PID)${NC}" +else + echo -e "${RED}❌ Erreur: Backend n'a pas démarré${NC}" + echo "Vérifiez les logs: /tmp/fastapi.log" + cat /tmp/fastapi.log + exit 1 +fi + +# Démarrer un serveur HTTP simple pour le frontend +echo "" +echo "🌐 Démarrage du frontend..." +cd "$SCRIPT_DIR/frontend" + +# Vérifier que index.html existe +if [ ! -f "index.html" ]; then + echo -e "${RED}❌ Erreur: index.html introuvable dans $(pwd)${NC}" + echo "Contenu du dossier:" + ls -la + exit 1 +fi + +# Tuer l'ancien serveur s'il existe +pkill -f "python3.*http.server.*9000" 2>/dev/null + +python3 -m http.server 9000 > /tmp/frontend.log 2>&1 & +FRONTEND_PID=$! + +sleep 2 + +if kill -0 $FRONTEND_PID 2>/dev/null; then + echo -e "${GREEN}✅ Frontend démarré (PID: $FRONTEND_PID)${NC}" +else + echo -e "${RED}❌ Erreur: Frontend n'a pas démarré${NC}" + cat /tmp/frontend.log + exit 1 +fi + +# Sauvegarder les PIDs +echo $BACKEND_PID > /tmp/ai-assistant-backend.pid +echo $FRONTEND_PID > /tmp/ai-assistant-frontend.pid + +echo "" +echo "========================================" +echo -e "${GREEN}🎉 AI Code Assistant est prêt !${NC}" +echo "========================================" +echo "" +echo "📊 Informations:" +echo " - Backend API: http://localhost:9001" +echo " - Frontend: http://localhost:9000" +echo " - WebSocket: ws://localhost:9001/ws/chat" +echo "" +echo "🔗 Accès:" +echo " Ouvrez votre navigateur sur: ${GREEN}http://localhost:9000${NC}" +echo "" +echo "📝 Logs:" +echo " - Backend: /tmp/fastapi.log" +echo " - Frontend: /tmp/frontend.log" +echo " - Ollama: /tmp/ollama.log" +echo "" +echo "🛑 Pour arrêter:" +echo " bash stop.sh" +echo "" +echo "📋 Modèles disponibles:" +ollama list | grep -v "NAME" +echo "" + +# Ouvrir le navigateur automatiquement (si sur Windows WSL) +if grep -qi microsoft /proc/version; then + echo "💡 Ouverture automatique du navigateur..." + cmd.exe /c start http://localhost:9000 2>/dev/null +fi + +# Suivre les logs en temps réel (optionnel) +# tail -f /tmp/fastapi.log diff --git a/stop.sh b/stop.sh new file mode 100644 index 0000000..9f773d5 --- /dev/null +++ b/stop.sh @@ -0,0 +1,40 @@ +#!/bin/bash + +# Script d'arrêt pour AI Code Assistant + +echo "🛑 Arrêt de AI Code Assistant..." + +# Couleurs +RED='\033[0;31m' +GREEN='\033[0;32m' +NC='\033[0m' + +# Arrêter le backend +if [ -f /tmp/ai-assistant-backend.pid ]; then + BACKEND_PID=$(cat /tmp/ai-assistant-backend.pid) + if kill -0 $BACKEND_PID 2>/dev/null; then + kill $BACKEND_PID + echo -e "${GREEN}✅ Backend arrêté${NC}" + fi + rm /tmp/ai-assistant-backend.pid +fi + +# Arrêter le frontend +if [ -f /tmp/ai-assistant-frontend.pid ]; then + FRONTEND_PID=$(cat /tmp/ai-assistant-frontend.pid) + if kill -0 $FRONTEND_PID 2>/dev/null; then + kill $FRONTEND_PID + echo -e "${GREEN}✅ Frontend arrêté${NC}" + fi + rm /tmp/ai-assistant-frontend.pid +fi + +# Tuer tous les processus http.server sur le port 9000 +pkill -f "python.*http.server.*9000" 2>/dev/null + +# Optionnel: arrêter Ollama (décommenter si souhaité) +# pkill ollama +# echo -e "${GREEN}✅ Ollama arrêté${NC}" + +echo "" +echo "✅ Tous les services sont arrêtés"