223 lines
14 KiB
TypeScript
223 lines
14 KiB
TypeScript
import { PrismaClient } from "@prisma/client";
|
|
|
|
const prisma = new PrismaClient();
|
|
|
|
const SUGGESTED_QUESTIONS: Record<string, string[]> = {
|
|
tools: [
|
|
"Quels outils IA utilisez-vous au quotidien ?",
|
|
"Comment les avez-vous choisis et intégrés à votre workflow ?",
|
|
"Utilisez-vous des rules, skills ou agents (Cursor, etc.) pour configurer vos outils ?",
|
|
"Partagez-vous une stack commune avec l'équipe ?",
|
|
],
|
|
prompts: [
|
|
"Comment structurez-vous vos prompts pour des tâches complexes ?",
|
|
"Utilisez-vous des templates ou des patterns réutilisables ?",
|
|
"Comment gérez-vous les cas limites et les outputs inattendus ?",
|
|
],
|
|
context: [
|
|
"Quel contexte fournissez-vous typiquement à l'IA ?",
|
|
"Comment décidez-vous ce qui est pertinent à inclure ?",
|
|
"Avez-vous des stratégies pour limiter le contexte tout en restant pertinent ?",
|
|
],
|
|
iteration: [
|
|
"Comment itérez-vous quand la première réponse ne convient pas ?",
|
|
"Décomposez-vous les tâches complexes en sous-étapes ou sous-agents ?",
|
|
"Utilisez-vous l'IA comme sparring partner pour réfléchir ?",
|
|
"Avez-vous des workflows agentiques (agents, sous-agents) ?",
|
|
],
|
|
evaluation: [
|
|
"Comment vérifiez-vous les sorties de l'IA avant de les utiliser ?",
|
|
"Avez-vous des critères explicites de qualité ?",
|
|
"Comment gérez-vous les hallucinations ou erreurs subtiles ?",
|
|
],
|
|
integration: [
|
|
"Comment l'IA est-elle discutée et partagée dans l'équipe ?",
|
|
"Y a-t-il des pratiques formalisées ou documentées ?",
|
|
"Comment les nouveaux arrivants sont-ils onboardés sur ces usages ?",
|
|
],
|
|
usecases: [
|
|
"Quels cas d'usage couvrez-vous (snippets, tests, refacto, debug...) ?",
|
|
"Quel est votre cas d'usage principal ?",
|
|
"Avez-vous exploré des usages plus avancés (discovery, review, agents, skills) ?",
|
|
],
|
|
impact: [
|
|
"Quel impact mesurable l'IA a-t-elle sur votre delivery ?",
|
|
"Comment le quantifiez-vous (temps, qualité, vélocité) ?",
|
|
"L'IA est-elle un levier stratégique pour l'équipe ?",
|
|
],
|
|
risks: [
|
|
"Quelles précautions prenez-vous (sécurité, confidentialité, biais) ?",
|
|
"Y a-t-il des règles partagées ou une doctrine ?",
|
|
"Comment gérez-vous les risques liés aux données sensibles ?",
|
|
],
|
|
alignment: [
|
|
"Comment vous assurez-vous que le code généré respecte vos standards ?",
|
|
"Avez-vous des garde-fous pour l'alignement archi ?",
|
|
"Comment gérez-vous le rework quand l'IA sort du cadre ?",
|
|
],
|
|
code_quality: [
|
|
"Quelle qualité de code attendez-vous des sorties IA ?",
|
|
"Comment validez-vous la maintenabilité ?",
|
|
"Avez-vous des exemples où le code généré était fragile ?",
|
|
],
|
|
quality_usage: [
|
|
"Utilisez-vous l'IA pour les tests ? Comment ?",
|
|
"Et pour la revue de code ou le refactoring ?",
|
|
"L'IA est-elle un levier pour améliorer la qualité globale ?",
|
|
],
|
|
capitalization: [
|
|
"Comment capitalisez-vous les prompts, rules, skills et bonnes pratiques ?",
|
|
"Y a-t-il une base partagée (rules, skills, wiki) ?",
|
|
"Comment partagez-vous les retours d'expérience ?",
|
|
],
|
|
learning: [
|
|
"Comment l'IA vous aide-t-elle à monter en compétence ?",
|
|
"Utilisez-vous l'IA pour comprendre des patterns ou concepts ?",
|
|
"Évitez-vous la dépendance passive (copier-coller sans comprendre) ?",
|
|
],
|
|
measurement: [
|
|
"Comment mesurez-vous l'usage et l'impact de l'IA ?",
|
|
"Avez-vous des indicateurs ou du feedback utilisateur ?",
|
|
"Comment pilotez-vous l'adoption et l'amélioration ?",
|
|
],
|
|
};
|
|
|
|
const RUBRICS: Record<string, string> = {
|
|
tools: "1:Usage ponctuel — utilisation occasionnelle, sans réelle stratégie ni critères de choix;2:Outil identifié — un outil principal utilisé, choix fait de manière informelle;3:Usage raisonné — comparaison de plusieurs outils, critères explicites (coût, latence, qualité);4:Stack partagée — stack commune à l'équipe, documentée et maintenue;5:Intégré au workflow — adoption généralisée",
|
|
prompts: "1:Vague — prompts improvisés, peu de structure, résultats aléatoires;2:Simple — prompts basiques avec instructions claires mais sans systématisation;3:Structuré — format cohérent (rôle, contexte, tâche, format attendu), testés manuellement;4:Templates — bibliothèque de prompts réutilisables, versionnés;5:Prompt engineering maîtrisé — techniques avancées (chain-of-thought, few-shot), optimisation continue, validation des outputs",
|
|
context: "1:Peu — contexte minimal fourni, l'IA manque d'informations pour bien répondre;2:Partiel — contexte partiel, parfois pertinent, parfois manquant;3:Suffisant — contexte adapté à la tâche, couvre les éléments essentiels;4:Structuré — contexte organisé (sections, priorités), stratégie de sélection;5:Contextualisation avancée — RAG, embedding, contexte dynamique selon la requête",
|
|
iteration: "1:One-shot — une seule tentative, pas de retry si le résultat est insuffisant;2:Quelques itérations — 2-3 essais manuels si la première réponse échoue;3:Itératif — approche systématique: retry, reformulation, décomposition en sous-tâches;4:Décomposition — tâches complexes découpées en étapes, prompts en chaîne;5:IA sparring partner — dialogue continu avec l'IA pour explorer, affiner, challenger les réponses",
|
|
evaluation: "1:Acceptation — acceptation des sorties sans vérification significative;2:Relecture superficielle — lecture rapide, pas de critères explicites;3:Vérif fonctionnelle — tests manuels ou automatisés, vérification du comportement;4:Regard archi — évaluation de la maintenabilité, alignement, cohérence;5:Culture critique — critères de qualité partagés, revue systématique, détection des hallucinations",
|
|
integration: "1:Isolé — usage personnel, pas de partage ou discussion en équipe;2:Discussions — échanges informels sur les usages, pas de formalisation;3:Partages — démos, retours d'expérience, bonnes pratiques partagées;4:Formalisé — pratiques documentées, onboarding, standards d'usage;5:Doctrine équipe — vision partagée, roadmap IA, adoption comme pilier de la stratégie",
|
|
usecases: "1:Snippets — usage limité à la génération de petits snippets ou complétion;2:Code basique — génération de fonctions, classes, scripts simples;3:Tests/refacto — génération de tests, refactoring, documentation;4:Debug/opt — aide au debug, optimisation, analyse de code;5:Discovery→review — exploration de solutions, design, revue de code, boucle complète",
|
|
impact: "1:Aucun — pas d'impact visible sur la delivery;2:Marginal — gain de temps perçu mais non quantifié;3:Accélération — vélocité accrue, moins de tâches répétitives;4:Gain mesurable — métriques (temps, qualité, vélocité) documentées;5:Levier clair — IA comme levier stratégique, pilotage de l'adoption, ROI démontré",
|
|
risks: "1:Aucune — pas de considération des risques (sécurité, confidentialité, biais);2:Sensibilisation — conscience des risques, pas de processus formalisé;3:Bonnes pratiques — précautions appliquées (données, prompts, sanitization);4:Règles partagées — règles d'usage, checklist, validation des données;5:Doctrine — politique de sécurité IA, gouvernance, revue des risques",
|
|
alignment: "1:Hors standards — code généré souvent non conforme, rework systématique;2:Rework lourd — modifications importantes nécessaires pour aligner;3:Cohérent — code généralement aligné, quelques ajustements;4:Aligné — prompts et garde-fous pour respecter standards et archi;5:Quasi conforme — sorties quasi conformes, validation automatisée possible",
|
|
code_quality: "1:Peu maintenable — code fragile, difficile à faire évoluer;2:Correct fragile — fonctionne mais cas limites non gérés;3:Maintenable — code propre, testable, évolutif;4:Propre structuré — patterns respectés, séparation des responsabilités;5:Quasi senior — qualité équivalente à un code produit par un dev senior",
|
|
quality_usage: "1:Rarement — utilisation peu fréquente pour la qualité;2:Tests simples — génération de tests unitaires basiques;3:Tests utiles — tests pertinents, couverture, refacto assistée;4:Refacto guidée — IA pour identifier du code à améliorer, suggérer des refactorings;5:Levier qualité — IA intégrée dans la boucle qualité (review, dette technique, standards)",
|
|
capitalization: "1:None — pas de capitalisation, tout est dans la tête ou éparpillé;2:Informel — notes personnelles, partage oral;3:Bonnes pratiques — document informal, exemples partagés;4:Base prompts — bibliothèque de prompts, wiki interne;5:Wiki & REX — base documentée, retours d'expérience, amélioration continue",
|
|
learning: "1:Dépendance — copier-coller sans comprendre, risque de régression;2:Apprentissage limité — utilisation pour débloquer mais compréhension superficielle;3:Compréhension — IA pour comprendre les concepts, valider sa compréhension;4:IA pour patterns — utilisation pour apprendre des patterns, architectures, bonnes pratiques;5:Accélérateur de progression — IA comme outil de montée en compétence structurée",
|
|
measurement: "1:Aucun suivi — pas de mesure de l'usage ou de l'impact;2:Perception — sentiment d'impact, pas de données;3:Feedback — retours utilisateurs, observations qualitatives;4:Indicateurs simples — métriques d'usage (adoption, volume), premiers KPIs;5:Pilotage structuré — tableau de bord, suivi de l'adoption, pilotage de l'amélioration",
|
|
};
|
|
|
|
const TEMPLATES_DATA = [
|
|
{
|
|
id: "full-15",
|
|
name: "Full - 15 dimensions",
|
|
dimensions: [
|
|
{ id: "tools", title: "Choix & maîtrise des outils", rubric: RUBRICS.tools },
|
|
{ id: "prompts", title: "Clarté des prompts", rubric: RUBRICS.prompts },
|
|
{ id: "context", title: "Pertinence du contexte fourni", rubric: RUBRICS.context },
|
|
{ id: "iteration", title: "Capacité d'itération", rubric: RUBRICS.iteration },
|
|
{ id: "evaluation", title: "Évaluation critique", rubric: RUBRICS.evaluation },
|
|
{ id: "integration", title: "Intégration dans les pratiques d'équipe", rubric: RUBRICS.integration },
|
|
{ id: "usecases", title: "Cas d'usage couverts", rubric: RUBRICS.usecases },
|
|
{ id: "impact", title: "Impact sur la delivery", rubric: RUBRICS.impact },
|
|
{ id: "risks", title: "Gestion risques & sécurité", rubric: RUBRICS.risks },
|
|
{ id: "alignment", title: "Alignement archi & standards", rubric: RUBRICS.alignment },
|
|
{ id: "code_quality", title: "Qualité du code généré", rubric: RUBRICS.code_quality },
|
|
{ id: "quality_usage", title: "Usage pour la qualité (tests, review)", rubric: RUBRICS.quality_usage },
|
|
{ id: "capitalization", title: "Capitalisation & partage", rubric: RUBRICS.capitalization },
|
|
{ id: "learning", title: "Montée en compétence via IA", rubric: RUBRICS.learning },
|
|
{ id: "measurement", title: "Mesure & pilotage", rubric: RUBRICS.measurement },
|
|
],
|
|
},
|
|
];
|
|
|
|
async function main() {
|
|
// Sync templates & dimensions only — ne touche pas aux évaluations, users, audit logs
|
|
for (const t of TEMPLATES_DATA) {
|
|
const template = await prisma.template.upsert({
|
|
where: { id: t.id },
|
|
create: { id: t.id, name: t.name },
|
|
update: { name: t.name },
|
|
});
|
|
for (let i = 0; i < t.dimensions.length; i++) {
|
|
const d = t.dimensions[i];
|
|
const questions = SUGGESTED_QUESTIONS[d.id];
|
|
await prisma.templateDimension.upsert({
|
|
where: {
|
|
templateId_slug: { templateId: template.id, slug: d.id },
|
|
},
|
|
create: {
|
|
templateId: template.id,
|
|
slug: d.id,
|
|
orderIndex: i,
|
|
title: d.title,
|
|
rubric: d.rubric,
|
|
suggestedQuestions: questions ? JSON.stringify(questions) : null,
|
|
},
|
|
update: {
|
|
orderIndex: i,
|
|
title: d.title,
|
|
rubric: d.rubric,
|
|
suggestedQuestions: questions ? JSON.stringify(questions) : null,
|
|
},
|
|
});
|
|
}
|
|
}
|
|
|
|
// Bootstrap demo data uniquement si la DB est vide
|
|
const evalCount = await prisma.evaluation.count();
|
|
if (evalCount === 0) {
|
|
const template = await prisma.template.findUnique({ where: { id: "full-15" } });
|
|
if (!template) throw new Error("Template not found");
|
|
|
|
await prisma.user.upsert({
|
|
where: { email: "admin@cars-front.local" },
|
|
create: { email: "admin@cars-front.local", name: "Admin User", role: "admin" },
|
|
update: {},
|
|
});
|
|
|
|
const dims = await prisma.templateDimension.findMany({
|
|
where: { templateId: template.id },
|
|
orderBy: { orderIndex: "asc" },
|
|
});
|
|
|
|
const candidates = [
|
|
{ name: "Alice Chen", role: "Senior ML Engineer", evaluator: "Jean Dupont" },
|
|
{ name: "Bob Martin", role: "Data Scientist", evaluator: "Marie Curie" },
|
|
{ name: "Carol White", role: "AI Product Manager", evaluator: "Jean Dupont" },
|
|
];
|
|
|
|
for (let i = 0; i < candidates.length; i++) {
|
|
const c = candidates[i];
|
|
const evaluation = await prisma.evaluation.create({
|
|
data: {
|
|
candidateName: c.name,
|
|
candidateRole: c.role,
|
|
evaluatorName: c.evaluator,
|
|
evaluationDate: new Date(2025, 1, 15 + i),
|
|
templateId: template.id,
|
|
status: i === 0 ? "submitted" : "draft",
|
|
findings: i === 0 ? "Bonne maîtrise des outils et des prompts. Axes d'amélioration : capitalisation et mesure." : null,
|
|
recommendations: i === 0 ? "Former sur la capitalisation des prompts et mettre en place des indicateurs." : null,
|
|
},
|
|
});
|
|
for (const d of dims) {
|
|
const score = 2 + Math.floor(Math.random() * 3);
|
|
await prisma.dimensionScore.create({
|
|
data: {
|
|
evaluationId: evaluation.id,
|
|
dimensionId: d.id,
|
|
score,
|
|
justification: `Justification pour ${d.title}`,
|
|
examplesObserved: `Observé : ${d.title} niveau ${score}`,
|
|
confidence: ["low", "med", "high"][Math.floor(Math.random() * 3)],
|
|
},
|
|
});
|
|
}
|
|
}
|
|
console.log("Seed complete: templates synced, demo evaluations created");
|
|
} else {
|
|
console.log("Seed complete: templates synced, evaluations preserved");
|
|
}
|
|
}
|
|
|
|
main()
|
|
.catch((e) => {
|
|
console.error(e);
|
|
process.exit(1);
|
|
})
|
|
.finally(() => prisma.$disconnect());
|