@atlashub/smartstack-cli 3.34.0 → 3.36.0

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

@@ -41,14 +41,31 @@ Phase 5: PERIMETRE         → Bound scope with roles, coverage matrix (sections
 
 ---
 
+## PROJECT vs APPLICATION MODE
+
+> **When `workflow_mode = "project"` (detected in step-00 from prompt structure):**
+> The cadrage operates at the **PROJECT level**, not at a single application level.
+> - Phase 1-3: Gather requirements for the ENTIRE project (all applications combined)
+> - Phase 4: ANTICIPATION analyzes cross-application shared modules and suggests extracting them as dedicated applications
+> - Phase 5: Coverage matrix maps requirements to APPLICATIONS first, then modules within each application
+> - `candidate_applications` from step-00 are used as starting structure (can be modified during cadrage)
+>
+> **When `workflow_mode = "application"` (single-app):**
+> The cadrage operates at the application level as before.
+
 ## PHASE 1: ECOUTE (Listen)
 
 ### 1. Read Current State
 
 ```
-ba-reader.findFeature({feature_id})
-→ Read metadata: application, language, workflow.mode, useCase
-→ Read cadrage section (if resuming)
+IF workflow_mode === "project":
+  ba-reader.findProjectFeature({project_id})
+  → Read metadata: projectName, language, candidateApplications
+  → Read cadrage section (if resuming)
+ELSE:
+  ba-reader.findFeature({feature_id})
+  → Read metadata: application, language, workflow.mode, useCase
+  → Read cadrage section (if resuming)
 ```
 
 IF cadrage already completed (status = "framed"):
@@ -507,6 +524,91 @@ options:
 
 6. Accepted suggestions enrich `coverageMatrix` and `globalScope`.
 
+### 5b. Cross-Application Shared Module Detection (PROJECT MODE ONLY)
+
+> **When `workflow_mode = "project"`, analyze candidate applications for shared modules.**
+> A module that appears in 2+ applications should be extracted as a dedicated transversal application.
+
+**This section is SKIPPED if `workflow_mode !== "project"`.**
+
+**Process:**
+
+1. Build module inventory per candidate application:
+
+```javascript
+// From candidateApplications (step-00) + enriched by cadrage phases 1-4
+const modulesByApp = {};
+for (const app of candidate_applications) {
+  modulesByApp[app.name] = app.modules;  // e.g., { "RH": ["Employes", "Conges", "Temps"], "Projet": ["Projets", "Temps"] }
+}
+```
+
+2. Detect modules appearing in 2+ applications:
+
+```javascript
+const allModules = Object.values(modulesByApp).flat();
+const moduleCounts = {};
+for (const mod of allModules) {
+  const normalized = normalizeModuleName(mod);  // "Temps", "Saisie du temps", "Time Tracking" → same concept
+  moduleCounts[normalized] = (moduleCounts[normalized] || 0) + 1;
+}
+const sharedModules = Object.entries(moduleCounts)
+  .filter(([_, count]) => count >= 2)
+  .map(([name, count]) => ({ name, appearsIn: count, applications: findAppsContaining(name) }));
+```
+
+3. IF shared modules found, propose extraction:
+
+```
+{language == "fr"
+  ? "### Modules partagés détectés\n\nCertains modules apparaissent dans plusieurs applications. Les extraire en application(s) dédiée(s) améliore la réutilisabilité et évite la duplication :"
+  : "### Shared modules detected\n\nSome modules appear in multiple applications. Extracting them as dedicated application(s) improves reusability and avoids duplication:"}
+
+| Module | Présent dans | Suggestion |
+|--------|-------------|-----------|
+{for each shared: name | apps.join(", ") | "Extraire en application '{name}'" }
+
+{language == "fr"
+  ? "**Exemple :** Si 'Gestion du temps' est dans RH et Projet, créer une application 'Temps' dédiée que les deux autres consomment."
+  : "**Example:** If 'Time Management' is in HR and Project, create a dedicated 'Time' application that the other two consume."}
+```
+
+Ask via AskUserQuestion:
+```
+question: "{language == 'fr' ? 'Souhaitez-vous extraire les modules partagés en application(s) dédiée(s) ?' : 'Do you want to extract shared modules as dedicated application(s)?'}"
+header: "Extraction"
+options:
+  - label: "{language == 'fr' ? 'Oui, extraire' : 'Yes, extract'}"
+    description: "{language == 'fr' ? 'Créer {sharedModules.length} application(s) transversale(s) supplémentaire(s)' : 'Create {sharedModules.length} additional cross-cutting application(s)'}"
+  - label: "{language == 'fr' ? 'Non, garder en l\'état' : 'No, keep as-is'}"
+    description: "{language == 'fr' ? 'Chaque application garde sa propre version du module' : 'Each application keeps its own version of the module'}"
+```
+
+**IF "Oui, extraire":**
+```javascript
+for (const shared of sharedModules) {
+  // Create new candidate application
+  candidate_applications.push({
+    name: shared.name,
+    description: `Application transversale pour ${shared.name}`,
+    modules: [shared.name],
+    context: "business",
+    isTransversal: true,
+    consumedBy: shared.applications
+  });
+
+  // Remove the shared module from original applications
+  for (const appName of shared.applications) {
+    const app = candidate_applications.find(a => a.name === appName);
+    app.modules = app.modules.filter(m => normalizeModuleName(m) !== shared.name);
+    app.dependencies = app.dependencies || [];
+    app.dependencies.push({ target: shared.name, type: "data-dependency" });
+  }
+}
+```
+
+Update `candidate_applications` in the project feature.json.
+
 ---
 
 ## PHASE 5: PERIMETRE (Bound Scope)
@@ -720,9 +822,25 @@ ba-writer.enrichSection({
 ba-writer.updateStatus({feature_id}, "framed")
 ```
 
-### 9. Multi-Application Detection (NEW)
+### 9. Multi-Application Detection
 
 > **Analyze whether the project spans multiple independent applications.**
+> **SKIP this section entirely if `workflow_mode = "project"`** — multi-app was already detected in step-00
+> and cross-app analysis was done in section 5b above.
+
+**IF `workflow_mode === "project"`:**
+→ SKIP section 9 entirely. Candidate applications are already identified and enriched.
+→ Write cadrage data to project-level feature.json:
+```
+ba-writer.enrichSection({
+  projectId: {project_id},
+  section: "cadrage",
+  data: {cadrage data collected in phases 1-5 above}
+})
+```
+→ Continue to section 10 (summary).
+
+**IF `workflow_mode === "application"` (single-app mode):**
 
 After coverage matrix is validated, check if the identified functional domains suggest multiple applications:
 
@@ -763,15 +881,15 @@ ba-writer.createProjectFeature({
   metadata: {
     projectName: {project_name derived from feature_description},
     language: {language},
-    featureDescription: {feature_description}
+    featureDescription: {feature_description},
+    candidateApplications: [{detected candidates}]
   },
   cadrage: {cadrage data already collected in this step}
 })
 ```
-2. Set `workflow.mode = "project"` in project feature.json
+2. Set `workflow_mode = "project"` and `project_id = PROJ-NNN`
 3. Load `questionnaire/00b-project.md` for additional project-level questions
-4. Load `steps/step-01b-applications.md` for application decomposition
-5. **STOP — DO NOT load step-02**
+4. Continue to section 10 and then step-01b
 
 **IF "Single application":**
 → Continue to step 10 (display summary) and step-02 as usual.
@@ -807,5 +925,6 @@ ba-writer.createProjectFeature({
 
 ## NEXT STEP
 
-**IF workflow.mode === "project":** Load: `./step-01b-applications.md`
-**ELSE:** Load: `./step-02-decomposition.md`
+Load: `./step-01b-applications.md`
+
+> step-01b handles both single-app (lightweight identity confirmation) and multi-app (full application decomposition).

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

@@ -1,34 +1,201 @@
 ---
 name: step-01b-applications
-description: Application decomposition - identify and define multiple applications within a project
+description: Application identity confirmation (single-app) or full application decomposition (multi-app)
 model: opus
 next_step: steps/step-02-decomposition.md
 ---
 
 > **Context files:** `_shared.md`
 
-# Step 1b: Application Decomposition
+# Step 1b: Application Identity & Decomposition
 
 ## MANDATORY EXECUTION RULES
 
 - ALWAYS use ULTRATHINK mode
-- This step is ONLY loaded when `workflow.mode === "project"` (multi-application mode)
 - ALL communication in `{language}`
-- This step takes the candidate applications identified during cadrage and formalizes them
+- This step ALWAYS runs. It has two modes:
+  - **Single-app mode** (`workflow.mode !== "project"`): Lightweight application identity confirmation — name, code, context, route, icon, table prefix validation, application roles recap. Creates the `seedDataCore.navigationApplications` entry.
+  - **Multi-app mode** (`workflow.mode === "project"`): Full application decomposition as defined in sections 1-7 below.
 
-## YOUR TASK
+---
 
-For each candidate application identified during step-01 cadrage, define its identity, context, roles, and scope. Establish inter-application dependencies and create per-application feature.json files.
+## MODE GATE
+
+```
+IF workflow.mode === "project":
+  → Execute FULL multi-app flow (sections 1-7 below)
+ELSE:
+  → Execute LIGHTWEIGHT single-app identity (sections 0a-0f below)
+```
 
 ---
 
+## SINGLE-APP PATH (sections 0a-0f)
+
+> This path runs when `workflow.mode !== "project"` (single application, most common case).
+> It confirms the application-level identity (Level 2 of the navigation hierarchy) before proceeding to module decomposition.
+
+### 0a. Read Application Context
+
+```
+appFeature = ba-reader.findFeature({feature_id})
+→ Read metadata: application, context, tablePrefix
+→ Read cadrage: applicationRoles, coverageMatrix, globalScope
+→ Read cadrage.codebaseContext (if exists)
+```
+
+### 0b. Derive Application Identity
+
+From the cadrage data, derive the formal application identity:
+
+```javascript
+applicationCode = toPascalCase(metadata.application)  // e.g., "HumanResources"
+applicationLabel = metadata.application                // e.g., "Ressources Humaines" (human-readable)
+context = metadata.context                             // "business" (validated in step-00)
+applicationRoute = `/${context}/${toKebabCase(applicationCode)}`  // e.g., "/business/human-resources"
+applicationIcon = suggestIconFromDomain(applicationCode) // e.g., "users" for HR, "shopping-cart" for Sales
+tablePrefix = metadata.tablePrefix                     // e.g., "rh_" (already defined in step-01)
+sort = 1                                               // First (and only) application
+```
+
+**Icon suggestion heuristics:**
+| Domain pattern | Suggested icon |
+|---------------|---------------|
+| HR, Employee, Staff, Personnel | `users` |
+| Sales, Commerce, Revenue | `shopping-cart` |
+| Finance, Accounting, Budget | `wallet` |
+| Inventory, Stock, Warehouse | `package` |
+| CRM, Customer, Client | `contact` |
+| Project, Task, Planning | `clipboard-list` |
+| Support, Ticket, Help | `headphones` |
+| Reporting, Analytics, Dashboard | `bar-chart-2` |
+| Other | `layout-grid` |
+
+### 0c. Confirm Application Identity (BLOCKING)
+
+Display the application identity:
+
+```
+{language == "fr"
+  ? "## Identité de l'application\n\nVoici l'identité de votre application dans la hiérarchie de navigation SmartStack :"
+  : "## Application Identity\n\nHere is your application's identity in the SmartStack navigation hierarchy:"}
+
+| {language == "fr" ? "Niveau" : "Level"} | {language == "fr" ? "Valeur" : "Value"} |
+|-------|-------|
+| Context | `{context}` |
+| Application Code | `{applicationCode}` |
+| Application Name | `{applicationLabel}` |
+| Route | `{applicationRoute}` |
+| Icon | `{applicationIcon}` |
+| Table Prefix | `{tablePrefix}` |
+| Sort Order | `{sort}` |
+
+{language == "fr"
+  ? "### Rôles applicatifs\n\nCes rôles seront hérités par tous les modules :"
+  : "### Application Roles\n\nThese roles will be inherited by all modules:"}
+
+| Role | Level | Permission Pattern |
+|------|-------|--------------------|
+{for each role in cadrage.applicationRoles: role.role | role.level | {context}.{kebab(applicationCode)}.* }
+```
+
+Ask via AskUserQuestion:
+```
+question: "{language == 'fr' ? 'Cette identité d\'application est-elle correcte ?' : 'Is this application identity correct?'}"
+header: "Application"
+options:
+  - label: "{language == 'fr' ? 'Oui, parfait' : 'Yes, perfect'}"
+    description: "{language == 'fr' ? 'Code, route, icône et rôles sont corrects' : 'Code, route, icon and roles are correct'}"
+  - label: "{language == 'fr' ? 'Modifier' : 'Modify'}"
+    description: "{language == 'fr' ? 'Changer le code, la route, l\'icône ou les rôles' : 'Change code, route, icon or roles'}"
+```
+
+**IF "Modify":**
+→ Ask which field(s) to change via follow-up AskUserQuestion
+→ Apply changes
+→ Re-display and re-confirm (loop until validated)
+
+### 0d. Build Application SeedData Entries
+
+Create the `navigationApplications` entry (Level 2 hierarchy entry):
+
+```json
+{
+  "navigationApplications": [
+    {
+      "code": "{applicationCode}",
+      "label": "{applicationLabel}",
+      "icon": "{applicationIcon}",
+      "route": "{applicationRoute}",
+      "sort": 1
+    }
+  ]
+}
+```
+
+Create the `applicationRoles` entries (from cadrage.applicationRoles):
+
+```json
+{
+  "applicationRoles": [
+    { "code": "admin", "name": "{applicationLabel} Admin", "permissions": "*" },
+    { "code": "manager", "name": "{applicationLabel} Manager", "permissions": "CRU" },
+    { "code": "contributor", "name": "{applicationLabel} Contributor", "permissions": "CR" },
+    { "code": "viewer", "name": "{applicationLabel} Viewer", "permissions": "R" }
+  ]
+}
+```
+
+> **NOTE:** The roles map from `cadrage.applicationRoles` levels. If the cadrage defined custom roles beyond the standard 4, include them here too.
+
+### 0e. Write Application Identity to Feature.json
+
+```
+ba-writer.enrichSection({
+  featureId: {feature_id},
+  section: "metadata",
+  data: {
+    applicationCode: "{applicationCode}",
+    applicationRoute: "{applicationRoute}",
+    applicationIcon: "{applicationIcon}"
+  }
+})
+```
+
+> **NOTE:** The full `seedDataCore` arrays (`navigationApplications`, `applicationRoles`) will be written in step-03c when compiling the first module's specification. Here we only persist the identity fields in metadata so they are available to step-02 and step-03.
+
+### 0f. Summary and Continue
+
+```
+{language == "fr"
+  ? "✅ Application **{applicationCode}** identifiée\n\n- Route : `{applicationRoute}`\n- Icône : `{applicationIcon}`\n- Préfixe : `{tablePrefix}`\n- Rôles : {roleCount} rôles applicatifs définis\n\n→ Prochaine étape : décomposition en modules"
+  : "✅ Application **{applicationCode}** identified\n\n- Route: `{applicationRoute}`\n- Icon: `{applicationIcon}`\n- Prefix: `{tablePrefix}`\n- Roles: {roleCount} application roles defined\n\n→ Next step: module decomposition"}
+```
+
+→ Load `steps/step-02-decomposition.md`
+
+---
+
+## MULTI-APP PATH (sections 1-7)
+
+> This path runs when `workflow.mode === "project"` (multi-application mode).
+> It takes the candidate applications identified during cadrage and formalizes them.
+
 ### 1. Load Project Context
 
 ```
 projectFeature = ba-reader.findProjectFeature()
-candidateApps = projectFeature.cadrage.coverageMatrix grouped by domain
 globalRoles = projectFeature.cadrage.globalRoles (if defined)
 globalScope = projectFeature.cadrage.globalScope
+
+// Candidate applications: PRE-IDENTIFIED from step-00 prompt analysis + enriched by step-01 cadrage
+candidateApps = projectFeature.metadata.candidateApplications
+// These candidates already have: name, description, modules[], context, dependencies[]
+// They may also include transversal apps extracted from shared modules (step-01 section 5b)
+
+IF candidateApps is null or empty:
+  // Fallback: derive from coverage matrix (legacy path)
+  candidateApps = projectFeature.cadrage.coverageMatrix grouped by domain
 ```
 
 ### 2. Application Identity (per candidate)
@@ -154,14 +321,14 @@ options:
   - label: "{language == 'fr' ? 'Modifier' : 'Modify'}"
     description: "{language == 'fr' ? 'Ajouter, supprimer ou modifier des applications' : 'Add, remove, or modify applications'}"
   - label: "{language == 'fr' ? 'Fusionner en une seule' : 'Merge into one'}"
-    description: "{language == 'fr' ? 'Finalement, c'est une seule application avec plusieurs modules' : 'Actually, this is one application with multiple modules'}"
+    description: "{language == 'fr' ? 'Finalement, c\'est une seule application avec plusieurs modules' : 'Actually, this is one application with multiple modules'}"
 ```
 
 **IF "Merge into one":**
 → Convert back to single-application mode
 → Delete project-level feature.json
 → Create application-level feature.json with all scope items
-→ Load `steps/step-02-decomposition.md` directly
+→ Execute single-app path (sections 0a-0f above)
 
 ### 5. Create Per-Application Feature.json Files
 
@@ -175,6 +342,9 @@ ba-writer.createApplicationFeature({
   status: "draft",
   metadata: {
     application: {app.code},
+    applicationCode: {toPascalCase(app.code)},
+    applicationRoute: {`/${app.context}/${toKebabCase(app.code)}`},
+    applicationIcon: {app.icon},
     context: {app.context},
     language: {language},
     featureDescription: {app.description},
@@ -208,6 +378,7 @@ ba-writer.enrichApplicationRegistry({
       context: {app1.context},
       tablePrefix: {app1.tablePrefix},
       icon: {app1.icon},
+      route: {app1.route},
       description: {app1.description},
       applicationRoles: [{...}],
       scope: { mustHave: [...], shouldHave: [...], couldHave: [...] },
@@ -236,9 +407,9 @@ ba-writer.updateStatus({project_id}, "decomposed")
   ? "### Décomposition en applications terminée\n\n"
   : "### Application decomposition complete\n\n"}
 
-| Application | Contexte | Préfixe | Feature ID |
-|-------------|----------|---------|------------|
-{for each app: name | context | prefix | FEAT-NNN}
+| Application | Contexte | Préfixe | Route | Feature ID |
+|-------------|----------|---------|-------|------------|
+{for each app: name | context | prefix | route | FEAT-NNN}
 
 {language == "fr"
   ? "→ Prochaine étape : décomposition en modules pour **{firstApp}** (application {1}/{total})"
@@ -249,4 +420,4 @@ ba-writer.updateStatus({project_id}, "decomposed")
 
 ## NEXT STEP
 
-Load: `./step-02-decomposition.md` (for the first application in topological order)
+Load: `./step-02-decomposition.md` (for the first application in topological order, or the single application)

package/templates/skills/business-analyse/steps/step-03c-compile.md

@@ -301,11 +301,20 @@ for (const entry of specification.navigation.entries) {
 
 #### 8f. SeedData Core
 
-7 MANDATORY typed arrays — each with structured objects, NOT flat strings or objects.
+9 MANDATORY typed arrays — each with structured objects, NOT flat strings or objects.
 
 > **STRUCTURE CARD: specification.seedDataCore**
 > ```json
 > {
+>   "navigationApplications": [
+>     { "code": "{app}", "label": "{Application Name}", "icon": "{icon}", "route": "/business/{app-kebab}", "sort": 1 }
+>   ],
+>   "applicationRoles": [
+>     { "code": "admin", "name": "{App} Admin", "permissions": "*" },
+>     { "code": "manager", "name": "{App} Manager", "permissions": "CRU" },
+>     { "code": "contributor", "name": "{App} Contributor", "permissions": "CR" },
+>     { "code": "viewer", "name": "{App} Viewer", "permissions": "R" }
+>   ],
 >   "navigationModules": [
 >     { "code": "{module}", "label": "{Module Name}", "icon": "list", "route": "/business/{app}/{module}", "parentCode": "{app}", "sort": 1 }
 >   ],
@@ -339,7 +348,8 @@ for (const entry of specification.navigation.entries) {
 >   ]
 > }
 > ```
-> **MANDATORY:** All 7 arrays must be present. Each element must be an object, NOT a string.
+> **MANDATORY:** All 9 arrays must be present. Each element must be an object, NOT a string.
+> **NOTE:** `navigationApplications` and `applicationRoles` are populated from the application identity confirmed in step-01b. They are written ONCE for the first module processed and remain empty `[]` for subsequent modules.
 > **CRITICAL:** `navigationSections` and `navigationResources` are DERIVED from `specification.sections[]` — use the transform algorithm below (section 8f-bis).
 > **IMPORTANT:** `create` and `edit` are NEVER sections — they are action pages reached via buttons. Do NOT include them in `navigationSections`. Only include actual sidebar sections (list, dashboard, approve, import, etc.) and hidden route sections (detail).
 > **FORBIDDEN:** Do NOT use `navigationModule` (singular string), `permissions` as flat string array, `rolePermissions` as flat object, `permissionsConstants` as comma-separated string.
@@ -388,6 +398,8 @@ ba-writer.enrichSection({
   section: "specification",
   data: {
     seedDataCore: {
+      navigationApplications: [ ... ],            // FROM step-01b identity (only for first module, else [])
+      applicationRoles: [ ... ],                  // FROM cadrage.applicationRoles (only for first module, else [])
       navigationModules: [ ... ],
       navigationSections: navigationSections,     // DERIVED
       navigationResources: navigationResources,   // DERIVED

package/templates/skills/business-analyse/steps/step-03d-validate.md

@@ -73,7 +73,7 @@ Validate the module specification for completeness and consistency, write to fea
 | messages | 4 | `specification.messages.length >= 4` | PASS/FAIL |
 | messageFormat | `message` field present (BLOCKING) | `specification.messages.every(m => m.message)` | PASS/FAIL |
 | lifeCycles | 1 (if entity has status) | `specification.lifeCycles.length >= 1` (if any entity has status/state field) | PASS/FAIL |
-| seedDataCore | 7 arrays present with content | See detailed check below | PASS/FAIL (BLOCKING) |
+| seedDataCore | 9 arrays present with content | See detailed check below | PASS/FAIL (BLOCKING) |
 | apiEndpoints | 1 | `specification.apiEndpoints.length >= 1` | PASS/FAIL |
 | i18nKeys | present | `specification.i18nKeys !== undefined && specification.i18nKeys !== null` | PASS/FAIL |
 | navigationIcons | non-null | `specification.seedDataCore.navigationModules.every(m => m.icon !== null)` | PASS/FAIL |
@@ -81,7 +81,11 @@ Validate the module specification for completeness and consistency, write to fea
 **seedDataCore detailed check (BLOCKING):**
 ```javascript
 const sdc = specification.seedDataCore;
+const currentModuleIndex = metadata.workflow?.currentModuleIndex || 0;
 const checks = [
+  // navigationApplications and applicationRoles: required for first module (index 0), can be empty for subsequent modules
+  { key: "navigationApplications", actual: sdc.navigationApplications?.length || 0, min: currentModuleIndex === 0 ? 1 : 0 },
+  { key: "applicationRoles",      actual: sdc.applicationRoles?.length || 0,       min: currentModuleIndex === 0 ? 1 : 0 },
   { key: "navigationModules",      actual: sdc.navigationModules?.length || 0,      min: 1 },
   { key: "navigationSections",     actual: sdc.navigationSections?.length || 0,     min: 1 },  // EVERY module needs ≥1 section
   { key: "navigationResources",    actual: sdc.navigationResources?.length || 0,    min: 1 },