@atlashub/smartstack-cli 3.2.0 → 3.3.1

package/templates/skills/business-analyse/_suggestions.md

@@ -0,0 +1,34 @@
+# Business Analysis - Suggestions & Context7 (_suggestions.md)
+
+> **Loaded by:** step-01-cadrage, step-04-consolidation
+> **Purpose:** Proactive suggestion patterns and Context7 library references
+
+---
+
+## Proactive Suggestions
+
+After scope definition in step-01, the skill suggests complementary modules/sections:
+
+1. Analyze feature type and scope from questionnaire answers
+2. Load `patterns/suggestion-catalog.md`
+3. Match against catalog patterns
+4. Present suggestions via AskUserQuestion (accept/reject per suggestion)
+5. Store in feature.json.suggestions[]
+
+Accepted suggestions become candidates for future /business-analyse runs.
+
+---
+
+## Context7 (Step 04)
+
+```
+Prompt pattern:
+"use context7 with /facebook/react and /i18next/react-i18next
+ to generate {component} following SmartStack patterns"
+```
+
+Libraries:
+- `/facebook/react` - React 19 patterns
+- `/i18next/react-i18next` - Internationalization
+- `/remix-run/react-router` - React Router v7
+- `/lucide-icons/lucide-react` - Icons

package/templates/skills/business-analyse/questionnaire/06-security.md

@@ -44,7 +44,7 @@
 > - Les rôles identifiés en Q6.1-Q6.4 sont des **ensembles de permissions**, pas des données métier
 > - L'accès est contrôlé par des permissions attribuées aux rôles, pas par des propriétés d'entité
 > - Ne jamais proposer de créer une entité `Role`, `UserRole`, ou un attribut `User.Role`
-> - Le mapping rôle → permissions se fait dans la **Permission Matrix** (step-03-specify)
+> - Le mapping rôle → permissions se fait dans la **Permission Matrix** (step-03a-specify)
 
 ## Elicitation Guide
 

package/templates/skills/business-analyse/questionnaire.md

@@ -1,6 +1,6 @@
 # Elicitation Questionnaire - Business Analysis
 
-> **Usage:** Structured questions for step-01-cadrage and step-03-specify
+> **Usage:** Structured questions for step-01-cadrage and step-03a-specify
 > **Standard:** BABOK v3 - Elicitation Techniques (VibeCoding-focused)
 > **Model:** OPUS with ULTRATHINK
 > **Total:** ~68 targeted questions (dev-relevant only)
@@ -284,7 +284,7 @@
 | Phase | Categories utilisees |
 |-------|---------------------|
 | step-01-cadrage | 00 (si mode application), 01, 02, 03, 14, 15 + conditionnelles (05, 06, 08, 09, 10) |
-| step-03-specify (par module) | 04, 07, 11, 12, 13 (chargees par module) |
+| step-03a-specify (par module) | 04, 07, 11, 12, 13 (chargees par module) |
 
 ### Phase de cadrage
 

package/templates/skills/business-analyse/react/components.md

@@ -1,7 +1,7 @@
 # React Components - Business Analyse Viewer
 
 > **Usage:** React component that renders feature.json directly
-> **Loaded in:** step-05-handoff.md
+> **Loaded in:** step-05b-deploy.md
 > **Data source (module):** `docs/business/{app}/{module}/business-analyse/v{X.Y}/feature.json`
 > **Data source (application):** `docs/business/{app}/business-analyse/v{X.Y}/feature.json`
 > **Related:** `react/application-viewer.md` for application-level view

package/templates/skills/business-analyse/react/schema.md

@@ -1,7 +1,7 @@
 # TypeScript Schema - Feature JSON Types
 
 > **Usage:** TypeScript interfaces aligned with feature-schema.json and application-schema.json
-> **Loaded in:** step-05-handoff.md (for web app rendering)
+> **Loaded in:** step-05b-deploy.md (for web app rendering)
 > **Source (module):** `docs/business/{app}/{module}/business-analyse/v{X.Y}/feature.json`
 > **Source (application):** `docs/business/{app}/business-analyse/v{X.Y}/feature.json`
 

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

@@ -0,0 +1,294 @@
+# HTML Data Mapping Reference (references/html-data-mapping.md)
+
+> **Used by:** step-05b-deploy (section 3: Deploy Interactive HTML Document)
+> **Purpose:** Exact mapping from feature.json to HTML FEATURE_DATA and EMBEDDED_ARTIFACTS objects
+
+---
+
+## FEATURE_DATA Mapping
+
+Build a JSON object following this **exact mapping** from feature.json to the HTML data model:
+
+```javascript
+{
+  metadata: {
+    applicationName: master.metadata.application,       // e.g. "RH"
+    applicationId: master.id,                           // e.g. "FEAT-001"
+    version: master.version,                            // e.g. "1.0"
+    createdAt: master.metadata.createdAt,
+    lastModified: master.metadata.updatedAt
+  },
+  cadrage: {
+    problem: {
+      description: master.cadrage.problem,              // string → problem.description
+      trigger: master.cadrage.trigger,                  // string → problem.trigger
+      impactedPeople: "",                               // not in feature.json, client fills
+      history: "",
+      consequences: ""
+    },
+    current: {
+      tools: master.cadrage.asIs,                       // string → current.tools
+      steps: [],                                        // client can add process steps
+      painPoints: master.cadrage.stakeholders
+        .flatMap(s => s.painPoints || []).join("\n"),    // aggregate all painPoints
+      errors: ""
+    },
+    vision: {
+      changes: master.cadrage.toBe,                     // string → vision.changes
+      results: master.cadrage.acceptanceCriteria
+        .map(ac => ac.criterion).join("\n"),             // AC → results (one per line)
+      successSign: ""
+    },
+    stakeholders: master.cadrage.stakeholders.map(s => ({
+      role: s.role,
+      function: s.function || "",
+      tasks: s.tasks || [],
+      frequency: mapFrequency(s.frequency),             // "Quotidien"→"daily", etc.
+      access: mapAccess(s.involvement),                 // "decision-maker"→"admin", "end-user"→"contributor"
+      frustrations: (s.painPoints || []).join("\n")
+    })),
+    scope: {
+      vital: (master.cadrage.globalScope.mustHave || [])
+        .map(item => ({ name: item, description: "" })),      // string[] → {name,description}[]
+      important: (master.cadrage.globalScope.shouldHave || [])
+        .map(item => ({ name: item, description: "" })),
+      optional: (master.cadrage.globalScope.couldHave || [])
+        .map(item => ({ name: item, description: "" })),
+      excluded: (master.cadrage.globalScope.outOfScope || [])
+        .map(item => ({ name: item, description: "" }))
+    },
+    risks: (master.cadrage.risks || []).map(r => ({
+      description: r.description,
+      probability: r.probability,                       // "high" | "medium" | "low"
+      impact: r.impact,
+      mitigation: r.mitigation || ""
+    })),
+    assumptions: "",
+    success: {
+      definition: (master.cadrage.acceptanceCriteria || [])
+        .map(ac => ac.criterion).join("\n"),
+      metrics: "",
+      timeline: "",
+      minimumConditions: ""
+    }
+  },
+  modules: master.modules.map(m => ({
+    code: m.code,
+    name: m.code,                                       // module code as name
+    description: m.description || "",
+    featureType: m.featureType || "data-centric",
+    priority: m.priority || "must",
+    entities: m.entities || [],
+    status: m.status || "handed-off"
+  })),
+  dependencies: (master.dependencyGraph?.edges || []).map(e => ({
+    from: e.from,
+    to: e.to,
+    description: e.description || ""
+  })),
+  moduleSpecs: {
+    // FOR EACH module: read module feature.json, then map:
+    // [moduleCode]: { useCases, businessRules, entities, permissions, notes, mockupNotes }
+  },
+  consolidation: {
+    interactions: (master.consolidation?.crossModuleInteractions || []).map(i => ({
+      from: i.fromModule,
+      to: i.toModule,
+      description: i.description || ""
+    })),
+    e2eFlows: (master.consolidation?.e2eFlows || []).map(f => ({
+      name: f.name,
+      steps: (f.steps || []).map(s => ({ module: s.module, action: s.action })),
+      actors: (f.steps || []).map(s => s.permission).join(", ")
+    }))
+  },
+  handoff: master.handoff || {}
+}
+```
+
+### Module Specs Mapping
+
+For EACH module in `master.modules[]`:
+
+1. Read the module feature.json at `master.modules[i].featureJsonPath`
+2. Map to `moduleSpecs[moduleCode]`:
+
+```javascript
+moduleSpecs[moduleCode] = {
+  useCases: (moduleFeature.specification?.useCases || []).map(uc => ({
+    name: uc.name,
+    actor: uc.primaryActor,
+    steps: (uc.mainScenario || []).join("\n"),           // array → newline-separated string
+    alternative: (uc.alternativeScenarios || [])
+      .map(a => a.name + ": " + (a.steps || []).join(", ")).join("\n")
+  })),
+  businessRules: (moduleFeature.analysis?.businessRules || []).map(br => ({
+    name: br.name,
+    category: br.category,                              // "validation"|"calculation"|"workflow"|"security"|"data"
+    statement: br.statement,
+    example: (br.examples || []).map(e => e.input + " → " + e.expected).join("; ")
+  })),
+  entities: (moduleFeature.analysis?.entities || []).map(ent => ({
+    name: ent.name,
+    description: ent.description || "",
+    attributes: (ent.attributes || []).map(a => ({
+      name: a.name,
+      description: a.description || ""
+    })),
+    relationships: (ent.relationships || []).map(r =>
+      r.target + " (" + r.type + ") - " + (r.description || "")
+    )
+  })),
+  permissions: buildPermissionKeys(moduleFeature),      // see below
+  notes: "",
+  mockupNotes: ""  // Deprecated: wireframes now embedded separately in EMBEDDED_ARTIFACTS
+}
+```
+
+### Permission Keys Function
+
+The HTML uses `"Role|Action"` format (e.g. `"RH Admin|Consulter"`):
+
+```javascript
+function buildPermissionKeys(moduleFeature) {
+  const keys = [];
+  const matrix = moduleFeature.specification?.permissionMatrix;
+  if (!matrix) return keys;
+  const actionMap = { read: "Consulter", create: "Creer", update: "Modifier",
+                      delete: "Supprimer", validate: "Valider", export: "Exporter",
+                      submit: "Valider", import: "Creer" };
+  (matrix.roleAssignments || []).forEach(ra => {
+    (ra.permissions || []).forEach(permPath => {
+      const action = permPath.split(".").pop();         // last segment = action
+      const uiAction = actionMap[action] || action;
+      keys.push(ra.role + "|" + uiAction);
+    });
+  });
+  return keys;
+}
+```
+
+### Frequency Mapping
+
+```
+"Quotidien" → "daily", "Hebdomadaire" → "weekly", "Mensuel" → "monthly"
+Default: "daily"
+```
+
+### Access Mapping (involvement → access)
+
+```
+"decision-maker" → "admin", "end-user" with manager-like tasks → "manager"
+"end-user" → "contributor", "observer" → "viewer"
+Default: "contributor"
+```
+
+---
+
+## EMBEDDED_ARTIFACTS Mapping
+
+Build a JSON object containing ALL visual artifacts from feature.json:
+
+```javascript
+{
+  wireframes: {
+    // FOR EACH module: extract all wireframes from module feature.json
+    // [moduleCode]: [ {screen, format, content, elements, componentMapping, layout, description} ]
+  },
+  e2eFlows: [
+    // Extract from master consolidation.e2eFlows[]
+    // { name, diagram, steps, actors }
+  ],
+  dependencyGraph: {
+    // Extract from master dependencyGraph
+    // nodes: [ {id, label, type} ], edges: [ {from, to, description} ]
+  }
+}
+```
+
+### Wireframes Mapping
+
+For EACH module in `master.modules[]`:
+
+```javascript
+// Read the module feature.json
+const moduleFeature = readModuleFeature(moduleCode);
+const wireframes = (moduleFeature.specification?.uiWireframes || []).map(wf => ({
+  screen: wf.screen,                                    // e.g. "UM-list", "UM-form"
+  section: wf.section,                                  // e.g. "list", "form"
+  format: wf.mockupFormat || "ascii",                   // "ascii" | "svg"
+  content: wf.mockup,                                   // ASCII art or SVG markup
+  description: wf.description || "",
+  elements: wf.elements || [],                          // ["DataGrid", "FilterBar", ...]
+  actions: wf.actions || [],                            // ["filter", "sort", "create", ...]
+  componentMapping: wf.componentMapping || [],          // [{ wireframeElement, reactComponent }]
+  layout: wf.layout || null,                            // { type, regions: [...] }
+  permissionsRequired: wf.permissionsRequired || []
+}));
+
+// Store in artifacts object
+EMBEDDED_ARTIFACTS.wireframes[moduleCode] = wireframes;
+```
+
+### E2E Flows Mapping
+
+From master consolidation:
+
+```javascript
+EMBEDDED_ARTIFACTS.e2eFlows = (master.consolidation?.e2eFlows || []).map(flow => ({
+  name: flow.name,
+  diagram: generateE2EDiagram(flow),                    // ASCII diagram from flow.steps[]
+  steps: flow.steps || [],                              // [{ module, action, permission }]
+  actors: Array.from(new Set((flow.steps || [])
+    .map(s => s.permission?.split(".")[0])              // Extract role from permission path
+    .filter(Boolean))).join(", "),
+  modules: Array.from(new Set((flow.steps || [])
+    .map(s => s.module))).join(" → ")
+}));
+
+function generateE2EDiagram(flow) {
+  // Generate ASCII diagram from flow.steps[]
+  // Example output:
+  // "Customer ──[read]──→ Order ──[create]──→ Invoice ──[send]──→"
+  // "  (Orders)           (Orders)            (Invoices)"
+  // "  Contributor        Manager             System"
+
+  const stepDiagrams = (flow.steps || []).map(s =>
+    `${s.action}(${s.module})`
+  ).join(" ──→ ");
+
+  return stepDiagrams;
+}
+```
+
+### Dependency Graph Mapping
+
+From master dependencyGraph:
+
+```javascript
+EMBEDDED_ARTIFACTS.dependencyGraph = {
+  nodes: (master.modules || []).map(m => ({
+    id: m.code,
+    label: m.code,
+    type: m.featureType || "data-centric"
+  })),
+  edges: (master.dependencyGraph?.edges || []).map(e => ({
+    from: e.from,
+    to: e.to,
+    description: e.description || ""
+  }))
+};
+```
+
+---
+
+## Usage in step-05b-deploy
+
+1. Serialize the FEATURE_DATA object as JSON (with 2-space indentation for readability)
+2. Serialize the EMBEDDED_ARTIFACTS object as JSON (with 2-space indentation)
+3. Replace `{{FEATURE_DATA}}` with the serialized FEATURE_DATA JSON
+4. Replace `{{EMBEDDED_ARTIFACTS}}` with the serialized EMBEDDED_ARTIFACTS JSON
+5. Replace `{{APPLICATION_NAME}}` → `{application_name}` (still used in `<title>` and header)
+6. Replace `{{APPLICATION_ID}}` → `{feature_id}` (still used in `APP_KEY`)
+7. Replace `{{VERSION}}` → `{version}`
+8. Replace `{{CREATED_AT}}` → `{ISO timestamp}`

package/templates/skills/business-analyse/schemas/feature-schema.json

@@ -43,7 +43,7 @@
     }
   },
 
-  "$comment": "Sub-schema loading guide per BA step: step-00-init → metadata-schema.json | step-01-cadrage → discovery-schema.json (module) OR application-schema.json (master) | step-02-decomposition → application-schema.json (modules[], dependencyGraph) | step-03-specify → analysis-schema.json + specification-schema.json | step-04-consolidation → validation-schema.json + application-schema.json (consolidation) | step-05-handoff → handoff-schema.json",
+  "$comment": "Sub-schema loading guide per BA step: step-00-init → metadata-schema.json | step-01-cadrage → discovery-schema.json (module) OR application-schema.json (master) | step-02-decomposition → application-schema.json (modules[], dependencyGraph) | step-03a-specify → analysis-schema.json | step-03b-compile → specification-schema.json | step-04-consolidation → validation-schema.json + application-schema.json (consolidation) | step-05a-handoff → handoff-schema.json | step-05b-deploy → (artifacts only)",
 
   "$defs": {
     "stepStatus": { "$ref": "shared/common-defs.json#/$defs/stepStatus" },

package/templates/skills/business-analyse/schemas/sections/analysis-schema.json

@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "analysis-schema.json",
   "title": "SmartStack BA - Analysis",
-  "description": "Module-level analysis: objectives, business rules, entities, process flows, integrations, data lifecycle. Enriched by step-03-specify.",
+  "description": "Module-level analysis: objectives, business rules, entities, process flows, integrations, data lifecycle. Enriched by step-03a-specify.",
   "type": "object",
   "properties": {
     "objectives": {

package/templates/skills/business-analyse/schemas/sections/handoff-schema.json

@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "handoff-schema.json",
   "title": "SmartStack BA - Handoff",
-  "description": "Module-level handoff: file mapping (7 categories), BR-to-code mapping, API endpoint summary. Used by step-05-handoff.",
+  "description": "Module-level handoff: file mapping (7 categories), BR-to-code mapping, API endpoint summary. Used by step-05a-handoff.",
   "type": "object",
   "properties": {
     "complexity": { "type": "string", "enum": ["simple", "medium", "complex"] },

package/templates/skills/business-analyse/schemas/sections/specification-schema.json

@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "specification-schema.json",
   "title": "SmartStack BA - Specification",
-  "description": "Module-level specification: actors, use cases, FRs, permissions, navigation, wireframes, dashboards, sections, resources. Enriched by step-03-specify.",
+  "description": "Module-level specification: actors, use cases, FRs, permissions, navigation, wireframes, dashboards, sections, resources. Enriched by step-03b-compile.",
   "type": "object",
   "properties": {
     "actors": {

package/templates/skills/business-analyse/steps/step-00-init.md

@@ -4,6 +4,8 @@ description: Initialize Business Analysis - Parse flags, route use case, create
 next_step: steps/step-01-cadrage.md
 ---
 
+> **Context files:** `_shared.md`
+
 # Step 00: Initialize Business Analysis
 
 Initialize the business analysis workflow by parsing input flags, routing to the appropriate use case handler, and creating the initial feature.json structure.
@@ -294,17 +296,18 @@ Determine the language for analysis and code generation.
 
 **Check config:**
 - Retrieve `businessContext.language` from config
-- Default: "en" (English)
+- Default: "fr" (Francais)
 
 **If not in config OR auto_mode = false:**
 ```
 Ask via AskUserQuestion:
-  question: "Select language for analysis"
-  header: "Language"
+  question: "Quelle langue pour l'analyse ?"
+  header: "Langue"
   options:
+    - label: "Francais (fr)"
     - label: "English (en)"
-    - label: "French (fr)"
-    - label: "Spanish (es)"
+    - label: "Italiano (it)"
+    - label: "Deutsch (de)"
 ```
 
 **Store:**
@@ -372,12 +375,12 @@ Cache file location: `docs/business/{app}/business-analyse/.schema-cache.json`
 ```
 IF EXISTS docs/business/{app}/business-analyse/.schema-cache.json:
   Read cache file
-  IF cache.version == "6.0" (CURRENT SKILL VERSION):
-    Display: "✓ Schemas already deployed (v6.0) - skipping"
+  IF cache.version == "{CLI_VERSION}" (from package.json):
+    Display: "✓ Schemas already deployed ({CLI_VERSION}) - skipping"
     SKIP deployment (trust cache)
     → Go to Step 10
   ELSE:
-    Display: "⚠ Schema version mismatch (cache: {cache.version}, current: 6.0)"
+    Display: "⚠ Schema version mismatch (cache: {cache.version}, current: {CLI_VERSION})"
     Proceed to deployment
 ELSE:
   Display: "Deploying schemas (first time)..."
@@ -418,7 +421,7 @@ docs/business/{app}/business-analyse/schemas/
 
 ```json
 {
-  "version": "6.0",
+  "version": "{CLI_VERSION}",
   "deployedAt": "{ISO timestamp}",
   "schemas": [
     "feature-schema.json",
@@ -612,7 +615,7 @@ NEXT STEP: step-01-analyse ({use_case} mode)
 After showing initialization summary, proceed to `./step-01-cadrage.md`
 
 **Question mode (-q):** EXIT after ba-reader answers the question.
-**Micro mode (-m):** Load `./step-05-handoff.md` directly.
+**Micro mode (-m):** Load `./step-05a-handoff.md` directly.
 **Extract mode (-x):** Load `./step-06-extract.md` with `{json_data}` from parsed JSON file.
 
 **Pass context variables:**

package/templates/skills/business-analyse/steps/step-01-cadrage.md

@@ -5,6 +5,8 @@ model: opus
 next_step: steps/step-02-decomposition.md
 ---
 
+> **Context files:** `_shared.md` | `_elicitation.md` | `_architecture.md` | `_suggestions.md`
+
 # Step 1: Cadrage (Framing)
 
 ## MANDATORY EXECUTION RULES

package/templates/skills/business-analyse/steps/step-02-decomposition.md

@@ -2,9 +2,11 @@
 name: step-02-decomposition
 description: Module decomposition - identify modules, dependency graph, topological sort, client checkpoint
 model: sonnet
-next_step: steps/step-03-specify.md
+next_step: steps/step-03a-specify.md
 ---
 
+> **Context files:** `_shared.md`
+
 # Step 2: Decomposition
 
 ## MANDATORY EXECUTION RULES
@@ -36,7 +38,7 @@ ba-reader.findFeature({feature_id})
 
 IF status already "decomposed":
   Display: "Decomposition already completed. Loading next step."
-  Load: steps/step-03-specify.md
+  Load: steps/step-03a-specify.md
   STOP
 
 ### 2. Module Identification
@@ -290,4 +292,4 @@ When `workflow.mode = "module"` or only 1 scope item identified:
 
 ## NEXT STEP
 
-Load: `./step-03-specify.md`
+Load: `./step-03a-specify.md`