ollama-code-qwen/src/services/prompt-service.js

Un assistant IA en ligne de commande utilisant Ollama et le modèle qwen2.5-coder pour aider au développement, avec des capacités MCP améliorées et détection d'intentions en français et anglais

/**
 * Service spécialisé pour la gestion des prompts adaptés par tâche et contexte
 */
export class PromptService {
  constructor(config) {
    this.config = config;
    this.defaultTemperature = config.get('temperature') || 0.5; // Température réduite par défaut
    
    // Prompts système par type de tâche
    this.taskPrompts = {
      // Pour les tâches de génération de code
      code_generation: `
        Tu es un assistant de programmation expert, spécialisé dans la génération de code.
        - Produis du code clair, bien commenté et respectant les bonnes pratiques
        - Gère les cas d'erreur et ajoute des tests unitaires quand c'est approprié
        - Suis les conventions de nommage et de style cohérentes avec le projet
        - Explique brièvement ton raisonnement et les choix d'implémentation
      `,
      
      // Pour les tâches de débogage
      debugging: `
        Tu es un assistant de débogage expert, spécialisé dans la résolution de problèmes de code.
        - Analyse rigoureusement les erreurs et les bugs décrits
        - Identifie la cause racine du problème 
        - Propose des corrections précises en expliquant pourquoi elles fonctionnent
        - Suggère des tests ou vérifications supplémentaires pour valider la correction
      `,
      
      // Pour les tâches de refactorisation
      refactoring: `
        Tu es un assistant de refactorisation expert, spécialisé dans l'amélioration de code existant.
        - Maintiens la fonctionnalité existante tout en améliorant la structure
        - Améliore la lisibilité, la maintenabilité et les performances
        - Explique les bénéfices de chaque modification proposée
        - Respecte les patterns de conception cohérents avec le reste du projet
      `,
      
      // Pour les tâches d'explication de code
      explanation: `
        Tu es un assistant expert en explication de code.
        - Décompose le code en sections logiques et explique leur fonctionnement
        - Identifie les patterns et les algorithmes utilisés
        - Explique les choix d'implémentation et leurs implications
        - Utilise un langage clair et adapté au niveau technique de l'utilisateur
      `,
      
      // Pour les tâches Git
      git_operations: `
        Tu es un assistant Git expert.
        - Aide à formuler des commandes Git précises et sûres
        - Propose des stratégies efficaces pour la gestion des branches et des conflits
        - Rédige des messages de commit clairs et informatifs suivant les conventions
        - Explique les implications des opérations Git proposées
      `,
      
      // Prompt par défaut
      default: `
        Tu es un assistant de programmation intelligent qui aide au développement de logiciels.
        - Réponds de manière concise et précise aux questions techniques
        - Fournis du code bien structuré et documenté quand c'est demandé
        - Explique ton raisonnement et tes recommandations
        - Adapte tes réponses au contexte du projet actuel
      `
    };
    
    // Prompts spécifiques par langage
    this.languagePrompts = {
      javascript: `
        Pour le code JavaScript:
        - Utilise des fonctions fléchées et les features modernes (async/await, destructuring, etc.)
        - Préfère const sur let et évite var
        - Utilise ESM pour les imports/exports sauf indication contraire
        - Ajoute des JSDoc pour documenter les fonctions
      `,
      
      python: `
        Pour le code Python:
        - Suit PEP 8 pour le style de code
        - Utilise les type hints (Python 3.6+)
        - Préfère les list/dict comprehensions quand c'est approprié
        - Utilise des docstrings au format Google ou NumPy
      `,
      
      java: `
        Pour le code Java:
        - Utilise les conventions de nommage Java standard
        - Préfère les classes immuables quand c'est possible
        - Utilise les streams et les lambdas pour les opérations sur collections
        - Ajoute des commentaires Javadoc pour les classes et méthodes publiques
      `,
      
      go: `
        Pour le code Go:
        - Suit le style Go standard (gofmt)
        - Gère les erreurs explicitement
        - Utilise les interfaces de façon appropriée
        - Préfère les slices aux arrays quand la taille est variable
      `,
      
      // Autres langages...
    };
  }
  
  /**
   * Détecte le type de tâche basé sur l'entrée utilisateur
   * @param {string} userInput - Entrée utilisateur
   * @returns {string} - Type de tâche détecté
   */
  detectTaskType(userInput) {
    const input = userInput.toLowerCase();
    
    // Détection simple basée sur des mots-clés
    if (/crée|génère|écris|implément|développe/.test(input)) {
      return 'code_generation';
    }
    
    if (/bug|erreur|corrige|résous|fixe|débogue/.test(input)) {
      return 'debugging';
    }
    
    if (/refactori|améliore|optimise|nettoie|restructure/.test(input)) {
      return 'refactoring';
    }
    
    if (/explique|analyse|comprendre|comment fonctionne|que fait/.test(input)) {
      return 'explanation';
    }
    
    if (/git|commit|branch|merge|pull|push|conflit/.test(input)) {
      return 'git_operations';
    }
    
    return 'default';
  }
  
  /**
   * Détecte le langage de programmation principal basé sur le contexte
   * @param {string} projectContext - Contexte du projet
   * @returns {string|null} - Langage détecté ou null
   */
  detectPrimaryLanguage(projectContext) {
    const languageSignatures = {
      javascript: ['.js', '.jsx', '.ts', '.tsx', 'package.json', 'node_modules'],
      python: ['.py', 'requirements.txt', 'setup.py', '__pycache__'],
      java: ['.java', '.class', 'pom.xml', 'build.gradle'],
      go: ['.go', 'go.mod', 'go.sum'],
      rust: ['.rs', 'Cargo.toml', 'Cargo.lock'],
      ruby: ['.rb', 'Gemfile', 'Rakefile'],
      php: ['.php', 'composer.json'],
      csharp: ['.cs', '.csproj', '.sln'],
      cpp: ['.cpp', '.hpp', '.cc', 'CMakeLists.txt']
    };
    
    // Compter les occurrences de chaque signature
    const counts = {};
    for (const [lang, signatures] of Object.entries(languageSignatures)) {
      counts[lang] = 0;
      for (const signature of signatures) {
        const regex = new RegExp(signature.replace('.', '\\.'), 'gi');
        const matches = projectContext.match(regex);
        if (matches) {
          counts[lang] += matches.length;
        }
      }
    }
    
    // Trouver le langage avec le plus d'occurrences
    let maxLang = null;
    let maxCount = 0;
    for (const [lang, count] of Object.entries(counts)) {
      if (count > maxCount) {
        maxLang = lang;
        maxCount = count;
      }
    }
    
    return maxCount > 0 ? maxLang : null;
  }
  
  /**
   * Génère un prompt système complet basé sur le type de tâche et le contexte
   * @param {string} userInput - Entrée utilisateur
   * @param {string} projectContext - Contexte du projet
   * @returns {object} - Prompt et paramètres recommandés
   */
  generateSystemPrompt(userInput, projectContext) {
    // Détecter le type de tâche
    const taskType = this.detectTaskType(userInput);
    
    // Détecter le langage principal du projet
    const primaryLanguage = this.detectPrimaryLanguage(projectContext);
    
    // Construire le prompt système complet
    let systemPrompt = this.taskPrompts[taskType];
    
    // Ajouter des conseils spécifiques au langage si détecté
    if (primaryLanguage && this.languagePrompts[primaryLanguage]) {
      systemPrompt += '\n\n' + this.languagePrompts[primaryLanguage];
    }
    
    // Ajuster la température en fonction du type de tâche
    let temperature = this.defaultTemperature;
    if (taskType === 'code_generation' || taskType === 'debugging') {
      temperature = 0.3; // Plus basse pour plus de précision
    } else if (taskType === 'explanation') {
      temperature = 0.7; // Plus haute pour plus de créativité dans les explications
    }
    
    return {
      systemPrompt,
      temperature,
      taskType,
      primaryLanguage
    };
  }
}