@atlashub/smartstack-cli 4.50.0 → 4.52.0

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

@@ -111,20 +111,34 @@ For EACH module, use the flat file data from `collected_data.modules[moduleCode]
 ```javascript
 const mod = collected_data.modules[moduleCode];
 
+// NORMALIZE: usecases.json may use "useCases" (camelCase) or "usecases" (lowercase)
+const rawUCs = mod.usecases?.useCases || mod.usecases?.usecases || [];
+// NORMALIZE: rules.json may use "rules" or "businessRules"
+const rawBRs = mod.rules?.rules || mod.rules?.businessRules || [];
+
 moduleSpecs[moduleCode] = {
-  useCases: (mod.usecases?.useCases || []).map(uc => ({
-    name: uc.name,
+  useCases: rawUCs.map(uc => ({
+    name: uc.name || uc.title || uc.id || "",
     sectionCode: uc.sectionCode || "",
-    actor: uc.primaryActor,
-    steps: (uc.mainScenario || []).join("\n"),
-    alternative: (uc.alternativeScenarios || []).map(a => a.name + ": " + (a.steps || []).join(", ")).join("\n")
+    actor: uc.primaryActor || uc.actor || "",
+    // SAFETY NET: steps may be strings[] (mainScenario) or objects[] ({step, action})
+    steps: (uc.mainScenario || uc.steps || []).map(s =>
+      typeof s === 'string' ? s : (s.action || s.description || "")
+    ).join("\n"),
+    alternative: (uc.alternativeScenarios || uc.alternativeFlows || []).map(a =>
+      (a.name || a.trigger || "") + ": " + (a.steps || a.actions || []).map(s =>
+        typeof s === 'string' ? s : (s.action || s.description || "")
+      ).join(", ")
+    ).join("\n")
   })),
-  businessRules: (mod.rules?.rules || []).map(br => ({
-    name: br.name,
+  businessRules: rawBRs.map(br => ({
+    name: br.name || br.id || "",
     sectionCode: br.sectionCode || "",
-    category: br.category,
-    statement: br.statement,
-    example: (br.examples || []).map(e => e.input + " → " + e.expected).join("; ")
+    category: br.category || "",
+    statement: br.statement || br.description || "",
+    example: (br.examples || []).map(e =>
+      typeof e === 'string' ? e : ((e.input || "") + " → " + (e.expected || ""))
+    ).join("; ")
   })),
   // ENTITY SAFETY NET: map fields[] → attributes[] if agent deviated
   entities: (mod.entities?.entities || []).map(ent => ({
@@ -141,9 +155,45 @@ moduleSpecs[moduleCode] = {
 }
 
 // BUILD screens[] for HTML interactive mockups (SmartTable/SmartForm rendering)
+// NORMALIZE: screens.json may use "screens[]" (flat) or "sections[]" (nested) format
 const flatScr = mod.screens?.screens || [];
+const sectionScr = mod.screens?.sections || [];
 let screens = [];
+
+// Helper: normalize a column definition regardless of field naming convention
+function normalizeColumn(c) {
+  return {
+    field: c.code || c.name || c.id || c.field || c.fieldCode || "",
+    label: c.label || c.displayName || c.code || c.name || "",
+    type: c.renderAs === "badge" ? "badge" : (c.type || c.dataType || "text"),
+    sortable: !!c.sortable
+  };
+}
+
+// Helper: normalize a form field
+function normalizeField(f) {
+  return {
+    field: f.code || f.name || f.id || f.fieldCode || f.field || "",
+    label: f.label || f.displayName || f.code || f.name || "",
+    type: f.type || f.fieldType || f.dataType || "text",
+    required: !!f.required
+  };
+}
+
+// Helper: normalize a filter
+function normalizeFilter(f) {
+  if (typeof f === 'string') return f;
+  return f.label || f.displayName || f.filterLabel || f.name || f.code || f.filterCode || "";
+}
+
+// Helper: normalize an action
+function normalizeAction(a) {
+  if (typeof a === 'string') return a;
+  return a.code || a.id || a.label || a.actionCode || "";
+}
+
 if (flatScr.length > 0) {
+  // FORMAT A: flat screens[] array (ba-003 style)
   const bySec = {};
   flatScr.forEach(s => {
     const sec = s.section || "default";
@@ -156,28 +206,54 @@ if (flatScr.length > 0) {
       code: s.screen || s.name || "",
       label: s.sectionLabel || s.description || s.screen || "",
       type: s.componentType || "unknown",
-      columns: (s.columns || []).map(c => ({
-        field: c.code || c.field || "", label: c.label || c.code || "",
-        type: c.type || c.dataType || "text", sortable: !!c.sortable
-      })),
-      filters: (s.filters || []).map(f =>
-        typeof f === 'string' ? f : (f.label || f.filterLabel || f.code || f.filterCode || "")),
+      columns: (s.columns || []).map(normalizeColumn),
+      filters: (s.filters || []).map(normalizeFilter),
       fields: [],
       tabs: (s.tabs || []).map(t => ({
         label: t.label || t.tabLabel || t.code || "",
-        fields: (t.fields || []).map(f => ({
-          field: f.code || f.fieldCode || f.field || "",
-          label: f.label || f.code || "",
-          type: f.type || f.dataType || "text",
-          required: !!f.required
-        }))
+        fields: (t.fields || []).map(normalizeField)
       })),
-      actions: (s.actions || []).map(a =>
-        typeof a === 'string' ? a : (a.code || a.label || a.actionCode || "")),
-      kpis: s.kpis || [],
+      actions: (s.actions || []).map(normalizeAction),
+      kpis: (s.kpis || []).map(k => typeof k === 'object'
+        ? { label: k.label || k.displayName || "", value: k.value || k.metric || "0" }
+        : { label: String(k), value: "0" }),
       options: s.options || [],
       permission: s.permission || "",
-      notes: s.description || ""
+      notes: s.description || s.sectionDescription || ""
+    });
+  });
+  screens = Object.values(bySec);
+} else if (sectionScr.length > 0) {
+  // FORMAT B: sections[] array (ba-004 style — id/displayName/layout convention)
+  // Each section IS a screen resource (columns, tabs, filters are ON the section itself)
+  const bySec = {};
+  sectionScr.forEach(sec => {
+    const secId = sec.id || sec.code || sec.sectionCode || "";
+    const secLabel = sec.displayName || sec.label || sec.sectionLabel || secId;
+    const componentType = sec.layout || sec.componentType || "unknown";
+    if (!bySec[secId]) bySec[secId] = {
+      sectionCode: secId,
+      sectionLabel: secLabel,
+      resources: []
+    };
+    bySec[secId].resources.push({
+      code: secId,
+      label: secLabel,
+      type: componentType,
+      columns: (sec.columns || []).map(normalizeColumn),
+      filters: (sec.filters || []).map(normalizeFilter),
+      fields: [],
+      tabs: (sec.tabs || []).map(t => ({
+        label: t.displayName || t.label || t.code || t.id || "",
+        fields: (t.fields || []).map(normalizeField)
+      })),
+      actions: (sec.actions || []).map(normalizeAction),
+      kpis: (sec.kpis || []).map(k => typeof k === 'object'
+        ? { label: k.displayName || k.label || "", value: k.format === "percentage" ? "80%" : "1,234" }
+        : { label: String(k), value: "0" }),
+      options: sec.options || [],
+      permission: (typeof sec.permissions === 'object' ? sec.permissions?.view : sec.permission) || "",
+      notes: sec.description || ""
     });
   });
   screens = Object.values(bySec);
@@ -216,20 +292,36 @@ FEATURE_DATA.modules.forEach(m => {
   const source = collected_data.modules[m.code];
   if (!spec) { errors.push(`MISSING moduleSpecs[${m.code}]`); return; }
 
-  const srcUC = (source?.usecases?.useCases || []).length;
+  // Check useCases (handle both key conventions)
+  const srcUC = (source?.usecases?.useCases || source?.usecases?.usecases || []).length;
   const bltUC = (spec.useCases || []).length;
   if (srcUC > 0 && bltUC === 0)
     errors.push(`${m.code}: useCases EMPTY but source has ${srcUC}`);
 
-  const srcBR = (source?.rules?.rules || []).length;
+  // Check businessRules (handle both key conventions)
+  const srcBR = (source?.rules?.rules || source?.rules?.businessRules || []).length;
   const bltBR = (spec.businessRules || []).length;
   if (srcBR > 0 && bltBR === 0)
     errors.push(`${m.code}: businessRules EMPTY but source has ${srcBR}`);
 
+  // Check entities
   const srcEnt = (source?.entities?.entities || []).length;
   const bltEnt = (spec.entities || []).length;
   if (srcEnt > 0 && bltEnt === 0)
     errors.push(`${m.code}: entities EMPTY but source has ${srcEnt}`);
+
+  // Check screens (handle both formats: screens[] and sections[])
+  const srcScreens = (source?.screens?.screens || source?.screens?.sections || []).length;
+  const bltScreenResources = (spec.screens || []).reduce(
+    (acc, s) => acc + (s.resources || []).length, 0);
+  if (srcScreens > 0 && bltScreenResources === 0)
+    errors.push(`${m.code}: screens EMPTY (0 resources) but source has ${srcScreens} screens/sections`);
+
+  // Check serialization: [object Object] in useCases steps = BUG
+  (spec.useCases || []).forEach(uc => {
+    if (uc.steps && uc.steps.includes("[object Object]"))
+      errors.push(`${m.code}: UC "${uc.name}" has [object Object] in steps — steps[] contains objects not strings`);
+  });
 });
 
 if (errors.length > 0) {
@@ -242,6 +334,19 @@ if (errors.length > 0) {
 > If self-check detects errors, you MUST re-read the source data and re-build the failing moduleSpecs entries.
 > Do NOT proceed with empty arrays when source data exists.
 
+**dependencies[] (TOP-LEVEL — CRITICAL for HTML navigation):**
+```javascript
+dependencies: (master.consolidation?.crossModuleInteractions || master.dependencyGraph?.edges || []).map(i => ({
+  from: i.fromModule || i.from || "",
+  to: i.toModule || i.to || "",
+  description: i.description || ""
+}))
+```
+
+> **WARNING:** `data.dependencies` is used by the sidebar (navigation), module rendering, consolidation views,
+> handoff summary, and export. If this array is missing, the entire HTML page crashes with a TypeError.
+> ALWAYS include it, even if empty (`dependencies: []`).
+
 **consolidation:**
 ```javascript
 consolidation: {
@@ -297,39 +402,62 @@ rawWireframes.push(...flatScreens.filter(s => s.mockup || s.mockupFormat));
 // Source B: nested sections[].resources[].wireframe (design step output)
 const sections = mod.screens?.sections || [];
 for (const section of sections) {
+  // B1: wireframe directly on section (ba-004 style: sections[].wireframe)
+  if (section.wireframe) {
+    rawWireframes.push({
+      ...section.wireframe,
+      section: section.wireframe.section || section.id || section.code || section.sectionCode || "",
+      screen: section.wireframe.screen || section.id || section.code || section.sectionCode || ""
+    });
+  }
+  // B2: wireframe on resources (nested: sections[].resources[].wireframe)
   for (const resource of (section.resources || [])) {
     if (resource.wireframe) {
-      // Unwrap nested wireframe and add section context
       rawWireframes.push({
         ...resource.wireframe,
-        section: resource.wireframe.section || section.sectionCode || "",
-        screen: resource.wireframe.screen || `${section.sectionCode}-${resource.code}` || ""
+        section: resource.wireframe.section || section.sectionCode || section.id || "",
+        screen: resource.wireframe.screen || `${section.sectionCode || section.id}-${resource.code}` || ""
       });
     }
   }
 }
 
-// Source C: screens without mockup → auto-generate text description as wireframe fallback
+// Source C: screens/sections without mockup → auto-generate text description as wireframe fallback
+// C1: from flat screens[]
 const screensWithoutMockup = flatScreens.filter(s => !s.mockup && !s.mockupFormat);
-for (const screen of screensWithoutMockup) {
-  const type = screen.componentType || "";
+// C2: from sections[] (ba-004 style) — sections without wireframe property
+const sectionsWithoutWireframe = sections.filter(s => !s.wireframe);
+const allNoMockup = [
+  ...screensWithoutMockup.map(s => ({
+    type: s.componentType || "", columns: s.columns || [], tabs: s.tabs || [],
+    kpis: s.kpis || [], screen: s.screen || "", section: s.section || "",
+    description: s.sectionDescription || ""
+  })),
+  ...sectionsWithoutWireframe.map(s => ({
+    type: s.layout || s.componentType || "", columns: s.columns || [], tabs: s.tabs || [],
+    kpis: s.kpis || [], screen: s.id || s.code || "", section: s.id || s.code || "",
+    description: s.description || ""
+  }))
+];
+for (const screen of allNoMockup) {
+  const type = screen.type;
   let desc = "";
   if (type.includes("Table") || type.includes("Grid")) {
-    const cols = screen.columns || [];
-    desc = "Tableau avec " + cols.length + " colonnes : " + cols.map(c => c.label || c.code).join(", ");
+    const cols = screen.columns;
+    desc = "Tableau avec " + cols.length + " colonnes : " + cols.map(c => c.label || c.displayName || c.code || c.name).join(", ");
   } else if (type.includes("Form")) {
-    const tabs = screen.tabs || [];
+    const tabs = screen.tabs;
     desc = "Formulaire " + (tabs.length > 0 ? "avec " + tabs.length + " onglet(s)" : "");
   } else if (type.includes("Dashboard")) {
-    desc = "Tableau de bord avec KPIs";
+    desc = "Tableau de bord avec " + (screen.kpis.length || "") + " KPIs";
   } else if (type.includes("Kanban")) {
     desc = "Vue Kanban";
   }
   if (desc) {
     rawWireframes.push({
-      screen: screen.screen || "", section: screen.section || "",
+      screen: screen.screen, section: screen.section,
       mockupFormat: "text", mockup: desc,
-      description: screen.sectionDescription || "", elements: [], componentMapping: []
+      description: screen.description, elements: [], componentMapping: []
     });
   }
 }

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

@@ -8,7 +8,7 @@ model: opus
 
 ## YOUR TASK
 
-Run 6 blocking validations on the generated HTML file and display the completion summary.
+Run 9 blocking validations on the generated HTML file and display the completion summary.
 
 ---
 
@@ -57,18 +57,54 @@ FOR each module in FEATURE_DATA.modules:
 ```
 FOR each module in FEATURE_DATA.modules:
   Read source: docs/{app}/{module.code}/business-analyse/v{version}/usecases.json
-  sourceUCCount = count of useCases in source file
+  sourceUCCount = count of useCases OR usecases in source file
   htmlUCCount = count in FEATURE_DATA.moduleSpecs[module.code].useCases
   IF sourceUCCount > 0 AND htmlUCCount === 0:
     BLOCKING_ERROR("Module {module.code}: 0 useCases in HTML but {sourceUCCount} in source")
 
   Read source: docs/{app}/{module.code}/business-analyse/v{version}/rules.json
-  sourceBRCount = count of rules in source file
+  sourceBRCount = count of rules OR businessRules in source file
   htmlBRCount = count in FEATURE_DATA.moduleSpecs[module.code].businessRules
   IF sourceBRCount > 0 AND htmlBRCount === 0:
     BLOCKING_ERROR("Module {module.code}: 0 businessRules in HTML but {sourceBRCount} in source")
 ```
 
+**Check 7 — Screens/mockups populated (prevents ASCII-only regression):**
+```
+FOR each module in FEATURE_DATA.modules:
+  Read source: docs/{app}/{module.code}/business-analyse/v{version}/screens.json
+  sourceScreenCount = count of "screens" array OR "sections" array in source file
+  htmlScreenResources = sum of resources[].length across moduleSpecs[module.code].screens[]
+  IF sourceScreenCount > 0 AND htmlScreenResources === 0:
+    BLOCKING_ERROR("Module {module.code}: 0 screen resources but source has {sourceScreenCount}")
+```
+
+**Check 8 — No serialization bugs ([object Object]):**
+```
+Search ba-interactive.html for the literal string "[object Object]"
+IF found:
+  BLOCKING_ERROR("Serialization bug: [object Object] found in HTML — steps[] or other arrays contain objects instead of strings")
+  Identify which module/field contains the bug and fix the mapping
+```
+
+**Check 9 — No runtime crash (CRITICAL — validates page won't be blank):**
+```
+Open ba-interactive.html and search for the FEATURE_DATA JSON block.
+Verify these MANDATORY top-level fields exist:
+  - "modules": [...]          (array, can be empty)
+  - "dependencies": [...]     (array, can be empty)
+  - "cadrage": {...}          (object with stakeholders[], scope{})
+  - "moduleSpecs": {...}      (object, one key per module)
+  - "consolidation": {...}    (object)
+
+IF "dependencies" is missing from FEATURE_DATA:
+  Add: "dependencies": [] to the FEATURE_DATA object in the HTML
+  (This is the #1 cause of blank HTML pages — TypeError on data.dependencies.length crashes all JS)
+
+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.
 
 ---