@atlashub/smartstack-cli 4.75.0 → 4.76.0

package/templates/skills/business-analyse-html/html/src/scripts/12-render-diagrams.js

@@ -24,6 +24,24 @@ function renderMermaidDiagrams() {
         }
     }
 
+    // 1b. MCD (Modèle Conceptuel de Données) — after ERD
+    if (diagrams.mcd) {
+        var erdContainer = document.getElementById('dataModelContainer');
+        if (erdContainer) {
+            var mcdDiv = document.createElement('div');
+            mcdDiv.className = 'diagram-container diagram-mcd';
+            mcdDiv.innerHTML =
+                '<div class="diagram-section-header" style="font-size:0.95rem;font-weight:600;color:var(--text-bright);margin-bottom:0.75rem;">Mod\u00e8le Conceptuel de Donn\u00e9es (MCD)</div>' +
+                '<div class="mermaid">' + escapeHtml(diagrams.mcd) + '</div>';
+            var erdDiv = erdContainer.querySelector('.diagram-erd');
+            if (erdDiv && erdDiv.nextSibling) {
+                erdContainer.insertBefore(mcdDiv, erdDiv.nextSibling);
+            } else {
+                erdContainer.appendChild(mcdDiv);
+            }
+        }
+    }
+
     // 2. State machine diagrams — inject in module spec sections or consol-datamodel
     if (diagrams.stateMachines && Object.keys(diagrams.stateMachines).length > 0) {
         const smContainer = document.getElementById('dataModelContainer');
@@ -46,6 +64,34 @@ function renderMermaidDiagrams() {
         }
     }
 
+    // 2b. Use Case diagrams — inject in each module's UC tab
+    if (diagrams.useCases && Object.keys(diagrams.useCases).length > 0) {
+        Object.entries(diagrams.useCases).forEach(function(entry) {
+            var moduleCode = entry[0];
+            var def = entry[1];
+            var ucTab = document.getElementById('tab-' + moduleCode + '-uc');
+            if (!ucTab) {
+                // Try kebab-case version
+                var kebab = moduleCode.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
+                ucTab = document.getElementById('tab-' + kebab + '-uc');
+            }
+            if (ucTab) {
+                var ucDiagramDiv = document.createElement('div');
+                ucDiagramDiv.className = 'diagram-container diagram-usecase';
+                ucDiagramDiv.innerHTML =
+                    '<div class="diagram-section-header" style="font-size:0.95rem;font-weight:600;color:var(--text-bright);margin-bottom:0.75rem;">Diagramme de cas d\'utilisation</div>' +
+                    '<div class="mermaid">' + escapeHtml(def) + '</div>';
+                // Insert after the first paragraph (description text)
+                var firstP = ucTab.querySelector('p');
+                if (firstP && firstP.nextSibling) {
+                    ucTab.insertBefore(ucDiagramDiv, firstP.nextSibling);
+                } else {
+                    ucTab.insertBefore(ucDiagramDiv, ucTab.firstChild);
+                }
+            }
+        });
+    }
+
     // 3. Sequence diagrams in consol-flows
     if (diagrams.sequences && Object.keys(diagrams.sequences).length > 0) {
         var flowsContainer = document.getElementById('consolFlowsContainer');

package/templates/skills/business-analyse-html/references/02-feature-data-building.md

@@ -36,10 +36,12 @@ moduleSpecs[moduleCode] = {
     name: br.name || br.id || "",
     sectionCode: br.sectionCode || "",
     category: br.category || "",
+    severity: br.severity || "",
     statement: br.statement || br.description || "",
-    example: (br.examples || []).map(e =>
+    example: (br.examples || (br.example ? [br.example] : [])).map(e =>
       typeof e === 'string' ? e : ((e.input || "") + " → " + (e.expected || ""))
-    ).join("; ")
+    ).join("; "),
+    domainSpecific: br.domainSpecific || false
   })),
   // ENTITY SAFETY NET: map fields[] → attributes[] if agent deviated
   entities: (mod.entities?.entities || []).map(ent => ({

package/templates/skills/business-analyse-html/references/data-build.md

@@ -133,6 +133,8 @@ for rendering in the HTML viewer.
 ```javascript
 mermaidDiagrams: {
   erd: consolidation.mermaidDiagrams?.erd || null,           // ERD string or null
+  mcd: consolidation.mermaidDiagrams?.mcd || null,           // MCD string or null
+  useCases: consolidation.mermaidDiagrams?.useCases || {},   // {moduleCode: mermaid_def}
   stateMachines: consolidation.mermaidDiagrams?.stateMachines || {},  // {entity: mermaid_def}
   sequences: consolidation.mermaidDiagrams?.sequences || {}          // {flowName: mermaid_def}
 }

package/templates/skills/business-analyse-html/references/data-mapping.md

@@ -122,6 +122,7 @@ moduleSpecs[moduleCode] = {
     name: uc.name || uc.title || uc.id || "",            // Format A: "name", Format B: "title" or "id"
     sectionCode: uc.sectionCode || "",
     actor: uc.primaryActor || uc.actor || "",             // Format A: "primaryActor", Format B: "actor"
+    description: uc.description || "",                    // Optional description field
     // SAFETY NET: steps may be string[] or object[] ({step, action})
     steps: (uc.mainScenario || uc.steps || []).map(s =>
       typeof s === 'string' ? s : (s.action || s.description || "")
@@ -130,7 +131,10 @@ moduleSpecs[moduleCode] = {
       (a.name || a.trigger || "") + ": " + (a.steps || a.actions || []).map(s =>
         typeof s === 'string' ? s : (s.action || s.description || "")
       ).join(", ")
-    ).join("\n")
+    ).join("\n"),
+    preconditions: uc.preconditions || [],                // Array of precondition objects or strings
+    postconditions: uc.postconditions || [],              // Array of postcondition objects or strings
+    errorScenarios: uc.errorScenarios || []               // Array of error scenario objects
   })),
   businessRules: rawBRs.map(br => ({
     name: br.name || br.id || "",
@@ -166,19 +170,28 @@ The HTML uses `"Role|Action"` format (e.g. `"RH Admin|Consulter"`):
 
 ```javascript
 // Input: permissions object from flat file (mod.permissions), NOT moduleFeature
-function buildPermissionKeys(permissionsData) {
+// lang: optional language override ('fr' or 'en'), defaults to 'fr'
+function buildPermissionKeys(permissionsData, lang = 'fr') {
   const keys = [];
-  const actionMap = {
-    Read: "Consulter", Create: "Créer", Update: "Modifier",
-    Delete: "Supprimer", Validate: "Valider", Export: "Exporter",
-    Submit: "Valider", Import: "Créer",
-    read: "Consulter", create: "Créer", update: "Modifier",
-    delete: "Supprimer", validate: "Valider", export: "Exporter",
-    submit: "Valider", import: "Créer"
-  };
+
+  // Bilingual actionMap based on language parameter
+  const actionMap = lang === 'en'
+    ? {
+        read: 'Read', create: 'Create', update: 'Update', delete: 'Delete',
+        approve: 'Approve', export: 'Export', validate: 'Validate', admin: 'Admin',
+        Read: 'Read', Create: 'Create', Update: 'Update', Delete: 'Delete',
+        Approve: 'Approve', Export: 'Export', Validate: 'Validate', Admin: 'Admin',
+        submit: 'Validate', import: 'Create', Submit: 'Validate', Import: 'Create'
+      }
+    : {
+        read: 'Consulter', create: 'Créer', update: 'Modifier', delete: 'Supprimer',
+        approve: 'Valider', export: 'Exporter', validate: 'Valider', admin: 'Administrer',
+        Read: 'Consulter', Create: 'Créer', Update: 'Modifier', Delete: 'Supprimer',
+        Approve: 'Valider', Export: 'Exporter', Validate: 'Valider', Admin: 'Administrer',
+        submit: 'Valider', import: 'Créer', Submit: 'Valider', Import: 'Créer'
+      };
 
   const matrix = permissionsData?.matrix || permissionsData?.permissionMatrix;
-  if (!matrix) return keys;
 
   // Format A: matrix is array of { role, permissions[] } (ba-009+ format)
   if (Array.isArray(matrix)) {
@@ -202,25 +215,79 @@ function buildPermissionKeys(permissionsData) {
   }
 
   // Format B: legacy matrix.roleAssignments[] format
-  (matrix.roleAssignments || []).forEach(ra => {
-    (ra.permissions || []).forEach(permPath => {
-      const action = permPath.split(".").pop();
-      if (action === "*") {
-        Object.values(actionMap).forEach(uiAction => {
+  if (matrix && matrix.roleAssignments) {
+    (matrix.roleAssignments || []).forEach(ra => {
+      (ra.permissions || []).forEach(permPath => {
+        const action = permPath.split(".").pop();
+        if (action === "*") {
+          Object.values(actionMap).forEach(uiAction => {
+            const key = ra.role + "|" + uiAction;
+            if (!keys.includes(key)) keys.push(key);
+          });
+        } else {
+          const uiAction = actionMap[action] || action;
           const key = ra.role + "|" + uiAction;
           if (!keys.includes(key)) keys.push(key);
+        }
+      });
+    });
+    return keys;
+  }
+
+  // Format C: permissions.json from step-03 with top-level roles[]
+  if (keys.length === 0 && permissionsData?.roles) {
+    const actionMap_C = lang === 'en'
+      ? { read: 'Read', create: 'Create', update: 'Update', delete: 'Delete', approve: 'Approve', export: 'Export', validate: 'Validate', admin: 'Admin' }
+      : { read: 'Consulter', create: 'Créer', update: 'Modifier', delete: 'Supprimer', approve: 'Valider', export: 'Exporter', validate: 'Valider', admin: 'Administrer' };
+
+    permissionsData.roles.forEach(entry => {
+      const role = entry.role || entry.name || '';
+      (entry.permissions || entry.actions || []).forEach(perm => {
+        const action = typeof perm === 'string' ? perm.split('.').pop().toLowerCase() : (perm.action || '').toLowerCase();
+        const uiAction = actionMap_C[action] || action;
+        const key = role + '|' + uiAction;
+        if (role && !keys.includes(key)) keys.push(key);
+      });
+      // Handle wildcard patterns like "HumanResources.*"
+      if ((entry.permissionPattern || '').endsWith('*')) {
+        Object.values(actionMap_C).forEach(a => {
+          const key = (entry.role || entry.name) + '|' + a;
+          if (!keys.includes(key)) keys.push(key);
         });
-      } else {
-        const uiAction = actionMap[action] || action;
-        keys.push(ra.role + "|" + uiAction);
       }
     });
-  });
+  }
+
+  // Format D: permissionMatrix.roleAssignments[]
+  if (keys.length === 0 && permissionsData?.permissionMatrix?.roleAssignments) {
+    const actionMap_D = lang === 'en'
+      ? { read: 'Read', create: 'Create', update: 'Update', delete: 'Delete', approve: 'Approve', export: 'Export', validate: 'Validate', admin: 'Admin' }
+      : { read: 'Consulter', create: 'Créer', update: 'Modifier', delete: 'Supprimer', approve: 'Valider', export: 'Exporter', validate: 'Valider', admin: 'Administrer' };
+
+    permissionsData.permissionMatrix.roleAssignments.forEach(entry => {
+      const role = entry.role || '';
+      (entry.permissions || []).forEach(perm => {
+        if (typeof perm === 'string' && perm.endsWith('.*')) {
+          // Wildcard: expand to all standard actions
+          Object.values(actionMap_D).forEach(a => {
+            const key = role + '|' + a;
+            if (!keys.includes(key)) keys.push(key);
+          });
+        } else {
+          const action = typeof perm === 'string' ? perm.split('.').pop().toLowerCase() : '';
+          const uiAction = actionMap_D[action] || action;
+          const key = role + '|' + uiAction;
+          if (role && action && !keys.includes(key)) keys.push(key);
+        }
+      });
+    });
+  }
+
   return keys;
 }
 ```
 
-> **Language handling:** The actionMap should use `metadata.language` to select the correct labels. For `fr`: Consulter/Créer/Modifier/Supprimer. For `en`: Read/Create/Update/Delete. Default to English if language is unknown.
+> **Language handling:** The function accepts an optional `lang` parameter ('fr' or 'en'). Defaults to 'fr' (French). For English labels: Read/Create/Update/Delete/Export/Validate. For French: Consulter/Créer/Modifier/Supprimer/Exporter/Valider.
 
 ### Frequency Mapping
 

package/templates/skills/business-analyse-html/steps/step-02-build-data.md

@@ -64,6 +64,12 @@ This step is NEVER blocking — ASCII-only wireframes are acceptable.
 - Wireframe fields use format/content (NOT mockupFormat/mockup)
 - Per-module: useCases/businessRules/entities count must match source (empty when source has data = BUG)
 - dependencies[] must be present (even if empty) to prevent HTML crashes
+- **Permissions:** `buildPermissionKeys()` supports 4 formats:
+  - **Format A:** `permissions.matrix[]` with `{role, permissions[]}`
+  - **Format B:** `permissions.permissionMatrix.roleAssignments[]`
+  - **Format C:** `permissions.roles[]` with `{role, permissions[]}`
+  - **Format D:** `permissions.permissionMatrix.roleAssignments[]` with wildcard expansion
+  - Pass optional `lang` parameter ('fr'|'en') for bilingual labels. Defaults to 'fr'.
 
 ## NEXT STEP
 

package/templates/skills/business-analyse-html/steps/step-04-verify.md

@@ -8,7 +8,7 @@ model: opus
 
 ## YOUR TASK
 
-Run 9 blocking validations on the generated HTML file and display the completion summary.
+Run 16 blocking validations on the generated HTML file and display the completion summary.
 
 ---
 
@@ -105,11 +105,97 @@ IF "modules" is missing:
   BLOCKING_ERROR("FEATURE_DATA.modules missing — page will crash")
 ```
 
-> **IF any check fails:** fix the issue and re-run the failing step before completing.
+> **IF any check fails (1-9):** fix the issue and re-run the failing step before completing.
+
+### 2. Content Quality Validations (NEW)
+
+**Check 10 — Language coherence:**
+```
+Read FEATURE_DATA.metadata.language (or config.json language field)
+IF language is set (e.g., "fr"):
+  FOR each module in FEATURE_DATA.modules:
+    const spec = FEATURE_DATA.moduleSpecs[module.code]
+
+    // Check UC names
+    FOR each uc in spec.useCases:
+      IF language == "fr" AND uc.name matches /^(Create|Update|Delete|View|List|Manage|Submit|Approve|Reject|Export)\b/:
+        WARNING("Module {module.code}: UC '{uc.name}' appears English (expected French)")
+
+    // Check BR statements
+    FOR each br in spec.businessRules:
+      IF language == "fr" AND br.statement matches /\b(must|should|cannot|when|if the|is required)\b/i:
+        WARNING("Module {module.code}: BR '{br.name}' statement appears English (expected French)")
+
+  Count total warnings. IF > 20% of items are in wrong language:
+    WARNING("⚠ Significant language mismatch: {count} items in wrong language")
+```
+
+**Check 11 — Business rules have examples:**
+```
+FOR each module in FEATURE_DATA.modules:
+  const brs = FEATURE_DATA.moduleSpecs[module.code].businessRules || []
+  IF brs.length === 0: SKIP
+  const withExamples = brs.filter(br => br.example && br.example.trim() !== '')
+  const rate = withExamples.length / brs.length
+  IF rate < 0.5:
+    WARNING("Module {module.code}: only {withExamples.length}/{brs.length} BRs have examples ({rate*100}%)")
+```
+
+**Check 12 — Entity attributes have type field:**
+```
+FOR each module in FEATURE_DATA.modules:
+  const entities = FEATURE_DATA.moduleSpecs[module.code].entities || []
+  FOR each entity in entities:
+    const attrs = entity.attributes || []
+    const withType = attrs.filter(a => a.type && a.type.trim() !== '' && a.type !== 'string')
+    IF attrs.length > 3 AND withType.length === 0:
+      WARNING("Module {module.code}: entity '{entity.name}' — all {attrs.length} attributes default to 'string' (types may be missing)")
+```
+
+**Check 13 — Permissions populated per module:**
+```
+FOR each module in FEATURE_DATA.modules:
+  const perms = FEATURE_DATA.moduleSpecs[module.code].permissions || []
+  IF perms.length === 0:
+    WARNING("Module {module.code}: 0 permissions — permission grid will be empty")
+```
+
+**Check 14 — Mockups not empty (screens with actual resources):**
+```
+FOR each module in FEATURE_DATA.modules:
+  const screens = FEATURE_DATA.moduleSpecs[module.code].screens || []
+  const wireframes = EMBEDDED_ARTIFACTS.wireframes?.[module.code] || []
+  IF screens.length === 0 AND wireframes.length === 0:
+    WARNING("Module {module.code}: no screens and no wireframes — Mockups tab will show 'Aucune maquette'")
+  ELSE IF screens.length > 0:
+    const totalResources = screens.reduce((sum, s) => sum + (s.resources || []).length, 0)
+    IF totalResources === 0:
+      WARNING("Module {module.code}: has screens[] but 0 resources — mockups will appear empty despite data existing")
+```
+
+**Check 15 — MCD diagram present (multi-module projects):**
+```
+const diagrams = FEATURE_DATA.consolidation?.mermaidDiagrams || {}
+IF FEATURE_DATA.modules.length > 1:
+  IF !diagrams.erd:
+    WARNING("No ERD diagram — data model section will have no visual")
+  IF !diagrams.mcd:
+    WARNING("No MCD diagram — conceptual model not generated")
+```
+
+**Check 16 — Use Case diagrams present:**
+```
+const ucDiagrams = diagrams.useCases || {}
+const totalUCs = Object.values(FEATURE_DATA.moduleSpecs).reduce((sum, s) => sum + (s.useCases?.length || 0), 0)
+IF Object.keys(ucDiagrams).length === 0 AND totalUCs > 0:
+  WARNING("No use case diagrams generated — UC tabs will have no UML visual")
+```
+
+> **Checks 10-16 produce WARNINGs (non-blocking).** Display all warnings in the completion summary so the user is aware of potential quality issues.
 
 ---
 
-### 2. Display Completion Summary
+### 3. Display Completion Summary
 
 ```
 ══════════════════════════════════════════════════════════════
@@ -131,5 +217,8 @@ Modules: {count} ({names})
   4. If approved: /business-analyse-handoff then /business-analyse-develop to begin development
   5. If corrections needed: export ba-review.json from the HTML, then run /business-analyse-review
 
+Quality Warnings: {warning_count}
+{FOR each warning: display warning message}
+
 ══════════════════════════════════════════════════════════════
 ```