@mindflight/mindbrain-personal-studio 0.6.1 → 0.6.2

package/scripts/build-serenity-v6-concept-review-pack.mjs

@@ -1,493 +0,0 @@
-#!/usr/bin/env node
-
-import fs from "node:fs";
-import path from "node:path";
-
-const ROOT = process.cwd();
-const DAY_DIR = path.join(ROOT, "docs/demo/export-audit/2026-06-26");
-const MIGRATION_DIR = path.join(DAY_DIR, "serenity-production-v6-migration");
-const TECHNICAL_REVIEW_DIR = path.join(DAY_DIR, "serenity-production-v6-review-pack");
-const OUT_DIR = path.join(DAY_DIR, "serenity-production-v6-concept-review");
-
-const readJson = (file) => JSON.parse(fs.readFileSync(file, "utf8"));
-const write = (name, content) => {
-  fs.writeFileSync(path.join(OUT_DIR, name), `${content.trim()}\n`);
-};
-
-const schemas = readJson(path.join(TECHNICAL_REVIEW_DIR, "schema_decision_pack.json"));
-const relations = readJson(path.join(TECHNICAL_REVIEW_DIR, "relation_decision_pack.json"));
-const rejected = readJson(path.join(TECHNICAL_REVIEW_DIR, "rejected_relation_audit.json"));
-const scenarios = readJson(path.join(MIGRATION_DIR, "scenario_sop_map.json"));
-
-fs.mkdirSync(OUT_DIR, { recursive: true });
-
-const relationGloss = {
-  activer: "declenche ou rend applicable un objet metier",
-  assigner_gestion: "attribue la gestion operationnelle a une equipe ou un gestionnaire",
-  composer: "compose un ensemble a partir d'elements metier",
-  contenir: "exprime une inclusion structurelle stable",
-  declencher: "cree un evenement ou une mission a partir d'un fait initial",
-  donne_lieu_a: "cree une suite operationnelle ou administrative",
-  est_actee_par: "formalise une decision ou une action par une piece",
-  est_calcule_a_partir_de: "garde la lignee de calcul entre pieces comptables",
-  est_composee_d: "detaille les sous-parties d'un objet de suivi",
-  est_emise_par: "identifie l'emetteur d'une piece",
-  evalue: "relie une expertise ou verification a l'objet evalue",
-  fonde_une: "sert de base a une decision, action ou demande",
-  peut_generer: "peut creer un objet aval selon les conditions SOP",
-  peut_preceder: "modele l'ordre possible des etapes",
-  porte_sur: "indique l'objet metier concerne",
-  produit_des: "produit des livrables ou effets attendus",
-  rattacher: "rattache un objet a son contexte metier principal",
-  referencer: "relation generique de reference; trop large sans decomposition",
-  resulte_de: "indique la cause ou l'origine metier",
-  supporter: "relation generique de support/preuve; trop large sans decomposition",
-};
-
-const domainGloss = {
-  accounting_closeout: "Cloture comptable et appels de fonds",
-  administrative: "Administration et mutations",
-  ag_decision_cycle: "Assemblee generale et decisions",
-  comptabilite: "Comptabilite",
-  decisionnel: "Assemblee generale et decisions",
-  finance: "Finance et tresorerie",
-  missions: "Missions, incidents et sinistres",
-  production: "Vue copropriete 360 et production",
-  technique: "Travaux, equipements et interventions",
-  meta: "Gouvernance du modele",
-  mapping_profile_governance: "Gouvernance du mapping",
-  mappingprofile: "Gouvernance du mapping",
-};
-
-const scenarioQuestion = {
-  accounting_closeout:
-    "Veut-on tracer la lignee comptable complete, ou seulement produire des controles et ecarts calcules ?",
-  administrative:
-    "Veut-on modeler les mutations comme un workflow metier, ou seulement comme des dossiers et documents historises ?",
-  ag_decision_cycle:
-    "Les decisions d'AG doivent-elles generer des objets aval typés comme travaux, appels de fonds ou mandats ?",
-  comptabilite:
-    "Quels controles comptables sont des objets SOP persistants, et lesquels sont seulement des resultats de verification ?",
-  decisionnel:
-    "Les decisions d'AG doivent-elles generer des objets aval types comme travaux, appels de fonds ou mandats ?",
-  finance:
-    "Quels mouvements financiers doivent etre relies a leur origine metier, et lesquels restent des lignes comptables ?",
-  missions:
-    "La mission est-elle une timeline documentaire, un workflow d'etats, ou les deux ?",
-  production:
-    "La vue copropriete 360 doit-elle devenir une carte structurelle de reference ou rester une projection de consultation ?",
-  technique:
-    "Le cycle travaux doit-il etre une chaine SOP typee de bout en bout, ou une vue de suivi alimentee par documents ?",
-  meta:
-    "Ces elements servent-ils au modele metier ou seulement a gouverner l'import et la couverture ?",
-  mapping_profile_governance:
-    "Ces elements doivent-ils rester hors modele metier comme regles de mapping et qualite ?",
-  mappingprofile:
-    "Ces elements doivent-ils rester hors modele metier comme regles de mapping et qualite ?",
-};
-
-const choiceBlock = [
-  "A. Rapatrier dans V6 comme concept/relation SOP canonique.",
-  "B. Ne pas ajouter: mapper vers un concept ou une relation V6 deja existante.",
-  "C. Rejeter: bruit V4, fake data, ou relation trop generique.",
-  "D. Bloquer: demander une phrase SOP source -> relation -> cible avant decision.",
-].join("\n");
-
-const md = (value) =>
-  String(value ?? "")
-    .replaceAll("|", "\\|")
-    .replace(/\s+/g, " ")
-    .trim();
-
-const familyFromScope = (scope) => {
-  if (!scope) return "unknown";
-  const cleaned = scope.replace(/^serenity-production-v5:/, "");
-  const [family] = cleaned.split(":");
-  return family || "unknown";
-};
-
-const labelFromScope = (scope) => {
-  if (!scope) return "Sans scenario";
-  return scope.replace(/^serenity-production-v5:/, "").replaceAll(":", " / ");
-};
-
-const schemaLabel = (schemaId) =>
-  schemaId
-    .replace(/^serenity-v4:/, "")
-    .replace(/^serenity-v4-s2:/, "")
-    .replace(/^serenity-production-v6:/, "")
-    .replaceAll(":", " / ")
-    .replaceAll("_", " ");
-
-const schemaDisplayKey = (schema) => schemaLabel(schema.schema_id).toLowerCase();
-
-const relationRecommendation = (relation) => {
-  if (["referencer", "supporter"].includes(relation.relation_type)) {
-    return "Ne pas rapatrier tel quel. Decomposer en relations SOP precises avec source, cible et preuve.";
-  }
-  if (relation.source_quality === "mixed_or_generated") {
-    return "Candidat seulement. Rapatrier uniquement si une phrase SOP confirme source, cible et direction.";
-  }
-  return "Candidat a valider par scenario SOP.";
-};
-
-const schemaRecommendation = (schema) => {
-  if (schema.current_v6_equivalent) {
-    return `Mapper vers ${schema.current_v6_equivalent}; pas de nouveau schema a creer.`;
-  }
-  if (schema.decision === "rename_and_add_if_sop_valid") {
-    return "Concept potentiellement utile, mais le nom doit etre renomme en V6 et confirme par SOP.";
-  }
-  if (schema.decision === "add_or_rename_after_sop_review") {
-    return "Decision metier requise: nouveau concept V6 ou decomposition vers concepts existants.";
-  }
-  return "Verifier si c'est un alias V4, un concept manquant, ou du bruit.";
-};
-
-const families = new Map();
-const ensureFamily = (family) => {
-  if (!families.has(family)) {
-    families.set(family, {
-      family,
-      label: domainGloss[family] || family,
-      question: scenarioQuestion[family] || "Quelle decision metier faut-il prendre pour ce groupe ?",
-      scenarioLabels: new Set(),
-      schemas: [],
-      relations: [],
-    });
-  }
-  return families.get(family);
-};
-
-for (const scenario of scenarios) {
-  const family = ensureFamily(familyFromScope(scenario.scope));
-  family.scenarioLabels.add(labelFromScope(scenario.scope));
-}
-
-for (const schema of schemas) {
-  for (const scope of schema.required_by_scopes || []) {
-    const family = ensureFamily(familyFromScope(scope));
-    family.schemas.push(schema);
-    family.scenarioLabels.add(labelFromScope(scope));
-  }
-}
-
-for (const relation of relations) {
-  for (const supported of relation.supported_scenarios || []) {
-    const family = ensureFamily(familyFromScope(supported.scope));
-    family.relations.push(relation);
-    family.scenarioLabels.add(labelFromScope(supported.scope));
-  }
-}
-
-const uniqBy = (items, keyFn) => {
-  const seen = new Set();
-  return items.filter((item) => {
-    const key = keyFn(item);
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-};
-
-for (const family of families.values()) {
-  family.schemas = uniqBy(family.schemas, schemaDisplayKey);
-  family.relations = uniqBy(family.relations, (relation) => relation.relation_type);
-}
-
-const orderedFamilies = [...families.values()]
-  .filter((family) => family.schemas.length || family.relations.length)
-  .sort((a, b) => {
-    const score = (family) => family.schemas.length * 2 + family.relations.length;
-    return score(b) - score(a) || a.family.localeCompare(b.family);
-  });
-
-const immediateMappings = schemas.filter((schema) => schema.current_v6_equivalent);
-const conceptDecisions = uniqBy(
-  schemas.filter((schema) => !schema.current_v6_equivalent),
-  schemaDisplayKey,
-);
-const genericRelations = relations.filter((relation) =>
-  ["referencer", "supporter"].includes(relation.relation_type),
-);
-const sopRelationCandidates = relations.filter(
-  (relation) => !["referencer", "supporter"].includes(relation.relation_type),
-);
-
-const summary = {
-  generated_at: new Date().toISOString(),
-  source_directories: {
-    migration: path.relative(ROOT, MIGRATION_DIR),
-    technical_review: path.relative(ROOT, TECHNICAL_REVIEW_DIR),
-  },
-  output_directory: path.relative(ROOT, OUT_DIR),
-  counts: {
-    scenarios: scenarios.length,
-    schema_cases: schemas.length,
-    schema_alias_or_mapping_cases: immediateMappings.length,
-    schema_concept_decision_cases: conceptDecisions.length,
-    relation_cases: relations.length,
-    generic_relations_not_to_import_as_is: genericRelations.length,
-    sop_relation_candidates: sopRelationCandidates.length,
-    rejected_relation_cases_kept_out: rejected.length,
-  },
-  conclusion:
-    "Rien ne doit etre importe automatiquement depuis V4. Les vrais candidats sont des decisions conceptuelles par scenario: mappings de schemas, quelques concepts manquants, et relations SOP a rediger.",
-};
-
-write(
-  "README.md",
-  `# Serenity Production V6 - revue conceptuelle
-
-Ce dossier remplace la lecture technique du pack precedent pour la decision metier.
-
-Le point important: **il n'y a pas une masse de choses a rapatrier automatiquement depuis V4**. V4 contient beaucoup de relations generiques, de fake data, de references techniques et de liens trop larges. La revue utile est donc:
-
-1. confirmer les concepts qui sont deja couverts par V6 et doivent seulement etre mappes;
-2. identifier les vrais concepts manquants par scenario;
-3. refuser les relations generiques comme \`referencer\` et \`supporter\` tant qu'elles ne sont pas decomposees;
-4. accepter une relation uniquement si elle peut etre formulee comme une phrase SOP: **source -> verbe -> cible**.
-
-Fichiers a lire dans l'ordre:
-
-- \`00-quoi-rapatrier.md\`: synthese actionnable.
-- \`01-questions-decision.md\`: questions metier avec choix A/B/C/D.
-- \`02-scenarios.md\`: revue par scenario/famille.
-- \`03-schemas-concepts.md\`: concepts manquants ou a mapper.
-- \`04-relations-candidates.md\`: relations candidates traduites en langage metier.
-- \`concept_review_matrix.json\`: meme contenu en structure exploitable par script.
-`,
-);
-
-write(
-  "00-quoi-rapatrier.md",
-  `# Quoi rapatrier depuis V4 ?
-
-## Conclusion courte
-
-**Rien a rapatrier automatiquement.** Le bon resultat de la revue actuelle est conservateur: V6 reste a 300 schemas/entites parce que les 400+ de V4 incluent beaucoup de bruit, de donnees generees et de relations non SOP.
-
-## A rapatrier maintenant sans changer le modele
-
-Ces cas ne demandent pas de nouveau schema V6: ils doivent etre traites comme alias, renommages ou mappings de reference.
-
-| Concept V4/SOP | Decision proposee |
-|---|---|
-${immediateMappings
-  .map((schema) => `| ${md(schemaLabel(schema.schema_id))} | ${md(schemaRecommendation(schema))} |`)
-  .join("\n") || "| Aucun | Aucun mapping immediat detecte |"}
-
-## A decider au niveau concept/scenario
-
-Ces concepts ne doivent pas etre ajoutes sur base du JSON seul. Il faut dire s'ils existent vraiment dans une SOP.
-
-| Concept candidat | Scenarios touches | Decision proposee |
-|---|---:|---|
-${conceptDecisions
-  .map(
-    (schema) =>
-      `| ${md(schemaLabel(schema.schema_id))} | ${schema.required_by_count ?? (schema.required_by_scopes || []).length} | ${md(schemaRecommendation(schema))} |`,
-  )
-  .join("\n") || "| Aucun | 0 | Aucun concept a decider |"}
-
-## A ne pas rapatrier tel quel
-
-| Relation V4 | Pourquoi |
-|---|---|
-${genericRelations
-  .map(
-    (relation) =>
-      `| ${md(relation.relation_type)} | ${md(relationGloss[relation.relation_type])}. ${md(relationRecommendation(relation))} |`,
-  )
-  .join("\n") || "| Aucune | Aucun cas generique majeur |"}
-
-## A transformer en phrase SOP avant decision
-
-Une relation candidate devient acceptable seulement si on peut l'ecrire ainsi:
-
-\`<concept source> -> <relation metier> -> <concept cible>\`
-
-Exemple de decision attendue: \`Decision AG -> genere -> Demande de travaux\`.
-
-Relations candidates a revoir: ${sopRelationCandidates.map((relation) => `\`${relation.relation_type}\``).join(", ")}.
-`,
-);
-
-write(
-  "01-questions-decision.md",
-  `# Questions de decision
-
-Pour chaque bloc, choisis A/B/C/D. Tu peux aussi repondre par une phrase SOP si tu connais la relation exacte.
-
-${orderedFamilies
-  .map((family) => {
-    const schemaLines = family.schemas
-      .slice(0, 8)
-      .map((schema) => `- ${schemaLabel(schema.schema_id)}: ${schemaRecommendation(schema)}`)
-      .join("\n");
-    const relationLines = family.relations
-      .slice(0, 10)
-      .map(
-        (relation) =>
-          `- ${relation.relation_type}: ${relationGloss[relation.relation_type] || "relation a clarifier"}; ${relationRecommendation(relation)}`,
-      )
-      .join("\n");
-    return `## ${family.label}
-
-Question metier: ${family.question}
-
-Concepts a trancher:
-${schemaLines || "- Aucun concept manquant detecte pour ce bloc."}
-
-Relations a trancher:
-${relationLines || "- Aucune relation candidate detectee pour ce bloc."}
-
-Choix possibles:
-${choiceBlock}`;
-  })
-  .join("\n\n")}
-`,
-);
-
-write(
-  "02-scenarios.md",
-  `# Revue par scenario/famille
-
-${orderedFamilies
-  .map((family) => {
-    const scenarioList = [...family.scenarioLabels].sort().slice(0, 20);
-    return `## ${family.label}
-
-Question de fond: ${family.question}
-
-Scenarios couverts:
-${scenarioList.map((label) => `- ${label}`).join("\n")}
-${family.scenarioLabels.size > scenarioList.length ? `\n- ... ${family.scenarioLabels.size - scenarioList.length} autres scenarios` : ""}
-
-Concepts manquants ou a mapper:
-${family.schemas
-  .map(
-    (schema) =>
-      `- ${schemaLabel(schema.schema_id)} -> ${schemaRecommendation(schema)} Scenarios touches: ${schema.required_by_count ?? (schema.required_by_scopes || []).length}.`,
-  )
-  .join("\n") || "- Aucun."}
-
-Relations candidates:
-${family.relations
-  .map(
-    (relation) =>
-      `- ${relation.relation_type}: ${relationGloss[relation.relation_type] || "a clarifier"}. Recommendation: ${relationRecommendation(relation)}`,
-  )
-  .join("\n") || "- Aucune."}
-
-Decision attendue:
-- choisir A/B/C/D pour chaque concept et relation;
-- si A, fournir une phrase SOP source -> relation -> cible;
-- si B, indiquer le concept ou la relation V6 cible.`;
-  })
-  .join("\n\n")}
-`,
-);
-
-write(
-  "03-schemas-concepts.md",
-  `# Concepts et schemas
-
-## Cas de mapping/alias
-
-| Concept reference | Equivalent V6 propose | Scenarios | Action |
-|---|---|---:|---|
-${immediateMappings
-  .map(
-    (schema) =>
-      `| ${md(schemaLabel(schema.schema_id))} | ${md(schema.current_v6_equivalent)} | ${schema.required_by_count ?? (schema.required_by_scopes || []).length} | Mapper, ne pas creer de nouveau schema |`,
-  )
-  .join("\n") || "| Aucun | - | 0 | - |"}
-
-## Cas de decision conceptuelle
-
-| Concept candidat | Domaine | Scenarios | Question |
-|---|---|---:|---|
-${conceptDecisions
-  .map((schema) => {
-    const family = domainGloss[schema.domain] || schema.domain || "inconnu";
-    return `| ${md(schemaLabel(schema.schema_id))} | ${md(family)} | ${schema.required_by_count ?? (schema.required_by_scopes || []).length} | ${md(schemaRecommendation(schema))} |`;
-  })
-  .join("\n") || "| Aucun | - | 0 | - |"}
-`,
-);
-
-write(
-  "04-relations-candidates.md",
-  `# Relations candidates
-
-## Relations a rejeter telles quelles
-
-| Relation | Lecture metier | Decision |
-|---|---|---|
-${genericRelations
-  .map(
-    (relation) =>
-      `| ${md(relation.relation_type)} | ${md(relationGloss[relation.relation_type])} | ${md(relationRecommendation(relation))} |`,
-  )
-  .join("\n") || "| Aucune | - | - |"}
-
-## Relations SOP candidates
-
-Ces relations ne sont pas encore acceptees. Elles sont seulement des hypotheses a reformuler en SOP.
-
-| Relation V4 | Lecture metier | Scenarios | Decision proposee |
-|---|---|---|---|
-${sopRelationCandidates
-  .map((relation) => {
-    const scopes = (relation.supported_scenarios || [])
-      .map((scenario) => labelFromScope(scenario.scope))
-      .join(", ");
-    return `| ${md(relation.relation_type)} | ${md(relationGloss[relation.relation_type] || "a clarifier")} | ${md(scopes)} | ${md(relationRecommendation(relation))} |`;
-  })
-  .join("\n") || "| Aucune | - | - | - |"}
-
-## Format de validation
-
-Pour accepter une relation, fournir une phrase de ce type:
-
-\`Decision AG -> genere -> Demande de travaux\`
-
-Puis preciser:
-
-- source: schema V6 source;
-- cible: schema V6 cible;
-- cardinalite: un vers un, un vers plusieurs, plusieurs vers plusieurs;
-- preuve SOP: nom du scenario ou procedure qui l'exige.
-`,
-);
-
-const matrix = orderedFamilies.map((family) => ({
-  family: family.family,
-  label: family.label,
-  business_question: family.question,
-  scenario_count: family.scenarioLabels.size,
-  scenarios: [...family.scenarioLabels].sort(),
-  schema_cases: family.schemas.map((schema) => ({
-    schema_id: schema.schema_id,
-    business_label: schemaLabel(schema.schema_id),
-    recommendation: schemaRecommendation(schema),
-    current_v6_equivalent: schema.current_v6_equivalent ?? null,
-    decision: schema.decision,
-    required_by_count: schema.required_by_count ?? (schema.required_by_scopes || []).length,
-  })),
-  relation_cases: family.relations.map((relation) => ({
-    relation_type: relation.relation_type,
-    business_reading: relationGloss[relation.relation_type] || null,
-    recommendation: relationRecommendation(relation),
-    decision: relation.decision,
-    v4_instances: relation.v4_instances,
-    source_quality: relation.source_quality,
-  })),
-  choices: ["rapatrier", "mapper_existing", "reject", "needs_sop_sentence"],
-}));
-
-write("concept_review_matrix.json", JSON.stringify({ summary, families: matrix }, null, 2));
-write("review_summary.json", JSON.stringify(summary, null, 2));
-
-console.log(JSON.stringify(summary, null, 2));