eslint-config-ai-swe/src/utils/agents-md-generator.js

ESLint configuration optimized for AI Agents SWE with TypeScript and multi-framework support.

export function generateAgentsMd(suggestedConfigs) {
  const rules = [];
  
  // Extract rules from AI configuration
  if (suggestedConfigs.includes('ai')) {
    rules.push(...extractAIRules());
  }
  
  // Extract rules from TypeScript configuration
  if (suggestedConfigs.includes('typescript')) {
    rules.push(...extractTypeScriptRules());
  }
  
  // Extract rules from framework configurations
  if (suggestedConfigs.includes('react')) {
    rules.push(...extractReactRules());
  }
  
  if (suggestedConfigs.includes('vue')) {
    rules.push(...extractVueRules());
  }
  
  if (suggestedConfigs.includes('svelte')) {
    rules.push(...extractSvelteRules());
  }
  
  return generateMarkdown(rules);
}

function extractAIRules() {
  return [
    {
      name: 'complexity',
      description: 'Maintient une complexité cyclomatique faible pour une meilleure lisibilité',
      recommendation: 'Garder la complexité ≤ 6',
      benefit: 'Code plus facile à comprendre et maintenir',
    },
    {
      name: 'max-lines-per-function',
      description: 'Limite la taille des fonctions pour améliorer la lisibilité',
      recommendation: 'Maximum 40 lignes par fonction',
      benefit: 'Fonctions plus focales et testables',
    },
    {
      name: 'max-depth',
      description: 'Contrôle la profondeur d\'imbrication du code',
      recommendation: 'Maximum 2 niveaux d\'imbrication',
      benefit: 'Réduit la complexité cognitive',
    },
    {
      name: 'max-params',
      description: 'Limite le nombre de paramètres de fonction',
      recommendation: 'Maximum 3 paramètres',
      benefit: 'Meilleure maintenabilité et testabilité',
    },
  ];
}

function extractTypeScriptRules() {
  return [
    {
      name: '@typescript-eslint/no-explicit-any',
      description: 'Empêche l\'utilisation du type any',
      recommendation: 'Utiliser des types spécifiques ou unknown',
      benefit: 'Meilleure sécurité des types',
    },
    {
      name: '@typescript-eslint/no-unsafe-assignment',
      description: 'Empêche les assignations non sécurisées',
      recommendation: 'Vérifier les types avant assignation',
      benefit: 'Évite les erreurs de type à l\'exécution',
    },
    {
      name: '@typescript-eslint/consistent-type-imports',
      description: 'Enforce l\'utilisation de import type',
      recommendation: 'Utiliser import type pour les types uniquement',
      benefit: 'Meilleure séparation des types et valeurs',
    },
  ];
}

function extractReactRules() {
  return [
    {
      name: 'react-hooks/rules-of-hooks',
      description: 'Enforce les règles des Hooks React',
      recommendation: 'Toujours appeler les hooks au niveau supérieur',
      benefit: 'Évite les bugs subtils avec les hooks',
    },
    {
      name: 'react-hooks/exhaustive-deps',
      description: 'Vérifie les dépendances des hooks',
      recommendation: 'Inclure toutes les dépendances dans le tableau de dépendances',
      benefit: 'Prévient les effets de bord et stale closures',
    },
  ];
}

function extractVueRules() {
  return [
    {
      name: 'vue/require-v-for-key',
      description: 'Exige une clé pour les v-for',
      recommendation: 'Toujours fournir une clé unique pour v-for',
      benefit: 'Meilleure performance et évitement de bugs',
    },
    {
      name: 'vue/no-unused-vars',
      description: 'Détecte les variables non utilisées',
      recommendation: 'Supprimer ou utiliser toutes les variables déclarées',
      benefit: 'Code plus propre et performant',
    },
  ];
}

function extractSvelteRules() {
  return [
    {
      name: 'svelte/no-unused-vars',
      description: 'Détecte les variables non utilisées dans les composants Svelte',
      recommendation: 'Supprimer ou utiliser toutes les variables déclarées',
      benefit: 'Code plus propre et performant',
    },
    {
      name: 'svelte/valid-compile',
      description: 'Vérifie que le composant Svelte compile correctement',
      recommendation: 'Corriger les erreurs de syntaxe Svelte',
      benefit: 'Évite les erreurs de compilation',
    },
  ];
}

function generateMarkdown(rules) {
  const timestamp = new Date().toISOString();
  
  return `# AGENTS.md - Règles de Guidage pour l'IA

*Auto-généré par eslint-config-ai-swe le ${timestamp}*

## Introduction

Ce document contient les règles de linting et recommandations spécifiques pour aider les agents IA à écrire du code de haute qualité qui respecte les standards du projet.

## Règles Essentielles

${rules.map(rule => `
### \`${rule.name}\`

**Description:** ${rule.description}

**Recommandation:** ${rule.recommendation}

**Bénéfice:** ${rule.benefit}
`).join('\n')}

## Principes Généraux

1. **Simplicité avant tout** - Le code doit être simple et facile à comprendre
2. **Sécurité des types** - Utiliser TypeScript avec des types stricts
3. **Performance** - Éviter les opérations coûteuses et optimiser le rendu
4. **Maintenabilité** - Écrire du code qui est facile à modifier et étendre

## Bonnes Pratiques

### Fonctions
- Garder les fonctions courtes et focales
- Limiter le nombre de paramètres
- Utiliser des noms de fonctions descriptifs
- Documenter les fonctions complexes

### TypeScript
- Toujours utiliser des types spécifiques
- Éviter \`any\` et \`unknown\` quand c'est possible
- Utiliser \`import type\` pour les imports de types
- Préférer les interfaces aux types pour les objets

### React/Vue/Svelte
- Suivre les meilleures pratiques du framework
- Utiliser les hooks correctement
- Gérer les états de manière appropriée
- Optimiser le rendu

## Outils Utilisés

- **ESLint** - Linting statique
- **TypeScript** - Vérification des types
- **Prettier** - Formatage du code (optionnel)
- **Framework-specific plugins** - Règles adaptées au framework

## Mise à Jour

Ce document est généré automatiquement lors de la configuration du projet. Pour le mettre à jour, exécutez:

\`\`\`bash
npx eslint-config-ai-swe setup --force
\`\`\`

---

*Document généré par eslint-config-ai-swe - Ne pas modifier manuellement*
`;
}