@atlashub/smartstack-cli 3.33.0 → 3.35.0

package/templates/skills/business-analyse/steps/step-04a-collect.md

@@ -279,6 +279,117 @@ Identify shared lookup/reference tables:
 
 ---
 
+### 2f. Cross-Application Validation (Project Mode Only)
+
+> **Only runs when `workflow.mode === "project"`** (multi-application feature).
+> Validates cross-application interactions identified during step-01b.
+
+```
+IF workflow.mode !== "project":
+  SKIP this section entirely
+  → Proceed to section 6 storage
+```
+
+**Process:**
+
+1. **Load project feature.json:**
+   ```
+   projectFeature = ba-reader.findProjectFeature()
+   applications = projectFeature.applications
+   applicationGraph = projectFeature.applicationDependencyGraph
+   ```
+
+2. **Cross-Application Shared Entities:**
+   ```javascript
+   const crossAppSharedEntities = [];
+   for (const app1 of applications) {
+     for (const app2 of applications) {
+       if (app1.code === app2.code) continue;
+       for (const mod1 of app1.modules) {
+         for (const mod2 of app2.modules) {
+           // Detect entity name overlap or FK references across apps
+           const shared = findSharedEntities(mod1.entities, mod2.entities);
+           if (shared.length > 0) {
+             crossAppSharedEntities.push({
+               entity: shared[0].name,
+               definedInApp: app1.code,
+               definedInModule: mod1.code,
+               referencedByApp: app2.code,
+               referencedByModule: mod2.code,
+               referenceType: shared[0].type
+             });
+           }
+         }
+       }
+     }
+   }
+   ```
+
+3. **Cross-Application Permission Path Consistency:**
+   ```javascript
+   // Verify permission paths use correct context per application
+   for (const app of applications) {
+     const expectedPrefix = `${app.context}.${toKebabCase(app.code)}`;
+     for (const mod of app.modules) {
+       for (const perm of mod.permissions || []) {
+         if (!perm.path.startsWith(expectedPrefix)) {
+           WARNING(`Permission path mismatch in ${app.code}/${mod.code}: "${perm.path}" should start with "${expectedPrefix}"`);
+         }
+       }
+     }
+   }
+   ```
+
+4. **Cross-Application Role Name Consistency:**
+   ```javascript
+   // Check for role name conflicts across applications
+   const allRoles = {};
+   for (const app of applications) {
+     for (const role of app.applicationRoles || []) {
+       if (allRoles[role.role] && allRoles[role.role].level !== role.level) {
+         WARNING(`Role "${role.role}" has different levels: ${allRoles[role.role].app}=${allRoles[role.role].level} vs ${app.code}=${role.level}`);
+       }
+       allRoles[role.role] = { app: app.code, level: role.level };
+     }
+   }
+   ```
+
+5. **Store Cross-Application Data:**
+   ```javascript
+   ba-writer.enrichSection({
+     featureId: {project_id},
+     section: "consolidation.crossApplicationInteractions",
+     data: crossAppSharedEntities.map(shared => ({
+       fromApplication: shared.definedInApp,
+       fromModule: shared.definedInModule,
+       toApplication: shared.referencedByApp,
+       toModule: shared.referencedByModule,
+       interactionType: shared.referenceType,
+       entity: shared.entity,
+       description: `${shared.entity} defined in ${shared.definedInApp}/${shared.definedInModule}, referenced by ${shared.referencedByApp}/${shared.referencedByModule}`
+     }))
+   });
+   ```
+
+6. **Display Cross-Application Interaction Map:**
+
+   ```
+   ═══════════════════════════════════════════════════════════════
+     CROSS-APPLICATION INTERACTIONS
+   ═══════════════════════════════════════════════════════════════
+
+   | Source App | Source Module | Target App | Target Module | Entity | Type |
+   |------------|-------------|------------|--------------|--------|------|
+   | HR         | Employees   | SelfService | LeaveRequests | Employee | FK |
+
+   Shared entities: {count}
+   Permission paths: {valid_count}/{total_count} consistent
+   Role conflicts: {conflict_count}
+   ═══════════════════════════════════════════════════════════════
+   ```
+
+---
+
 ## SINGLE-MODULE MODE
 
 When only 1 module:

package/templates/skills/business-analyse/steps/step-05a-handoff.md

@@ -32,8 +32,20 @@ Build the development handoff data: verify consolidation, choose implementation
 Use ba-reader to locate the feature and verify consolidation status:
 
 ```
-ba-reader.findFeature({feature_id})
-→ Check status = "consolidated"
+// Determine feature source based on workflow mode
+IF workflow.mode === "project":
+  projectFeature = ba-reader.findProjectFeature()
+  // Verify ALL applications are specified
+  FOR each app in projectFeature.applications:
+    appFeature = ba-reader.findFeature(app.featureJsonPath)
+    IF appFeature.status !== "consolidated":
+      BLOCKING ERROR: "Application {app.code} not consolidated (status: {appFeature.status})"
+      → Return to step-04a-collect.md
+  // Use project-level feature for overall consolidation
+  feature = projectFeature
+ELSE:
+  ba-reader.findFeature({feature_id})
+  → Check status = "consolidated"
 ```
 
 **IF** status ≠ "consolidated" → **STOP**. Return to step-04a-collect.md.
@@ -42,18 +54,22 @@ Display validation summary:
 
 ```
 ✓ Consolidation: APPROVED
+✓ Applications: {app_count} (project mode only)
 ✓ Modules: {count} specified and validated
 ✓ Cross-module: interactions mapped
+✓ Cross-application: interactions mapped (project mode only)
 ✓ Permissions: coherent
 → Proceeding to handoff...
 ```
 
 Include:
-- Number of modules
+- Number of applications (project mode only)
+- Number of modules across all applications
 - Number of entities across all modules
 - Number of use cases across all modules
 - Number of business rules across all modules
 - Cross-module interaction count
+- Cross-application interaction count (project mode only)
 
 ---
 
@@ -101,9 +117,9 @@ See [references/cache-warming-strategy.md](../references/cache-warming-strategy.
 
 ---
 
-### 2. Implementation Strategy Choice (Multi-Module)
+### 2. Implementation Strategy Choice (Multi-Module/Multi-App)
 
-**IF** more than 1 module defined in feature.json:
+**IF** more than 1 module defined in feature.json (or project mode with multiple applications):
 
 Ask via AskUserQuestion:
 
@@ -117,8 +133,12 @@ options:
     description: "Implémenter toutes les entités, puis tous les services, puis tous les contrôleurs, etc. Plus de parallélisation possible mais plus complexe."
   - label: "Hybride"
     description: "Modules fondation en premier (couche par couche), puis modules dépendants (module par module)"
+  - label: "Application par application (Recommandé multi-app)"
+    description: "Implémenter chaque application complètement avant de passer à la suivante. Suit l'ordre topologique inter-applications."
 ```
 
+> **Note:** "Application par application" only appears for project mode with 2+ applications.
+
 Store the chosen strategy in `handoff.implementationStrategy`.
 
 **IF** only 1 module → default to "Module par module" (no choice needed).
@@ -335,6 +355,31 @@ Generate `.ralph/prd-CrossModule.json` with:
 
 Add to progress.txt after all module tasks.
 
+### 6d. Cross-Application PRD (Project Mode Only)
+
+> **Only generated when `workflow.mode === "project"`.**
+> Contains cross-application integration tests and shared entity validation.
+
+```json
+{
+  "$version": "3.0.0",
+  "implementation": {
+    "filesToCreate": {
+      "tests": [
+        { "path": "src/Tests/Integration/CrossApplication/SharedEntityValidationTests.cs", "type": "IntegrationTests", "module": "CrossApplication" },
+        { "path": "src/Tests/Integration/CrossApplication/CrossAppPermissionTests.cs", "type": "SecurityTests", "module": "CrossApplication" },
+        { "path": "src/Tests/Integration/CrossApplication/CrossAppE2EFlowTests.cs", "type": "E2ETests", "module": "CrossApplication" }
+      ]
+    }
+  }
+}
+```
+
+Write to: `.ralph/prd-CrossApplication.json`
+
+> This PRD is generated IN ADDITION to the per-module cross-module PRD.
+> It validates interactions between applications, not just between modules within the same application.
+
 ---
 
 ### 7. Write Handoff to Feature.json
@@ -434,53 +479,119 @@ const lang = master.metadata.language || "fr";
 
 const seedDataCore = {
   // Application-level navigation (MANDATORY — one entry per application)
-  navigationApplications: [{
-    code: appCode.toLowerCase(),
-    name: appCode,
-    labels: {
-      fr: lang === "fr" ? (master.cadrage?.applicationName || appLabel) : appLabel,
-      en: lang === "en" ? (master.cadrage?.applicationName || appLabel) : appLabel,
-      it: appLabel,
-      de: appLabel
-    },
-    description: {
-      fr: lang === "fr" ? appDesc : `Gestion ${appLabel}`,
-      en: lang === "en" ? appDesc : `${appLabel} management`,
-      it: `Gestione ${appLabel}`,
-      de: `${appLabel} Verwaltung`
-    },
-    icon: inferIconFromApplication(master) || "layout-grid",
-    iconType: "lucide",
-    context: contextCode,
-    route: `/${contextCode}/${toKebabCase(appCode)}`,
-    displayOrder: 1
-  }],
-
-  navigationModules: master.modules.map((m, i) => ({
-    code: m.code,
-    label: m.name || m.code,
-    description: m.description,
-    icon: inferIconFromModule(m) || "folder",  // MUST be non-null — use sensible default
-    iconType: "lucide",
-    route: `/${contextCode}/${toKebabCase(appCode)}/${toKebabCase(m.code)}`,
-    displayOrder: (i + 1) * 10
-  })),
-
-  navigationSections: master.modules.flatMap(m =>
-    (m.anticipatedSections || []).map((s, j) => ({
-      moduleCode: m.code,
-      code: s.code,
-      label: s.description?.split(':')[0] || s.code,
-      description: s.description || "",
-      route: s.code === "list"
-        ? `/${contextCode}/${toKebabCase(appCode)}/${toKebabCase(m.code)}`
-        : s.code === "detail"
-          ? `/${contextCode}/${toKebabCase(appCode)}/${toKebabCase(m.code)}/:id`
-          : `/${contextCode}/${toKebabCase(appCode)}/${toKebabCase(m.code)}/${toKebabCase(s.code)}`,
-      displayOrder: (j + 1) * 10,
-      navigation: s.code === "detail" ? "hidden" : "visible"
-    }))
-  ),
+  // PROJECT MODE: Generate one entry per application from project feature.json
+  // SINGLE-APP MODE: Generate one entry from master feature.json
+  navigationApplications: (() => {
+    if (workflow.mode === "project") {
+      // Multi-app: one navigation entry per application
+      return projectFeature.applications.map((app, idx) => {
+        const appLabel = toHumanReadable(app.code);
+        const appContext = app.context || "business";
+        return {
+          code: app.code.toLowerCase(),
+          name: app.code,
+          labels: {
+            fr: lang === "fr" ? (app.name || appLabel) : appLabel,
+            en: lang === "en" ? (app.name || appLabel) : appLabel,
+            it: appLabel,
+            de: appLabel
+          },
+          description: {
+            fr: lang === "fr" ? (app.description || `Gestion ${appLabel}`) : `Gestion ${appLabel}`,
+            en: lang === "en" ? (app.description || `${appLabel} management`) : `${appLabel} management`,
+            it: `Gestione ${appLabel}`,
+            de: `${appLabel} Verwaltung`
+          },
+          icon: app.icon || inferIconFromApplication({ metadata: { application: app.code } }) || "layout-grid",
+          iconType: "lucide",
+          context: appContext,
+          route: `/${appContext}/${toKebabCase(app.code)}`,
+          displayOrder: (idx + 1) * 10
+        };
+      });
+    } else {
+      // Single-app: one navigation entry
+      return [{
+        code: appCode.toLowerCase(),
+        name: appCode,
+        labels: {
+          fr: lang === "fr" ? (master.cadrage?.applicationName || appLabel) : appLabel,
+          en: lang === "en" ? (master.cadrage?.applicationName || appLabel) : appLabel,
+          it: appLabel,
+          de: appLabel
+        },
+        description: {
+          fr: lang === "fr" ? appDesc : `Gestion ${appLabel}`,
+          en: lang === "en" ? appDesc : `${appLabel} management`,
+          it: `Gestione ${appLabel}`,
+          de: `${appLabel} Verwaltung`
+        },
+        icon: inferIconFromApplication(master) || "layout-grid",
+        iconType: "lucide",
+        context: contextCode,
+        route: `/${contextCode}/${toKebabCase(appCode)}`,
+        displayOrder: 1
+      }];
+    }
+  })(),
+
+  // PROJECT MODE: Flatten modules from ALL applications
+  // SINGLE-APP MODE: Use master.modules directly
+  navigationModules: (() => {
+    if (workflow.mode === "project") {
+      let order = 0;
+      return projectFeature.applications.flatMap(app => {
+        const appContext = app.context || "business";
+        return (app.modules || []).map(m => ({
+          code: m.code,
+          applicationCode: app.code,
+          label: m.name || m.code,
+          description: m.description,
+          icon: inferIconFromModule(m) || "folder",
+          iconType: "lucide",
+          route: `/${appContext}/${toKebabCase(app.code)}/${toKebabCase(m.code)}`,
+          displayOrder: (++order) * 10
+        }));
+      });
+    } else {
+      return master.modules.map((m, i) => ({
+        code: m.code,
+        label: m.name || m.code,
+        description: m.description,
+        icon: inferIconFromModule(m) || "folder",
+        iconType: "lucide",
+        route: `/${contextCode}/${toKebabCase(appCode)}/${toKebabCase(m.code)}`,
+        displayOrder: (i + 1) * 10
+      }));
+    }
+  })(),
+
+  navigationSections: (() => {
+    const buildSections = (modules, appContextCode, appCode) =>
+      modules.flatMap(m =>
+        (m.anticipatedSections || []).map((s, j) => ({
+          moduleCode: m.code,
+          code: s.code,
+          label: s.description?.split(':')[0] || s.code,
+          description: s.description || "",
+          route: s.code === "list"
+            ? `/${appContextCode}/${toKebabCase(appCode)}/${toKebabCase(m.code)}`
+            : s.code === "detail"
+              ? `/${appContextCode}/${toKebabCase(appCode)}/${toKebabCase(m.code)}/:id`
+              : `/${appContextCode}/${toKebabCase(appCode)}/${toKebabCase(m.code)}/${toKebabCase(s.code)}`,
+          displayOrder: (j + 1) * 10,
+          navigation: s.code === "detail" ? "hidden" : "visible"
+        }))
+      );
+
+    if (workflow.mode === "project") {
+      return projectFeature.applications.flatMap(app =>
+        buildSections(app.modules || [], app.context || "business", app.code)
+      );
+    } else {
+      return buildSections(master.modules, contextCode, appCode);
+    }
+  })(),
 
   navigationResources: master.cadrage.coverageMatrix
     .filter(cm => cm.module && cm.anticipatedResources?.length > 0)
@@ -504,37 +615,73 @@ const seedDataCore = {
     }));
   }),
 
-  permissions: master.modules.flatMap(m => {
-    const basePath = `business.${master.metadata.application.toLowerCase()}.${m.code.toLowerCase()}`;
-    const actions = ['read', 'create', 'update', 'delete'];
-    return [
-      { path: `${basePath}.*`, action: '*', description: `Full ${m.name || m.code} access` },
-      ...actions.map(action => ({
-        path: `${basePath}.${action}`,
-        action: action,
-        description: `${action.charAt(0).toUpperCase() + action.slice(1)} ${m.name || m.code}`
-      }))
-    ];
-  }),
-
-  rolePermissions: master.cadrage.applicationRoles.map(role => ({
-    role: role.role,
-    level: role.level,
-    permissions: master.modules.map(m => `business.${master.metadata.application.toLowerCase()}.${m.code.toLowerCase()}.${
-      role.level === 'admin' ? '*' :
-      role.level === 'manager' ? 'read,create,update' :
-      role.level === 'contributor' ? 'read,create' : 'read'
-    }`)
-  })),
-
-  permissionConstants: master.modules.flatMap(m =>
-    ['Read', 'Create', 'Update', 'Delete', 'Validate', 'Export'].map(action => ({
-      module: m.code,
-      action: action,
-      constant: `${master.metadata.application}${m.code}${action}`,
-      path: `business.${master.metadata.application.toLowerCase()}.${m.code.toLowerCase()}.${action.toLowerCase()}`
-    }))
-  )
+  // PROJECT MODE: permissions scoped per application context
+  // SINGLE-APP MODE: all permissions under business.{app}
+  permissions: (() => {
+    const buildPermissions = (modules, appContext, appCode) =>
+      modules.flatMap(m => {
+        const basePath = `${appContext}.${toKebabCase(appCode)}.${toKebabCase(m.code)}`;
+        const actions = ['read', 'create', 'update', 'delete'];
+        return [
+          { path: `${basePath}.*`, action: '*', description: `Full ${m.name || m.code} access` },
+          ...actions.map(action => ({
+            path: `${basePath}.${action}`,
+            action: action,
+            description: `${action.charAt(0).toUpperCase() + action.slice(1)} ${m.name || m.code}`
+          }))
+        ];
+      });
+
+    if (workflow.mode === "project") {
+      return projectFeature.applications.flatMap(app =>
+        buildPermissions(app.modules || [], app.context || "business", app.code)
+      );
+    } else {
+      return buildPermissions(master.modules, contextCode, appCode);
+    }
+  })(),
+
+  rolePermissions: (() => {
+    const buildRolePermissions = (roles, modules, appContext, appCode) =>
+      roles.map(role => ({
+        role: role.role,
+        level: role.level,
+        permissions: modules.map(m => `${appContext}.${toKebabCase(appCode)}.${toKebabCase(m.code)}.${
+          role.level === 'admin' ? '*' :
+          role.level === 'manager' ? 'read,create,update' :
+          role.level === 'contributor' ? 'read,create' : 'read'
+        }`)
+      }));
+
+    if (workflow.mode === "project") {
+      return projectFeature.applications.flatMap(app =>
+        buildRolePermissions(app.applicationRoles || [], app.modules || [], app.context || "business", app.code)
+      );
+    } else {
+      return buildRolePermissions(master.cadrage.applicationRoles, master.modules, contextCode, appCode);
+    }
+  })(),
+
+  permissionConstants: (() => {
+    const buildConstants = (modules, appCode) =>
+      modules.flatMap(m =>
+        ['Read', 'Create', 'Update', 'Delete', 'Validate', 'Export'].map(action => ({
+          module: m.code,
+          application: appCode,
+          action: action,
+          constant: `${appCode}${m.code}${action}`,
+          path: `${contextCode}.${toKebabCase(appCode)}.${toKebabCase(m.code)}.${action.toLowerCase()}`
+        }))
+      );
+
+    if (workflow.mode === "project") {
+      return projectFeature.applications.flatMap(app =>
+        buildConstants(app.modules || [], app.code)
+      );
+    } else {
+      return buildConstants(master.modules, appCode);
+    }
+  })()
 };
 
 // Icon inference for APPLICATION level (NEVER leave as null)
@@ -609,26 +756,72 @@ IF seedDataCore.navigationSections.length === 0:
 #### 7c. Master Handoff (after ALL modules written + seedDataCore generated)
 
 ```
-ba-writer.enrichSection({
-  featureId: {feature_id},
-  section: "handoff",
-  data: {
-    status: "handed-off",
-    complexity: "{simple|medium|complex}",
-    implementationStrategy: "{strategy}",
-    moduleCount: {count},
-    moduleOrder: [...],
-    totalFilesToCreate: {sum across all modules},
-    totalTasks: {sum across all modules},
-    prdStructure: "per-module | consolidated",
-    prdFiles: [
-      { module: "{module1}", path: ".ralph/prd-{module1}.json" },
-      { module: "{module2}", path: ".ralph/prd-{module2}.json" }
-    ],
-    progressTrackerPath: ".ralph/progress.txt",
-    handedOffAt: "{ISO timestamp}"
-  }
-})
+// Write handoff to application-level feature.json (single-app mode)
+// OR to each application feature.json + project feature.json (project mode)
+
+IF workflow.mode === "project":
+  // Write handoff to EACH application feature.json
+  FOR each app in projectFeature.applications:
+    ba-writer.enrichSection({
+      featureId: app.featureJsonPath,
+      section: "handoff",
+      data: {
+        status: "handed-off",
+        complexity: "{app-level complexity}",
+        implementationStrategy: "{strategy}",
+        moduleCount: app.modules.length,
+        moduleOrder: app.modules.map(m => m.code),
+        totalFilesToCreate: {sum across app modules},
+        totalTasks: {sum across app modules},
+        prdFiles: app.modules.map(m => ({ module: m.code, path: `.ralph/prd-${m.code}.json` })),
+        handedOffAt: "{ISO timestamp}"
+      }
+    })
+
+  // Write project-level handoff summary
+  ba-writer.enrichSection({
+    featureId: {project_id},
+    section: "handoff",
+    data: {
+      status: "handed-off",
+      complexity: "{global complexity}",
+      implementationStrategy: "{strategy}",
+      applicationCount: projectFeature.applications.length,
+      applicationOrder: projectFeature.applicationDependencyGraph.topologicalOrder,
+      totalModuleCount: {sum of all app module counts},
+      totalFilesToCreate: {sum across ALL applications and modules},
+      totalTasks: {sum across ALL applications and modules},
+      prdStructure: "per-module",
+      prdFiles: [
+        ...allModulePrdFiles,
+        { module: "CrossModule", path: ".ralph/prd-CrossModule.json" },
+        { module: "CrossApplication", path: ".ralph/prd-CrossApplication.json" }
+      ],
+      progressTrackerPath: ".ralph/progress.txt",
+      handedOffAt: "{ISO timestamp}"
+    }
+  })
+ELSE:
+  ba-writer.enrichSection({
+    featureId: {feature_id},
+    section: "handoff",
+    data: {
+      status: "handed-off",
+      complexity: "{simple|medium|complex}",
+      implementationStrategy: "{strategy}",
+      moduleCount: {count},
+      moduleOrder: [...],
+      totalFilesToCreate: {sum across all modules},
+      totalTasks: {sum across all modules},
+      prdStructure: "per-module | consolidated",
+      prdFiles: [
+        { module: "{module1}", path: ".ralph/prd-{module1}.json" },
+        { module: "{module2}", path: ".ralph/prd-{module2}.json" }
+      ],
+      progressTrackerPath: ".ralph/progress.txt",
+      handedOffAt: "{ISO timestamp}"
+    }
+  })
 ```
 
 #### 7d. Final Verification (BLOCKING)