veza/VEZA_COMPLETE_AUDIT_PROMPT.md

# VEZA Complete MVP Audit & Todolist Generator

## 🎯 Mission

Tu es un agent d'audit exhaustif. Ta mission est de scanner **l'intégralité** du codebase Veza et générer une **todolist de 200+ tâches** couvrant tout ce qui est nécessaire pour atteindre un **MVP stable prêt pour la production à petite échelle**.

**RÈGLE ABSOLUE** : Ne JAMAIS ignorer, skipper ou supprimer une feature/route/fonction. Si quelque chose existe côté frontend mais pas backend (ou inversement), **AJOUTE UNE TÂCHE** pour l'implémenter. L'objectif est la **progression**, pas la régression ni la stagnation.

---

## 📁 Répertoires à Scanner

```
veza/
├── apps/web/                    # Frontend React/TypeScript (SCAN COMPLET)
│   ├── src/
│   │   ├── components/          # Composants UI
│   │   ├── features/            # Features par domaine
│   │   ├── hooks/               # Custom hooks
│   │   ├── pages/               # Pages/routes
│   │   ├── services/            # Services API
│   │   ├── stores/              # State management
│   │   ├── types/               # Types TypeScript
│   │   ├── utils/               # Utilitaires
│   │   └── schemas/             # Validation Zod
│   ├── public/
│   └── tests/
│
├── veza-backend-api/            # Backend Go/Gin (SCAN COMPLET)
│   ├── cmd/                     # Entry points
│   ├── internal/
│   │   ├── api/                 # Routes & handlers
│   │   ├── config/              # Configuration
│   │   ├── dto/                 # Data Transfer Objects
│   │   ├── middleware/          # Middlewares
│   │   ├── models/              # Database models
│   │   ├── repository/          # Data access
│   │   ├── services/            # Business logic
│   │   └── errors/              # Error handling
│   └── migrations/
│
├── veza-common/                 # Shared code (SI EXISTE)
├── veza-chat-server/            # Chat server Rust (SI EXISTE)
├── veza-stream-server/          # Streaming server (SI EXISTE)
├── docker-compose*.yml          # Infrastructure
└── docs/                        # Documentation
```

---

## 🔍 Protocole d'Audit Exhaustif

### ÉTAPE 1 : Cartographie du Frontend (apps/web/)

```bash
# 1.1 Lister TOUTES les routes/pages
find apps/web/src/pages apps/web/src/features/*/pages -name "*.tsx" 2>/dev/null

# 1.2 Lister TOUS les services API
find apps/web/src/services apps/web/src/features/*/services -name "*.ts" 2>/dev/null

# 1.3 Lister TOUS les appels API
grep -rn "apiClient\.\|axios\.\|fetch(" apps/web/src/ --include="*.ts" --include="*.tsx"

# 1.4 Lister TOUS les types/interfaces
find apps/web/src/types apps/web/src/features/*/types -name "*.ts" 2>/dev/null

# 1.5 Lister TOUS les stores (state management)
find apps/web/src/stores apps/web/src/features/*/stores -name "*.ts" 2>/dev/null

# 1.6 Lister TOUS les hooks custom
find apps/web/src/hooks apps/web/src/features/*/hooks -name "*.ts" 2>/dev/null

# 1.7 Lister TOUS les composants
find apps/web/src/components apps/web/src/features/*/components -name "*.tsx" 2>/dev/null

# 1.8 Lister TOUS les schemas de validation
find apps/web/src/schemas apps/web/src/features/*/schemas -name "*.ts" 2>/dev/null

# 1.9 Lister les tests existants
find apps/web/src -name "*.test.ts" -o -name "*.test.tsx" -o -name "*.spec.ts" 2>/dev/null
```

### ÉTAPE 2 : Cartographie du Backend (veza-backend-api/)

```bash
# 2.1 Lister TOUTES les routes définies
grep -rn "router\.\(GET\|POST\|PUT\|DELETE\|PATCH\)" veza-backend-api/internal/api/

# 2.2 Lister TOUS les handlers
find veza-backend-api/internal/handlers veza-backend-api/internal/api -name "*.go" 2>/dev/null

# 2.3 Lister TOUS les models
find veza-backend-api/internal/models -name "*.go" 2>/dev/null

# 2.4 Lister TOUS les DTOs
find veza-backend-api/internal/dto -name "*.go" 2>/dev/null

# 2.5 Lister TOUS les services
find veza-backend-api/internal/services -name "*.go" 2>/dev/null

# 2.6 Lister TOUS les repositories
find veza-backend-api/internal/repository -name "*.go" 2>/dev/null

# 2.7 Lister TOUS les middlewares
find veza-backend-api/internal/middleware -name "*.go" 2>/dev/null

# 2.8 Lister les migrations
find veza-backend-api/migrations -name "*.sql" 2>/dev/null

# 2.9 Lister les tests existants
find veza-backend-api -name "*_test.go" 2>/dev/null
```

### ÉTAPE 3 : Analyse de l'Intégration

```bash
# 3.1 Extraire TOUS les endpoints appelés par le frontend
grep -rohn "apiClient\.[a-z]*\s*(\s*['\"\`][^'\"\`]*" apps/web/src/ | sort | uniq

# 3.2 Extraire TOUTES les routes backend
grep -rn "router\.\(GET\|POST\|PUT\|DELETE\|PATCH\)" veza-backend-api/internal/api/ | grep -o '"[^"]*"' | sort | uniq

# 3.3 Comparer les deux listes pour trouver les gaps

# 3.4 Vérifier la cohérence des types
# Frontend types vs Backend DTOs

# 3.5 Vérifier les variables d'environnement
grep -rn "VITE_" apps/web/src/
grep -rn "os.Getenv" veza-backend-api/
```

### ÉTAPE 4 : Scanner les Autres Services (si présents)

```bash
# veza-common
ls -la veza-common/ 2>/dev/null

# veza-chat-server
ls -la veza-chat-server/ 2>/dev/null
grep -rn "route\|endpoint\|handler" veza-chat-server/src/ 2>/dev/null

# veza-stream-server
ls -la veza-stream-server/ 2>/dev/null
```

---

## 📋 Catégories de Tâches à Générer

Pour chaque élément trouvé, génère des tâches dans ces catégories :

### 1. BACKEND - Routes API (BE-API-XXX)
- Routes manquantes appelées par le frontend
- Routes existantes mais incomplètes
- Validation des inputs manquante
- Gestion des erreurs insuffisante
- Documentation OpenAPI manquante

### 2. BACKEND - Models & Database (BE-DB-XXX)
- Models manquants ou incomplets
- Migrations manquantes
- Index manquants
- Relations mal définies
- Soft delete non implémenté

### 3. BACKEND - Services & Logic (BE-SVC-XXX)
- Business logic manquante
- Validation métier manquante
- Transactions non gérées
- Caching non implémenté

### 4. BACKEND - Security (BE-SEC-XXX)
- Authentication gaps
- Authorization gaps
- Rate limiting manquant
- Input sanitization
- CORS issues

### 5. BACKEND - Tests (BE-TEST-XXX)
- Tests unitaires manquants
- Tests d'intégration manquants
- Coverage insuffisante

### 6. FRONTEND - Pages & Routes (FE-PAGE-XXX)
- Pages incomplètes
- Routes mal configurées
- Layouts manquants
- Navigation broken

### 7. FRONTEND - Components (FE-COMP-XXX)
- Composants manquants
- Props non typées
- Accessibilité (a11y)
- Responsive design
- Error boundaries

### 8. FRONTEND - Services & API (FE-API-XXX)
- Services API incomplets
- Error handling manquant
- Loading states manquants
- Retry logic manquant

### 9. FRONTEND - State Management (FE-STATE-XXX)
- Stores incomplets
- State sync issues
- Cache invalidation
- Optimistic updates

### 10. FRONTEND - Types & Validation (FE-TYPE-XXX)
- Types manquants ou incorrects
- Zod schemas manquants
- Runtime validation

### 11. FRONTEND - Tests (FE-TEST-XXX)
- Tests unitaires manquants
- Tests de composants manquants
- Tests E2E manquants

### 12. INTEGRATION (INT-XXX)
- Contract mismatches
- Type inconsistencies
- Missing endpoints
- Response format issues

### 13. INFRASTRUCTURE (INFRA-XXX)
- Docker configuration
- Environment variables
- CI/CD pipeline
- Monitoring/Logging

### 14. DOCUMENTATION (DOC-XXX)
- API documentation
- README updates
- Architecture docs
- Deployment guide

### 15. SECURITY (SEC-XXX)
- Authentication issues
- Authorization issues
- Data exposure risks
- Dependency vulnerabilities

---

## 📊 Format de Sortie JSON

Génère le fichier `VEZA_COMPLETE_MVP_TODOLIST.json` avec cette structure :

```json
{
  "meta": {
    "title": "Veza Complete MVP Todolist",
    "description": "Exhaustive todolist for production-ready MVP",
    "generated_at": "ISO_TIMESTAMP",
    "total_tasks": 200,
    "target": "Production-ready MVP at small scale",
    "scanned_directories": [
      "apps/web/",
      "veza-backend-api/",
      "veza-common/",
      "..."
    ],
    "audit_methodology": "Full codebase scan + integration analysis"
  },
  "summary": {
    "by_priority": {
      "P0_critical": 0,
      "P1_high": 0,
      "P2_medium": 0,
      "P3_low": 0
    },
    "by_category": {
      "BE-API": 0,
      "BE-DB": 0,
      "BE-SVC": 0,
      "BE-SEC": 0,
      "BE-TEST": 0,
      "FE-PAGE": 0,
      "FE-COMP": 0,
      "FE-API": 0,
      "FE-STATE": 0,
      "FE-TYPE": 0,
      "FE-TEST": 0,
      "INT": 0,
      "INFRA": 0,
      "DOC": 0,
      "SEC": 0
    },
    "by_owner": {
      "backend": 0,
      "frontend": 0,
      "fullstack": 0,
      "devops": 0
    },
    "estimated_total_hours": 0
  },
  "phases": [
    {
      "id": "PHASE-1",
      "name": "Critical Foundation",
      "description": "Must fix before any other work",
      "priority": "P0",
      "estimated_days": 0,
      "tasks": []
    },
    {
      "id": "PHASE-2",
      "name": "Core Features Completion",
      "description": "Complete essential user-facing features",
      "priority": "P1",
      "estimated_days": 0,
      "tasks": []
    },
    {
      "id": "PHASE-3",
      "name": "Integration & Consistency",
      "description": "Ensure frontend/backend work seamlessly",
      "priority": "P1",
      "estimated_days": 0,
      "tasks": []
    },
    {
      "id": "PHASE-4",
      "name": "Security Hardening",
      "description": "Security measures for production",
      "priority": "P1",
      "estimated_days": 0,
      "tasks": []
    },
    {
      "id": "PHASE-5",
      "name": "Testing & Quality",
      "description": "Test coverage and code quality",
      "priority": "P2",
      "estimated_days": 0,
      "tasks": []
    },
    {
      "id": "PHASE-6",
      "name": "Performance & Optimization",
      "description": "Optimize for production load",
      "priority": "P2",
      "estimated_days": 0,
      "tasks": []
    },
    {
      "id": "PHASE-7",
      "name": "Documentation & DevOps",
      "description": "Documentation and deployment readiness",
      "priority": "P2",
      "estimated_days": 0,
      "tasks": []
    },
    {
      "id": "PHASE-8",
      "name": "Polish & UX",
      "description": "UI/UX improvements and polish",
      "priority": "P3",
      "estimated_days": 0,
      "tasks": []
    }
  ],
  "tasks": [
    {
      "id": "BE-API-001",
      "phase": "PHASE-2",
      "priority": "P1",
      "priority_rank": 1,
      "category": "backend-api",
      "title": "Task title",
      "description": "Detailed description",
      "owner": "backend",
      "estimated_hours": 2,
      "status": "todo",
      "files_involved": [
        {
          "path": "veza-backend-api/internal/...",
          "action": "create|modify|delete",
          "reason": "Why this file"
        }
      ],
      "implementation_steps": [
        {
          "step": 1,
          "action": "What to do",
          "details": "How to do it"
        }
      ],
      "acceptance_criteria": [
        "Criterion 1",
        "Criterion 2"
      ],
      "dependencies": ["OTHER-TASK-ID"],
      "related_frontend": "FE-XXX-YYY",
      "related_backend": "BE-XXX-YYY",
      "test_requirements": [
        "Unit test for...",
        "Integration test for..."
      ],
      "notes": "Additional context"
    }
  ],
  "gap_analysis": {
    "frontend_calls_without_backend": [
      {
        "frontend_location": "apps/web/src/services/xxx.ts:42",
        "endpoint_called": "GET /api/v1/something",
        "backend_status": "NOT_FOUND",
        "task_created": "BE-API-XXX"
      }
    ],
    "backend_routes_without_frontend": [
      {
        "backend_location": "veza-backend-api/internal/api/router.go:123",
        "endpoint_defined": "POST /api/v1/something-else",
        "frontend_usage": "NOT_FOUND",
        "task_created": "FE-API-XXX"
      }
    ],
    "type_mismatches": [
      {
        "frontend_type": "apps/web/src/types/user.ts - id: number",
        "backend_type": "veza-backend-api/internal/dto/user.go - ID: uuid.UUID",
        "task_created": "INT-XXX"
      }
    ]
  },
  "risk_register": [
    {
      "risk": "Description of risk",
      "severity": "high|medium|low",
      "mitigation_tasks": ["TASK-ID-1", "TASK-ID-2"],
      "owner": "backend|frontend|devops"
    }
  ],
  "mvp_definition": {
    "must_have_features": [
      {
        "feature": "User Authentication",
        "status": "complete|partial|missing",
        "tasks_required": ["BE-API-001", "FE-PAGE-001"]
      }
    ],
    "nice_to_have": [
      {
        "feature": "Advanced Search",
        "tasks_if_included": ["BE-API-050", "FE-COMP-030"]
      }
    ],
    "out_of_scope": [
      "Feature X - reason"
    ]
  },
  "progress_tracking": {
    "completed": 0,
    "in_progress": 0,
    "todo": 200,
    "blocked": 0,
    "last_updated": null,
    "completion_percentage": 0
  }
}
```

---

## 🔢 Règles de Priorisation

### P0 - Critical (Blocker)
- L'app ne démarre pas
- Crash systématique
- Faille de sécurité majeure
- Perte de données possible
- Authentication cassée

### P1 - High (Core Feature)
- Feature essentielle non fonctionnelle
- Intégration frontend/backend cassée
- UX bloquante pour l'utilisateur
- Performance inacceptable

### P2 - Medium (Important)
- Feature secondaire non fonctionnelle
- Inconsistances visuelles
- Tests manquants pour code critique
- Documentation manquante

### P3 - Low (Nice to Have)
- Améliorations UX mineures
- Refactoring non urgent
- Tests pour code non critique
- Optimisations mineures

---

## ⚠️ Règles Absolues

### NE JAMAIS :
- ❌ Ignorer une route/feature parce qu'elle n'est pas implémentée
- ❌ Recommander de supprimer du code qui appelle des endpoints manquants
- ❌ Sauter des fichiers "parce qu'ils semblent obsolètes"
- ❌ Limiter l'audit à certains dossiers seulement
- ❌ Générer moins de 200 tâches

### TOUJOURS :
- ✅ Créer une tâche pour implémenter ce qui manque
- ✅ Documenter les deux côtés (frontend + backend) pour chaque gap
- ✅ Lier les tâches entre elles (dependencies, related_*)
- ✅ Inclure des critères d'acceptation testables
- ✅ Estimer les heures de travail

---

## 🚀 Séquence d'Exécution

```
1. SCAN FRONTEND
   └── Lister tous les fichiers
   └── Extraire tous les appels API
   └── Identifier tous les types
   └── Trouver tous les composants/pages
   └── Détecter les tests manquants

2. SCAN BACKEND
   └── Lister toutes les routes
   └── Extraire tous les handlers
   └── Identifier tous les models/DTOs
   └── Trouver tous les services
   └── Détecter les tests manquants

3. ANALYSE D'INTÉGRATION
   └── Comparer endpoints frontend vs backend
   └── Comparer types frontend vs DTOs backend
   └── Identifier TOUS les gaps
   └── Créer tâches pour chaque gap

4. SCAN SERVICES ANNEXES
   └── veza-common
   └── veza-chat-server
   └── veza-stream-server
   └── Autres...

5. ANALYSE SÉCURITÉ
   └── Auth/AuthZ gaps
   └── Input validation
   └── CORS/CSRF
   └── Secrets exposure

6. ANALYSE INFRA
   └── Docker configs
   └── Environment vars
   └── CI/CD gaps

7. GÉNÉRATION TODOLIST
   └── Créer toutes les tâches
   └── Assigner les priorités
   └── Calculer les estimations
   └── Organiser en phases
   └── Générer le JSON final
```

---

## 📤 Output Attendu

À la fin de l'audit, tu dois produire :

1. **`VEZA_COMPLETE_MVP_TODOLIST.json`** — Le fichier JSON avec 200+ tâches
2. **Résumé dans la conversation** :
   ```
   ══════════════════════════════════════════════════════
   📊 AUDIT COMPLET VEZA - RÉSUMÉ
   ══════════════════════════════════════════════════════
   
   Total tâches générées: XXX
   
   Par priorité:
   • P0 (Critical): XX tâches
   • P1 (High): XX tâches
   • P2 (Medium): XX tâches
   • P3 (Low): XX tâches
   
   Par catégorie:
   • Backend API: XX
   • Backend DB: XX
   • Backend Services: XX
   • Frontend Pages: XX
   • Frontend Components: XX
   • Integration: XX
   • Security: XX
   • Tests: XX
   • Infrastructure: XX
   • Documentation: XX
   
   Gaps critiques détectés:
   • XX endpoints appelés par frontend mais non implémentés
   • XX routes backend sans utilisation frontend
   • XX type mismatches
   
   Estimation totale: XXX heures (~XX semaines)
   
   Fichier généré: VEZA_COMPLETE_MVP_TODOLIST.json
   ══════════════════════════════════════════════════════
   ```

---

## 🎯 COMMENCE MAINTENANT

1. **Lis la structure du projet** :
   ```bash
   ls -la
   find . -type d -name "src" | head -20
   ```

2. **Scanne le frontend** (apps/web/)

3. **Scanne le backend** (veza-backend-api/)

4. **Identifie les gaps d'intégration**

5. **Génère les 200+ tâches**

6. **Produis le fichier JSON final**

**Première action** : Lister la structure racine du projet et identifier tous les répertoires à scanner.