@atlashub/smartstack-cli 3.32.0 → 3.34.0

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

@@ -0,0 +1,252 @@
+---
+name: step-01b-applications
+description: Application decomposition - identify and define multiple applications within a project
+model: opus
+next_step: steps/step-02-decomposition.md
+---
+
+> **Context files:** `_shared.md`
+
+# Step 1b: Application 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
+
+## 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.
+
+---
+
+### 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
+```
+
+### 2. Application Identity (per candidate)
+
+For EACH candidate application from the cadrage analysis:
+
+#### 2a. Confirm Application Name and Context
+
+Display proposed application:
+```
+{language == "fr"
+  ? "### Application : {suggestedName}\n\n**Contexte de navigation :** {suggestedContext}\n**Description :** {description based on coverage matrix items}"
+  : "### Application: {suggestedName}\n\n**Navigation context:** {suggestedContext}\n**Description:** {description based on coverage matrix items}"}
+```
+
+Ask via AskUserQuestion:
+```
+question: "{language == 'fr' ? 'Cette application et son contexte vous conviennent-ils ?' : 'Does this application and its context suit you?'}"
+header: "{appName}"
+options:
+  - label: "{language == 'fr' ? 'Oui, parfait' : 'Yes, perfect'}"
+    description: "{language == 'fr' ? 'Nom et contexte corrects' : 'Name and context are correct'}"
+  - label: "{language == 'fr' ? 'Modifier' : 'Modify'}"
+    description: "{language == 'fr' ? 'Changer le nom, le contexte ou la description' : 'Change name, context, or description'}"
+```
+
+#### 2b. Table Prefix (per application)
+
+Each application MUST have its own unique table prefix.
+
+1. Derive suggested prefix from application name (2-5 lowercase letters + `_`)
+2. Validate:
+   - Format: `^[a-z]{2,5}_$`
+   - No collision with platform prefixes: `auth_`, `nav_`, `usr_`, `ai_`, `cfg_`, `wkf_`, `support_`, `entra_`, `ref_`, `loc_`, `lic_`, `tenant_`
+   - No collision with other applications in this project
+3. Ask via AskUserQuestion for confirmation
+
+#### 2c. Application-Specific Roles
+
+Based on global roles from cadrage + application-specific needs:
+
+```
+{language == "fr"
+  ? "### Rôles pour {appName}\n\nVoici les rôles hérités des rôles globaux, adaptés à cette application :"
+  : "### Roles for {appName}\n\nHere are the roles inherited from global roles, adapted for this application:"}
+
+| Role | Level | Permission Pattern |
+|------|-------|--------------------|
+{for each role: name | admin/manager/contributor/viewer | context.app.* pattern}
+```
+
+Ask via AskUserQuestion if additional roles are needed for this specific application.
+
+#### 2d. Application Scope
+
+Extract the subset of global scope that applies to this application:
+
+```
+applicationScope = {
+  mustHave: globalScope.mustHave.filter(item => belongsToApp(item, appCode)),
+  shouldHave: globalScope.shouldHave.filter(item => belongsToApp(item, appCode)),
+  couldHave: globalScope.couldHave.filter(item => belongsToApp(item, appCode))
+}
+```
+
+Display and confirm with user.
+
+### 3. Inter-Application Dependency Analysis
+
+After all applications are defined:
+
+1. **Identify dependencies:** For each pair of applications:
+   - Shared entities (e.g., Employee defined in HR, referenced by Self-Service)
+   - Event flows (e.g., HR publishes "EmployeeCreated", Self-Service subscribes)
+   - Authentication delegation (e.g., Self-Service uses HR's employee data for auth)
+   - Data dependencies (e.g., Self-Service reads HR data)
+
+2. **Build dependency graph:**
+```
+applicationDependencyGraph = {
+  edges: [
+    { from: "EmployeeSelfService", to: "HumanResources", type: "data-dependency", description: "Reads employee data" }
+  ],
+  topologicalOrder: ["HumanResources", "EmployeeSelfService"],
+  layers: [
+    { layer: 0, applications: ["HumanResources"] },
+    { layer: 1, applications: ["EmployeeSelfService"] }
+  ]
+}
+```
+
+3. **Cycle detection:** If circular dependencies detected → BLOCKING ERROR
+   - Display the cycle
+   - Ask user to resolve (merge applications or remove dependency)
+
+### 4. Client Checkpoint (BLOCKING)
+
+Display the full application structure:
+
+```
+{language == "fr"
+  ? "### Structure du projet\n\nVoici les applications identifiées :"
+  : "### Project Structure\n\nHere are the identified applications:"}
+
+| # | Application | Contexte | Préfixe | Rôles | Dépendances |
+|---|-------------|----------|---------|-------|-------------|
+{for each app: index | name | context | prefix | role count | dependency list}
+
+{language == "fr"
+  ? "### Ordre de traitement\n\nLes applications seront traitées dans cet ordre (fondations d'abord) :"
+  : "### Processing Order\n\nApplications will be processed in this order (foundations first):"}
+
+{for each layer: "Layer {n}: {app1}, {app2}, ..."}
+```
+
+Ask via AskUserQuestion:
+```
+question: "{language == 'fr' ? 'Cette structure de projet vous convient-elle ?' : 'Does this project structure suit you?'}"
+header: "Validation"
+options:
+  - label: "{language == 'fr' ? 'Oui, continuer' : 'Yes, continue'}"
+    description: "{language == 'fr' ? 'Passer à la décomposition en modules' : 'Proceed to module decomposition'}"
+  - 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'}"
+```
+
+**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
+
+### 5. Create Per-Application Feature.json Files
+
+For EACH application in topological order:
+
+```
+ba-writer.createApplicationFeature({
+  id: generate_feature_id(),
+  version: "1.0",
+  scope: "application",
+  status: "draft",
+  metadata: {
+    application: {app.code},
+    context: {app.context},
+    language: {language},
+    featureDescription: {app.description},
+    workflowType: "new",
+    analysisMode: "interactive",
+    mcpAvailable: true,
+    tablePrefix: {app.tablePrefix},
+    projectRef: {project_id},
+    workflow: {
+      mode: "application",
+      moduleOrder: [],
+      currentModuleIndex: 0,
+      completedModules: [],
+      currentModule: null
+    }
+  }
+})
+```
+
+Store the created feature.json path in the project feature.json `applications[].featureJsonPath`.
+
+### 6. Write to Project Feature.json
+
+```
+ba-writer.enrichApplicationRegistry({
+  projectId: {project_id},
+  applications: [
+    {
+      code: {app1.code},
+      name: {app1.name},
+      context: {app1.context},
+      tablePrefix: {app1.tablePrefix},
+      icon: {app1.icon},
+      description: {app1.description},
+      applicationRoles: [{...}],
+      scope: { mustHave: [...], shouldHave: [...], couldHave: [...] },
+      modules: [],
+      dependencies: [{...}],
+      status: "pending",
+      featureJsonPath: {app1.featureJsonPath},
+      estimatedComplexity: {app1.estimatedComplexity}
+    },
+    // ... more applications
+  ],
+  applicationDependencyGraph: {
+    edges: [...],
+    topologicalOrder: [...],
+    layers: [...]
+  }
+})
+
+ba-writer.updateStatus({project_id}, "decomposed")
+```
+
+### 7. Display Summary
+
+```
+{language == "fr"
+  ? "### 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}
+
+{language == "fr"
+  ? "→ Prochaine étape : décomposition en modules pour **{firstApp}** (application {1}/{total})"
+  : "→ Next step: module decomposition for **{firstApp}** (application {1}/{total})"}
+```
+
+---
+
+## NEXT STEP
+
+Load: `./step-02-decomposition.md` (for the first application in topological order)

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

@@ -28,12 +28,27 @@ Decompose the application scope into ordered modules. Identify dependencies betw
 ### 1. Read Cadrage Results
 
 ```
-ba-reader.findFeature({feature_id})
-→ Read cadrage.globalScope (mustHave, shouldHave, couldHave)
-→ Read cadrage.stakeholders (roles, tasks, pain points)
-→ Read cadrage.applicationRoles
-→ Read cadrage.codebaseContext (existing modules found)
-→ Read metadata.workflow.mode
+// Determine context source based on workflow mode
+IF workflow.mode === "project":
+  projectFeature = ba-reader.findProjectFeature()
+  currentAppCode = projectFeature.metadata.workflow.currentApplication
+  currentApp = projectFeature.applications.find(a => a.code === currentAppCode)
+  appFeature = ba-reader.findFeature(currentApp.featureJsonPath)
+
+  // Scope decomposition to current application only
+  → Read appFeature.cadrage.globalScope (application-specific scope from step-01b)
+  → Read appFeature.cadrage.stakeholders (filtered to this application)
+  → Read appFeature.cadrage.applicationRoles
+  → Read appFeature.metadata.workflow.mode
+
+  Display: "═══ Module decomposition for application: {currentApp.name} ({currentAppIndex + 1}/{total}) ═══"
+ELSE:
+  ba-reader.findFeature({feature_id})
+  → Read cadrage.globalScope (mustHave, shouldHave, couldHave)
+  → Read cadrage.stakeholders (roles, tasks, pain points)
+  → Read cadrage.applicationRoles
+  → Read cadrage.codebaseContext (existing modules found)
+  → Read metadata.workflow.mode
 ```
 
 IF status already "decomposed":
@@ -368,3 +383,5 @@ When `workflow.mode = "module"` or only 1 scope item identified:
 
 > **FORBIDDEN:** Asking any question between decomposition summary and step-03 load.
 > The client checkpoint was at step 6. Do NOT add another one.
+
+> **PROJECT MODE NOTE:** In project mode, this step runs once per application. After all modules for the current application are specified (via the module loop in step-03d), the application loop in `_module-loop.md` will advance to the next application and re-load this step for module decomposition of the next application. Module registries and dependency graphs are written to the APPLICATION-level feature.json (not the project level). The project-level feature.json tracks application status via `ba-writer.updateApplicationStatus()`.

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

@@ -548,8 +548,6 @@ IF currentModuleIndex < moduleOrder.length:
   Load: steps/step-03a1-setup.md
 
 IF currentModuleIndex >= moduleOrder.length:
-  Display: "═══ Tous les modules spécifiés! Passage à la consolidation (04a→04c) puis handoff (05a→05c)... ═══"
-  Display: "⚠ NE PAS lancer /ralph-loop — la consolidation et le handoff sont encore nécessaires."
   ba-writer.updateStatus({feature_id}, "specified")
 
   // CHECKPOINT: Save progress BEFORE transition (protects against context exhaustion)
@@ -562,10 +560,33 @@ IF currentModuleIndex >= moduleOrder.length:
     }
   })
 
-  // MANDATORY TRANSITION — DO NOT STOP HERE
-  // If context is near exhaustion, the checkpoint above ensures the user
-  // can resume with /business-analyse and it will route to step-04a automatically.
-  Load: steps/step-04a-collect.md
+  // CHECK: Are we in project mode (multi-application)?
+  IF workflow.mode === "project":
+    // APPLICATION LOOP: Check if more applications remain
+    projectFeature = ba-reader.findProjectFeature()
+    ba-writer.updateApplicationStatus(projectId, currentApp.code, "specified")
+    ba-writer.advanceApplicationLoop(projectId)
+
+    IF projectFeature.metadata.workflow.currentApplicationIndex + 1 < projectFeature.metadata.workflow.applicationOrder.length:
+      nextApp = projectFeature.metadata.workflow.applicationOrder[currentApplicationIndex + 1]
+      Display: "═══ Application {currentApp.name} terminée ({N}/{total}). Prochaine : {nextApp} ═══"
+      Display: "⚠ NE PAS lancer /ralph-loop — d'autres applications et la consolidation sont encore nécessaires."
+      // Load step-02 for next application's module decomposition
+      Load: steps/step-02-decomposition.md
+    ELSE:
+      Display: "═══ Toutes les applications spécifiées! Passage à la consolidation cross-application... ═══"
+      Display: "⚠ NE PAS lancer /ralph-loop — la consolidation et le handoff sont encore nécessaires."
+      ba-writer.updateStatus(projectId, "specified")
+      Load: steps/step-04a-collect.md
+  ELSE:
+    // SINGLE APPLICATION: Current behavior
+    Display: "═══ Tous les modules spécifiés! Passage à la consolidation (04a→04c) puis handoff (05a→05c)... ═══"
+    Display: "⚠ NE PAS lancer /ralph-loop — la consolidation et le handoff sont encore nécessaires."
+
+    // MANDATORY TRANSITION — DO NOT STOP HERE
+    // If context is near exhaustion, the checkpoint above ensures the user
+    // can resume with /business-analyse and it will route to step-04a automatically.
+    Load: steps/step-04a-collect.md
 ```
 
 ---

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: