src/config/tasks.yaml

# === CV splitter ===

split_cv_task:
  description: >
    Découpe le CV en sections JSON. Copie le texte brut sans reformuler ni résumer.

    RÈGLES STRICTES :
    1. "header" : Les premières lignes du CV — contient le NOM du candidat, son TITRE/POSTE, ses coordonnées (email, téléphone, LinkedIn, ville). Cherche en priorité dans le TEXTE BRUT PREMIÈRE PAGE car le Markdown peut mal ordonner le header.
    2. "experiences" : Uniquement l'historique professionnel (Entreprise, Poste, Dates, missions).
    3. "projects" : Sections explicitement titrées "Projets". Laisser VIDE si absent, ne pas inventer.
    4. "skills" : Listes de compétences, langages, outils.
    5. "education" : Diplômes et formations.
    6. "languages" : Langues mentionnées avec leur niveau (Français, Anglais, etc.).

    TEXTE PRINCIPAL DU CV (Markdown) :
    "{cv_content}"

    TEXTE BRUT PREMIÈRE PAGE (extraction directe, utilise-le si le texte principal manque le header) :
    "{cv_raw_start}"
  expected_output: >
    Un objet JSON valide strictement structuré ainsi :
    {{
      "header": "texte brut du header (nom, titre, contact)...",
      "experiences": "texte brut...",
      "projects": "texte brut...",
      "education": "texte brut...",
      "skills": "texte brut...",
      "languages": "texte brut..."
    }}

# === Tache d'extractions des informations === 

skills_task:
  description: >
    RÈGLES DE CLASSIFICATION :
    1. 'hard_skills' : Outils, langages, technos (ex: Python, SQL, Excel, React, FastAPI, LangChain).
       IMPORTANT: Inclure TOUTES les technologies mentionnées dans les projets, expériences et académique.
    2. 'soft_skills' : Qualités humaines (ex: Leadership, Communication, Rigueur).
    3. NE PAS INVENTER. Si ce n'est pas écrit, ne l'ajoute pas.
    4. EXHAUSTIVITÉ ABSOLUE : Traque RIGOUREUSEMENT chaque logiciel, langage, bibliothèque ou concept technique (ex: BeautifulSoup4, Scraping, Pandas, etc.). Ne laisse RIEN passer.
    5. 'skills_with_context' : Tu DOIS obligatoirement analyser la LISTE COMPLÈTE des 'hard_skills' extraites.
       RÈGLE ABSOLUE : Pour CHAQUE compétence, tu dois EFFECTUER UNE RECHERCHE TEXTUELLE RIGOUREUSE (comme un CTRL+F) dans le texte brut des Expériences, des Projets et de l'Éducation.
       De nombreuses compétences présentes dans les 'Expériences' sont souvent manquées. Prends le temps de lire chaque phrase des expériences !
       Si la compétence est trouvée, précise son contexte (ex: "expérience", "projet", "académique", "expérience, projet").
       Si et SEULEMENT SI tu as lu attentivement tous les autres textes et qu'elle n'est VRAIMENT mentionnée nulle part ailleurs que dans la section Compétences, alors attribue-lui le contexte "sans contexte". Ne mets JAMAIS "sans contexte" par erreur si la compétence se trouve dans l'expérience.
    Analyse les sections suivantes pour lister les compétences avec leur contexte d'utilisation :
    Expériences : {experiences}
    Projets : {projects}
    Education : {education}
    Skills Explicites : {skills}
  expected_output: >
    JSON : {{
      "hard_skills": ["Python", "SQL", "FastAPI"],
      "soft_skills": ["Rigueur", "Leadership"],
      "skills_with_context": [
        {{"skill": "Python", "context": "projet"}},
        {{"skill": "FastAPI", "context": "entreprise"}}
      ]
    }}

experience_task:
  description: >
    Tu es un extracteur de données strict.
    
    Pour CHAQUE poste identifié :
    1. Titre du poste
    2. Nom de l'entreprise
    3. Dates (Début - Fin)
    4. Description (Liste des tâches/responsabilités)
    
    RÈGLE : Ne confonds PAS les projets scolaires avec des expériences pro. Les stages et alternances SONT des expériences.

    Analyse ce texte d'expérience :
    "{experiences}"
  expected_output: >
    Liste JSON : [{{"Poste": "...", "Entreprise": "...", "start_date": "...", "end_date": "...", "responsabilités": ["task 1", "task 2"]}}]

project_task:
  description: >
    RÈGLES STRICTES DE STRUCTURE :
    Chaque projet DOIT avoir exactement ces clés :
    - "title" : Titre du projet
    - "technologies" : Liste de strings (Ex: ["Python", "React"])
    - "outcomes" : Liste de strings décrivant les résultats ou fonctionnalités (Ex: ["Appli déployée", "User base x2"])
    - "domaine metier" : (exemple un projet en lien avec la recommandation d'emploi est classé comme recrutement/RH)
    
    Sépare :
    - "professional" : Projets réalisés en entreprise (distincts du simple poste).
    - "personal" : Projets perso, Github, Hackathons, Écoles.
    
    Si une liste est vide, renvoie [].

    Analyse ce texte de projets : "{projects}"
    
    Si une liste est vide, renvoie [].
  expected_output: >
    JSON : {{
      "professional": [
        {{ "title": "Data Jobs", "technologies": ["Python", "API"], "outcomes": ["App crée", "Optimisation X"], "domaine metier": "recrutement/RH" }}
      ], 
      "personal": []
    }}

education_task:
  description: >
    Analyse la section education : "{education}"
    Extrait les diplômes.
  expected_output: >
    Liste JSON : [{{"degree": "...", "institution": "...", "start_date": "...", "end_date": "..."}}]

reconversion_task:
  description: >
    Le candidat est-il en reconversion ? (Changement majeur de domaine récent).
    Indique aussi le contexte (de quel domaine ou poste vient-il et quelle est sa réorientation).
    RÈGLE ABSOLUE : Tu DOIS extraire la DATE de début de cette reconversion.
    Cette date correspond au mois et à l'année de début de la formation de reconversion OU du premier emploi dans le nouveau domaine.
    Pour le contexte de reconversion et la date, base-toi sur les expériences et l'éducation.

    Analyse les expériences : "{experiences}"
    Et l'éducation : "{education}"
  expected_output: >
    JSON : {{"reconversion_analysis": {{"is_reconversion": true/false, "context": "...", "date_reconversion": "YYYY-MM ou null"}}}}

etudiant_task:
  description: >
    Le candidat est-il ACTUELLEMENT étudiant ? 
    CRITÈRES :
    1. Regarde les dates de fin des formations.
    2. Identifie la date de fin de la formation la plus récente.
    3. Si cette date est FUTURE par rapport à la date actuelle ou si c'est écrit "En cours" / "Présent", alors is_etudiant = true.
    4. Récupère explicitement cette date sous le champ 'latest_education_end_date' (format YYYY-MM-DD ou MM/YYYY ou "Present").
    5. indique aussi le niveau d'études (ex: bac+2, bac+5) du diplome le plus proche de la date actuelle.
    6. indique la spécialité exemple: ingenieur IA, data analyste, devellopeur frontend, etc.

    Nous sommes le {current_date}.
    Analyse la section education : "{education}"
  expected_output: >
    JSON : {{"etudiant_analysis": {{"is_etudiant": true/false, "niveau_etudes": "bac+5", "specialite": "data analyste", "latest_education_end_date": "YYYY-MM-DD"}}}}

language_task:
  description: >
    Identifie toutes les langues parlées par le candidat.

    RÈGLES :
    1. Extrais toutes les langues et niveaux présents dans la SECTION LANGUES.
    2. Détecte la langue dans laquelle le CV est rédigé à partir du DÉBUT DU CV.
    3. Si la langue du CV n'est PAS dans la SECTION LANGUES, ajoute-la avec le niveau "Natif" ou "Langue maternelle".
    4. Ne jamais omettre la langue du CV.

    SECTION LANGUES (extraite) : "{languages}"

    DÉBUT DU CV (pour détecter la langue de rédaction) : "{cv_raw_start}"
  expected_output: >
    JSON : {{"langues": [{{"langue": "Français", "niveau": "Natif"}}, {{"langue": "Anglais", "niveau": "B2"}}]}}

identity_task:
  description: >
    Extrais le prénom du candidat.

    RÈGLES :
    1. Cherche le prénom dans le HEADER, puis dans le TEXTE BRUT DÉBUT DU CV.
    2. Le NOM DU FICHIER est un indice fort : "ANISSA_KACEM_..." → prénom = "Anissa".
    3. Ne jamais inventer. Formate avec majuscule initiale.
    4. Si impossible à trouver, retourne null.

    HEADER DU CV (nom, titre, contact) : "{header}"

    TEXTE BRUT DÉBUT DU CV : "{cv_raw_start}"

    NOM DU FICHIER (indice très fiable, souvent au format NOM_PRENOM_...) : "{file_name}"
  expected_output: >
    JSON : {{"first_name": "..."}}

poste_visé_task:
  description: >
    Extrais le titre de poste visé tel qu'il est écrit dans l'en-tête du CV.

    RÈGLES :
    1. Le titre de poste se trouve juste après le nom du candidat (ex: "Business Analyst", "Data Engineer").
    2. Copie le titre EXACTEMENT tel qu'il est écrit, sans reformuler.
    3. Si le header est vide, cherche dans le TEXTE BRUT DÉBUT DU CV.
    4. Ne jamais inventer un titre.

    HEADER DU CV (extrait par le splitter) : "{header}"

    TEXTE BRUT DÉBUT DU CV (fallback si header vide) : "{cv_raw_start}"
  expected_output: >
    JSON : {{
      "poste_vise": "Le titre EXACT tel qu'écrit sur le CV",
      "confiance": 90
    }}

# === partie matching ===

metier_matching_task:
  description: >
    Compare le profil du candidat avec le référentiel de métiers pour recommander les 3 postes les plus adaptés.

    RÈGLES D'ANALYSE :
    IMPORTANT : Tu dois évaluer CHAQUE métier présent dans le RÉFÉRENTIEL DE MÉTIERS,
    sans en omettre aucun. Le top 3 final doit être basé sur l'évaluation exhaustive de tous
    les métiers listés. Ne jamais présélectionner ou ignorer des métiers a priori.

    1. Pour CHAQUE métier du référentiel, calcule un score de matching (0-100) basé sur :
       - Couverture des compétences techniques requises (40%)
       - Couverture des outils/technologies (30%)
       - Adéquation des expériences et projets (20%)
       - Cohérence avec le niveau d'études et l'expérience requise (10%)
    2. Utilise le mapping de domaines pour comprendre les liens implicites (ex: Metabase → BI,
       LangChain → LLM Engineering, Power BI → BI Analyst, Scikit-learn → Data Science).
    3. Pour les profils en reconversion, valorise les compétences transférables
       (gestion d'équipe → leadership, optimisation de production → optimisation de processus data,
       communication internationale → travail en équipe multiculturelle).
    4. Recommande les 3 métiers avec le MEILLEUR score parmi l'ensemble du référentiel évalué.
    5. PONDÉRATION TEMPORELLE (CRITIQUE) : Accorde un poids double (x2) aux technologies et compétences issues des expériences et projets les plus récents, ainsi qu'à la formation en cours. Le profil actuel d'un candidat est défini par ce qu'il fait aujourd'hui, pas par son historique lointain.
    6. Pour chaque métier recommandé, liste les compétences matchées et manquantes.
    7. Si le poste visé par le candidat ne fait pas partie du top 3, explique pourquoi.
    8. Fournis une analyse détaillée de l'adéquation du poste visé avec le profil.

    RÉFÉRENTIEL DE MÉTIERS :
    {metiers_reference}

    EN-TÊTE DU CV (pour le poste visé) : "{header}"

    SECTION COMPÉTENCES :
    {skills}

    SECTION EXPÉRIENCES :
    {experiences}

    SECTION PROJETS :
    {projects}

    SECTION FORMATION (utile pour détecter les reconversions):
    {education}
  expected_output: >
    JSON : {{
      "postes_recommandes": [
        {{
          "metier_id": "data_analyst",
          "nom": "Data Analyst",
          "categorie": "Noyau data & analytique",
          "score_matching": 85,
          "detail_scores": {{
            "competences_techniques": 80,
            "outils_technologies": 90,
            "experiences_projets": 85,
            "methodologies": 75
          }},
          "competences_matchees": ["SQL", "Python", "Power BI"],
          "competences_manquantes": ["Looker", "dbt"],
          "justification": "Le profil couvre 85% des compétences requises..."
        }}
      ],
      "poste_vise_dans_top3": true,
      "analyse_poste_vise": "Analyse détaillée de l'adéquation..."
    }}

cv_quality_task:
  description: >
    Évalue la qualité globale du CV en appliquant les critères de bonnes pratiques CV tech 2025,
    adaptés au niveau de séniorité du candidat.

    CRITÈRES D'ÉVALUATION (score sur 100 pour chaque) :

    1. COMPATIBILITÉ ATS (100 points) :
       - ÉVALUATION STRICTE ET CRITIQUE : Ne donne jamais un score parfait sans preuve.
       - Les noms des sections principales sont-ils standards (Expériences, Formations, Projets, Compétences) ou atypiques ? Si atypiques, pénalise. (RÈGLE ABSOLUE : N'évalue PAS et ne pénalise JAMAIS les sections d'introduction courtes comme "Profil", "À propos", "Résumé" ou "Profil atypique". Ignore-les totalement pour ce critère).
       - Les mots-clés techniques sont-ils contextuels ou simplement entassés de manière artificielle ?
       - Indique EXPLICITEMENT ce qui ne va pas (ex: "Nom de section 'Mon Parcours' au lieu de 'Expériences'", "Mots-clés empilés sans lien avec les expériences").
       - Fournis des points d'amélioration spécifiques et factuels.

    2. QUANTIFICATION DES RÉSULTATS (100 points) :
       - Les expériences mentionnent-elles des MÉTRIQUES TECHNIQUES SPÉCIFIQUES ?
         Cherche : réduction de latence (ms), amélioration du temps de chargement (%),
         optimisation de requêtes SQL (x fois plus rapide), volume d'utilisateurs supporté,
         réduction du temps de déploiement CI/CD, couverture de tests (%),
         réduction des coûts d'infrastructure, nombre de pipelines automatisés,
         volume de données traité, temps de réponse des APIs.
       - Donne des suggestions SPÉCIFIQUES de métriques que le candidat pourrait ajouter
         en fonction de ses expériences et projets RÉELS (pas des conseils génériques).

    3. STRUCTURE ET LISIBILITÉ (100 points) :
       - ANALYSE CRITIQUE BASÉE SUR LE TEXTE : Ne suppose pas que le CV est beau. Évalue la structure à partir du texte extrait.
       - RÈGLE ABSOLUE SUR LA FORME : N'évalue JAMAIS la présence ou l'absence de listes à puces/tirets. Le parsing supprime souvent la mise en forme, ne fais donc aucune remarque sur des "blocs de texte illisibles".
       - L'ordre chronologique inverse est-il respecté dans les expériences et formations ? Si non, pénalise sévèrement.
       - RÈGLE LONGUEUR : Utilise la donnée `NOMBRE DE PAGES`. Un profil < 7 ans d'expérience devrait tenir sur 1 page. Pénalise si > 2 pages.
       - RÈGLE POSTE VISÉ (CRITIQUE) : Si `POSTE VISÉ` est "Non identifié", c'est une ERREUR MAJEURE. Baisse drastiquement la note de structure et signale-le comme un RED FLAG (le recruteur doit identifier le but du CV en 3 secondes).
       - STRUCTURATION DES COMPÉTENCES : Les compétences sont-elles regroupées par catégories logiques (Langages, Frameworks, BDD, DevOps/Cloud) ou en liste plate ? Une structuration par catégories est fortement recommandée pour les filtres ATS.
       - Fournis des conseils d'amélioration FACTUELS sur la structure.

    4. PRÉSENTATION DES PROJETS (100 points) :
       - Chaque projet a-t-il un titre, des technos, et des résultats ?
       - Les projets sont-ils pertinents pour le poste visé ?
       - Y a-t-il une variété de projets (pro + perso) ?

    5. PREUVES DE COMPÉTENCES (100 points) :
       - RÈGLE CRITIQUE : Une compétence est considérée "sans preuve" UNIQUEMENT si elle
         apparaît EXCLUSIVEMENT dans la section Compétences sans aucune mention dans
         les expériences OU les projets. Tu dois vérifier par toi-même (par analyse textuelle)
         si les compétences listées apparaissent ailleurs. Ne signale que les skills qui n'ont "aucun contexte".
       - DÉTECTION DES LIENS : Cherche les URLs dans le CV Markdown ET dans le texte brut.
         Les liens peuvent apparaître sous forme de Markdown [texte](url), de texte brut
         (github.com/..., linkedin.com/...) ou dans le header. Signale les liens PRÉSENTS,
         ne jamais conclure à l'absence de liens sans avoir vérifié les deux sources de texte.
       - Pour les RECONVERSIONS : les compétences transférables (management, optimisation,
         communication, gestion budgétaire) sont-elles mises en valeur et reliées au nouveau domaine ?

    ADAPTATION AU NIVEAU DE SÉNIORITÉ :
    - Si JUNIOR : valorise les projets personnels, formations, stages bien décrits.
    - Si CONFIRMÉ : exige des résultats mesurables, progression, responsabilités.
    - Si SENIOR/STAFF : vérifie la présence de choix architecturaux et compromis
      (systèmes distribués, microservices), leadership technique (mentoring, revues de code),
      gestion de la scalabilité, impact organisationnel au-delà du code.

    SCORE GLOBAL :
    - il faut appliquer une moyenne des scores des 5 critères.

    RED FLAGS À DÉTECTER :
    - DÉTECTION STRICTE DES COMPÉTENCES SANS PREUVE : Tu DOIS t'appuyer uniquement sur ton évaluation de "preuves_competences". S'il y a des compétences listées dans "skills_sans_preuve", ajoute un red flag. Sinon, n'ajoute pas de red flag pour ce sujet.
    - Trous inexpliqués dans le parcours
    - Jargon excessif ou buzzwords sans substance
    - Incohérence entre compétences listées et projets/expériences
    - Section compétences en liste plate non catégorisée

    DONNÉES À ÉVALUER :
    EN-TÊTE DU CV (pour le poste visé et niveau de séniorité) : "{header}"
    NOMBRE DE PAGES : {page_count}
    CV COMPLET (texte Markdown) : "{cv_full_text}"
    TEXTE BRUT DU CV (première page, pour détecter les URLs et liens) : "{cv_raw_start}"
    SECTION COMPÉTENCES : "{skills}"
    SECTION EXPÉRIENCES : "{experiences}"
    SECTION PROJETS : "{projects}"
    SECTION FORMATIONS : "{education}"
  expected_output: >
    JSON : {{
      "score_global": 72,
      "compatibilite_ats": {{ "score": 80, "details": "..." }},
      "quantification_resultats": {{ "score": 50, "details": "...", "metriques_suggerees": ["Préciser le temps de réponse des dashboards PowerBI", "Quantifier le volume de données traité par les flows Dataiku"] }},
      "structure_lisibilite": {{ "score": 85, "details": "...", "structuration_competences": "Compétences bien catégorisées par domaine" }},
      "presentation_projets": {{ "score": 70, "details": "..." }},
      "preuves_competences": {{ "score": 65, "details": "...", "skills_sans_preuve": ["skill_hors_contexte_uniquement"], "liens_detectes": ["github.com/user", "linkedin.com/in/user"] }},
      "red_flags": ["..."],
      "points_forts": ["..."],
      "conseils_prioritaires": ["Conseil spécifique et actionnable 1", "Conseil spécifique 2"],
      "adaptation_seniorite": "Analyse adaptée au profil confirmé..."
    }}

project_analysis_task:
  description: >
    Évalue CHAQUE projet du CV et détermine la qualité technique et l'impact.

    RÈGLES D'OR :
    1. Neutralité : Un projet d'IA n'est pas intrinsèquement "meilleur" qu'un projet Web ou Data. Seule la profondeur technique compte.
    2. Alignement : Évalue la pertinence uniquement par rapport au titre de poste extrait dans {header}.

    Pour CHAQUE projet, tu dois scorer sur 10 avec une justification courte et factuelle (preuve tirée du CV) sur les 7 critères suivants :
    1. Pertinence & Alignement : Correspondance avec le poste visé {header} Questionner la nécessité de la complexité : la solution est-elle sur-dimensionnée ou adaptée au besoin ?
    2. Complexité Technique & Architecture : Évalue la profondeur de l'ingénierie. Un projet utilisant des services "clés en main" (Low-code/No-code/API simples) doit être scoré plus bas qu'une architecture personnalisée gérant des contraintes techniques réelles (concurrence, flux de données, optimisation).
    3. Stack & Maîtrise : Modernité, cohérence, diversité raisonnable vs "tech soup".
    4. Innovation & Originalité : Valeur ajoutée réelle vs "j'ai collé des libs à la mode" (Ex : scoring multi-dimensionnel + détection fraude = fort ; simple wrapper RAG = faible), Le projet résout-il un problème de manière originale ? Différencie les tutoriels classiques des solutions métiers.
    5. Impact & Résultats Mesurables : Chiffres concrets (+40 %, 2000 offres, 30 % moins d'étapes...) et crédibilité de la mesure.
    6. Ownership & Exécution : End-to-end (idea → business plan → dev → déploiement → monitoring). Méthodologies affichées (Design Thinking, Scrum...).
    7. Maturité Production & Qualité : Monitoring, coût/latence, tests, sécurité, RGPD, scaling, users réels vs démo/prototype.

    Méthode pour un avis CLAIR et CRITIQUE :
    - Être factuel d'abord (preuve du CV).
    - Donner du positif spécifique.
    - Donner de la critique constructive et honnête (jamais méchant, toujours utile).
    - Éviter le fanboying et le "tout est génial".
    - Termine par un verdict tranché sur la valeur du projet pour un recruteur.
    - Identifie l'over-claiming (promesses non prouvées).

    DONNÉES DU CANDIDAT :
    EN-TÊTE DU CV (pour déduire le poste visé) : "{header}"
    PROJETS MENTIONNÉS (texte brut) : {projects}

    TON : Professionnel, froid, analytique
  expected_output: >
    JSON : {{
      "analyse_projets": [
        {{
          "titre": "Nom exact du projet",
          "resume": "Description ultra-concise + type (Side Project / SaaS / MVP)",
          "evaluation": {{
            "pertinence": {{"score": 8, "justification": "..."}},
            "complexite": {{"score": 7, "justification": "..."}},
            "stack": {{"score": 9, "justification": "..."}},
            "innovation": {{"score": 6, "justification": "..."}},
            "impact": {{"score": 5, "justification": "Aucun chiffre concret"}},
            "ownership": {{"score": 8, "justification": "..."}},
            "maturite": {{"score": 4, "justification": "Pas de mention de monitoring ou de tests"}}
          }},
          "points_forts": ["...", "..."],
          "points_vigilance": ["Risque d'over-claim sur...", "Manque de visibilité sur tests"],
          "note_globale": 67,
          "verdict_recruteur": "Très bon projet qui démontre une vraie maîtrise agentique... Idéal pour un rôle IA intermédiaire, à creuser en entretien."
        }}
      ]
    }}