@atlashub/smartstack-cli 3.33.0 → 3.35.0

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

@@ -85,7 +85,8 @@ mcp__smartstack__validate_conventions({ checks: ["tables"] })
 
 Execute workflow detection algorithm:
 1. **Review Mode Detection:** Check if `{feature_description}` starts with `-review`
-2. **Existing Applications Scanner:** Glob `docs/business/*/business-analyse/*/feature.json`
+2. **Existing Projects Scanner:** Glob `docs/business-analyse/*/feature.json` (project-level)
+2b. **Existing Applications Scanner:** Glob `docs/business/*/business-analyse/*/feature.json` + `docs/platform/*/business-analyse/*/feature.json` + `docs/personal/*/business-analyse/*/feature.json`
 3. **Similarity Analysis:** Score user intent against existing apps (>= 80 = strong match)
 4. **Decision Tree:** Prompt user with relevant options
 
@@ -119,15 +120,125 @@ ELSE:
 ```yaml
 workflow_type: "new" | "update" | "review"
 existing_feature_id: string | null
+existing_project_id: string | null  # PROJ-NNN if resuming a project
 version: "1.0" (new) | "1.1"+ (update)
 review_json_path: string | null (review only)
 existing_apps: array of { app, featureId, description, version }
+existing_projects: array of { projectName, projectId, applications[], version }
 ```
 
+> **Project Resume Detection:** If a project-level feature.json is found at `docs/business-analyse/*/feature.json`, check its `metadata.workflow` to determine resume point. The project may have partially completed applications.
+
+## Step 3b: Early Multi-Application Detection from Prompt (NEW)
+
+> **Detect multi-app structure BEFORE asking for a single application name.**
+> When the user's prompt explicitly describes multiple applications, we must recognize this immediately
+> and set `workflow.mode = "project"` to avoid doing cadrage for a single app.
+
+**Detection patterns (ANY match = multi-app detected):**
+
+```javascript
+const multiAppPatterns = [
+  // French patterns
+  /une\s+application\s+\w+.*une\s+application\s+\w+/is,
+  /application\s*\d?\s*[:]\s*\w+.*application\s*\d?\s*[:]\s*\w+/is,
+  /premier[e]?\s+application.*deuxième\s+application/is,
+  /app\s*1\s*[:.].*app\s*2\s*[:.]*/is,
+  // English patterns
+  /an?\s+application\s+(for\s+)?\w+.*an?\s+application\s+(for\s+)?\w+/is,
+  /application\s*#?\d\s*[:.].*application\s*#?\d\s*[:.]*/is,
+  /first\s+app.*second\s+app/is,
+];
+
+const isMultiApp = multiAppPatterns.some(p => p.test(feature_description));
+```
+
+**IF multi-app detected:**
+
+1. Extract candidate applications from the prompt:
+
+```javascript
+// Parse the prompt to identify application boundaries
+// Each "une application X" / "an application X" block = one candidate
+const candidates = extractApplicationCandidates(feature_description);
+// Result example:
+// [
+//   { name: "RH", description: "gestion des employes, conges, temps", modules: ["Employes", "Conges", "Temps"] },
+//   { name: "Projet", description: "gestion des projets, saisie du temps", modules: ["Projets", "Temps"] }
+// ]
+```
+
+2. Detect shared modules across candidates:
+
+```javascript
+const allModules = candidates.flatMap(c => c.modules);
+const sharedModules = allModules.filter((m, i) => allModules.indexOf(m) !== i);
+// Example: sharedModules = ["Temps"] → appears in both RH and Projet
+```
+
+3. Display detection result and confirm:
+
+```
+{language == "fr"
+  ? "### Détection multi-application\n\nJ'ai détecté **{candidates.length} applications** dans votre description :"
+  : "### Multi-application detection\n\nI detected **{candidates.length} applications** in your description:"}
+
+| # | Application | Modules identifiés |
+|---|-------------|-------------------|
+{for each candidate: index | name | modules.join(", ")}
+
+{sharedModules.length > 0
+  ? "⚠️ **Modules partagés détectés :** {sharedModules.join(', ')} — ces modules apparaissent dans plusieurs applications. Ils pourraient constituer une application transversale dédiée."
+  : ""}
+```
+
+Ask via AskUserQuestion:
+```
+question: "{language == 'fr' ? 'Confirmez-vous cette structure multi-application ?' : 'Do you confirm this multi-application structure?'}"
+header: "Architecture"
+options:
+  - label: "{language == 'fr' ? 'Oui, {candidates.length} applications' : 'Yes, {candidates.length} applications'}"
+    description: "{language == 'fr' ? 'Créer un projet avec les applications identifiées' : 'Create a project with the identified applications'}"
+  - label: "{language == 'fr' ? 'Extraire les modules partagés' : 'Extract shared modules'}" (only if sharedModules.length > 0)
+    description: "{language == 'fr' ? 'Créer une application dédiée pour {sharedModules.join(', ')} ({candidates.length + 1} applications au total)' : 'Create a dedicated app for {sharedModules.join(', ')} ({candidates.length + 1} total)'}"
+  - label: "{language == 'fr' ? 'Application unique' : 'Single application'}"
+    description: "{language == 'fr' ? 'Tout regrouper en une seule application avec plusieurs modules' : 'Group everything into one application with multiple modules'}"
+```
+
+**IF "Oui, N applications" or "Extraire les modules partagés":**
+
+```yaml
+workflow_mode: "project"
+project_name: derived from feature_description
+candidate_applications: [{ name, description, modules, context }]
+shared_modules_extracted: boolean  # true if user chose extraction
+```
+
+→ Skip step 4 (application name) — applications will be confirmed in step-01b
+→ Continue to step 5 (language selection)
+
+**IF "Application unique":**
+
+```yaml
+workflow_mode: "application"
+```
+
+→ Continue to step 4 normally
+
+**IF no multi-app patterns detected:**
+→ Continue to step 4 normally
+
 ## Step 4: Determine Application Name
 
+> **This step is SKIPPED if `workflow_mode = "project"` (multi-app detected in step 3b).**
+
 ```
-IF workflow_type = "update":
+IF workflow_mode = "project":
+  application_name = project_name  // Project-level name, not a single app name
+  context = "business"  // Default, each app can have its own context
+  → Skip to step 5
+
+ELSE IF workflow_type = "update":
   application_name = existing app name (from step 3)
 ELSE:
   Analyze {feature_description} to extract application name
@@ -144,12 +255,13 @@ ELSE:
 **Validate business context:**
 ```
 validate_business_context("business")
-→ BA restricted to 'business' context only
+→ BA restricted to 'business' context only (in standalone mode)
+→ In project mode, each application can target any context
 ```
 
 **Store:**
 ```yaml
-application_name: string
+application_name: string  # or project_name if project mode
 context: "business"
 ```
 
@@ -211,15 +323,22 @@ feature_id: string
 ## Step 7: Create Output Directory Structure
 
 ```
-IF workflow_type = "new":
+IF workflow_mode = "project":
+  // Project mode: create project-level directory + per-app directories later (in step-01b)
+  mkdir -p docs/business-analyse/v1.0
+  docs_dir = "docs/business-analyse/v{version}"
+
+ELSE IF workflow_type = "new":
   mkdir -p docs/business/{application_name}/business-analyse/v1.0
+  docs_dir = "docs/business/{app}/business-analyse/v{version}"
+
 ELSE:
   Directory already exists from ba-writer.createVersion()
 ```
 
 **Store:**
 ```yaml
-docs_dir: "docs/business/{app}/business-analyse/v{version}"
+docs_dir: string
 ```
 
 ## Step 8: Deploy JSON Schemas to Project (MANDATORY)
@@ -272,34 +391,67 @@ See [references/cache-warming-strategy.md](../references/cache-warming-strategy.
 Create the master feature document using ba-writer agent.
 
 ```
-ba-writer.createApplicationFeature({
-  id: {feature_id},
-  version: {version},
-  scope: "application",
-  status: "draft",
-  metadata: {
-    application: {application_name},
-    context: "business",
-    language: {language},
-    featureDescription: {feature_description},
-    workflowType: {workflow_type},
-    analysisMode: "interactive",
-    mcpAvailable: true,
-    workflow: {
-      mode: "application",
-      moduleOrder: [],
-      currentModuleIndex: 0,
-      completedModules: [],
-      currentModule: null
+IF workflow_mode = "project":
+  // PROJECT MODE: Create project-level feature.json
+  ba-writer.createProjectFeature({
+    id: generate_project_id(),  // PROJ-NNN
+    version: {version},
+    scope: "project",
+    status: "draft",
+    metadata: {
+      projectName: {project_name},
+      language: {language},
+      featureDescription: {feature_description},
+      workflowType: {workflow_type},
+      analysisMode: "interactive",
+      mcpAvailable: true,
+      candidateApplications: {candidate_applications},  // From step 3b detection
+      sharedModulesExtracted: {shared_modules_extracted},
+      workflow: {
+        mode: "project",
+        applicationOrder: [],
+        currentApplicationIndex: 0,
+        completedApplications: []
+      }
     }
-  }
-})
-```
+  })
+
+  Output path: docs/business-analyse/v{version}/feature.json
 
-**Output path:**
-`docs/business/{app}/business-analyse/v{version}/feature.json`
+  Store:
+    project_id: string  // PROJ-NNN
+    feature_id: project_id  // In project mode, feature_id = project_id for step-01
 
-> **Note:** Always create the master feature.json first. Step-02 (decomposition) determines if it's single or multi-module.
+ELSE:
+  // SINGLE-APP MODE: Create application-level feature.json
+  ba-writer.createApplicationFeature({
+    id: {feature_id},
+    version: {version},
+    scope: "application",
+    status: "draft",
+    metadata: {
+      application: {application_name},
+      context: "business",
+      language: {language},
+      featureDescription: {feature_description},
+      workflowType: {workflow_type},
+      analysisMode: "interactive",
+      mcpAvailable: true,
+      workflow: {
+        mode: "application",
+        moduleOrder: [],
+        currentModuleIndex: 0,
+        completedModules: [],
+        currentModule: null
+      }
+    }
+  })
+
+  Output path: docs/business/{app}/business-analyse/v{version}/feature.json
+```
+
+> **Note:** In project mode, per-application feature.json files are created later in step-01b.
+> In single-app mode, step-02 (decomposition) determines if it's single or multi-module.
 
 ## Step 10: Update Config
 
@@ -330,13 +482,18 @@ Update `.business-analyse/config.json` with new feature information.
 |--------------------|----------------------------------------------|
 | Feature ID         | {feature_id}                                 |
 | Workflow           | {workflow_type}                               |
-| Application        | business/{application_name}                  |
+| Mode               | {workflow_mode === "project" ? "Multi-application project" : "Single application"} |
+| Application/Project| {workflow_mode === "project" ? project_name + " (" + candidate_applications.length + " apps)" : "business/" + application_name} |
 | Output Path        | {docs_dir}/feature.json                      |
 | Language           | {language}                                   |
 | Version            | {version}                                    |
 | MCP Available      | true                                         |
 | Analysis Mode      | Interactive (always)                         |
 
+{workflow_mode === "project"
+  ? "Candidate applications: " + candidate_applications.map(a => a.name).join(", ")
+  : ""}
+
 NEXT STEP: step-01-cadrage
 ═══════════════════════════════════════════════════════════════
 ```
@@ -347,14 +504,18 @@ After showing initialization summary, proceed to `./step-01-cadrage.md`
 
 **Pass context variables:**
 ```yaml
-feature_id: string
+feature_id: string               # FEAT-NNN (single-app) or PROJ-NNN (project)
 feature_description: string
 workflow_type: "new" | "update"
-application_name: string
+workflow_mode: "application" | "project"
+application_name: string         # Single-app: app name. Project: project name.
+applicationCode: string          # PascalCase derived from application_name (preliminary, confirmed in step-01b)
+project_id: string | null        # PROJ-NNN if project mode, null if single-app
+candidate_applications: array | null  # Pre-identified apps from prompt (project mode only)
+shared_modules_extracted: boolean     # True if user chose to extract shared modules as new app
 language: string
 docs_dir: string
 mcp_available: boolean
-workflow_mode: "application"
 analysisMode: "interactive"
 version: string
 ```
@@ -372,9 +533,11 @@ version: string
 
 If initialization was interrupted:
 
-1. Check `.business-analyse/config.json` for currentFeature
-2. If feature ID exists, search for feature.json in `docs/business/`
-3. If found, check status and `metadata.workflow.lastCompletedStep`:
+1. Check `.business-analyse/config.json` for currentFeature or currentProject
+2. If project ID exists, search for project feature.json in `docs/business-analyse/`
+   - If found with scope = "project": resume project mode (see Project Resume below)
+3. If feature ID exists, search for feature.json in `docs/business/`, `docs/platform/`, `docs/personal/`
+4. If found, check status and `metadata.workflow.lastCompletedStep`:
 
    **Status-based resume routing (check in this order):**
 
@@ -401,3 +564,22 @@ If initialization was interrupted:
    - Otherwise: offer to resume from last completed step
 
 4. If not found, create fresh feature.json
+
+**Project Resume (project mode):**
+
+If a project-level feature.json is found (scope = "project"):
+
+   - If status = `"draft"` or `"framed"`:
+     → Resume at `step-01-cadrage.md` or `step-01b-applications.md`
+
+   - If status = `"decomposed"`:
+     → Check `metadata.workflow.currentApplicationIndex` and `completedApplications[]`
+     → Resume module specification for current application (step-02 or step-03)
+
+   - If status = `"specified"`:
+     → All applications specified → Resume at `step-04a-collect.md`
+
+   - If status = `"consolidated"`:
+     → Resume at `step-05a-handoff.md`
+
+   Follow `_module-loop.md` "Project Mode (multi app)" resume logic for detailed routing.

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,7 +822,82 @@ ba-writer.enrichSection({
 ba-writer.updateStatus({feature_id}, "framed")
 ```
 
-### 9. Display Summary
+### 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:
+
+**Detection triggers (ANY of these = suggest multi-app):**
+- Coverage matrix entries reference different navigation contexts (business + personal + platform)
+- User mentioned "multiple applications", "several apps", "cross-platform"
+- Functional domains form clearly independent applications with separate user bases
+- Stakeholders only interact with specific domains (not shared across all)
+
+**IF detection triggers matched:**
+
+Display analysis as markdown:
+```
+{language == "fr"
+  ? "### Analyse multi-application\n\nD'après mon analyse, ce projet couvre plusieurs domaines fonctionnels qui pourraient former des applications indépendantes :\n\n"
+  : "### Multi-Application Analysis\n\nBased on my analysis, this project spans multiple functional domains that could form independent applications:\n\n"}
+
+| Domain | Suggested Context | Suggested Application | Key Modules |
+|--------|-------------------|----------------------|-------------|
+{for each identified domain: domain name | business/platform/personal | PascalCase name | top modules}
+```
+
+Ask via AskUserQuestion:
+```
+question: "{language == 'fr' ? 'Ce projet constitue-t-il une seule application ou plusieurs applications distinctes ?' : 'Is this a single application or multiple independent applications?'}"
+header: "Architecture"
+options:
+  - label: "{language == 'fr' ? 'Application unique' : 'Single application'}"
+    description: "{language == 'fr' ? 'Tous les domaines forment une seule application avec plusieurs modules' : 'All domains form one application with multiple modules'}"
+  - label: "{language == 'fr' ? 'Applications multiples' : 'Multiple applications'}"
+    description: "{language == 'fr' ? 'Chaque domaine est une application indépendante (navigation, rôles et préfixe de table séparés)' : 'Each domain is an independent application (separate navigation, roles, and table prefix)'}"
+```
+
+**IF "Multiple applications":**
+1. Create project-level feature.json:
+```
+ba-writer.createProjectFeature({
+  metadata: {
+    projectName: {project_name derived from feature_description},
+    language: {language},
+    featureDescription: {feature_description},
+    candidateApplications: [{detected candidates}]
+  },
+  cadrage: {cadrage data already collected in this step}
+})
+```
+2. Set `workflow_mode = "project"` and `project_id = PROJ-NNN`
+3. Load `questionnaire/00b-project.md` for additional project-level questions
+4. Continue to section 10 and then step-01b
+
+**IF "Single application":**
+→ Continue to step 10 (display summary) and step-02 as usual.
+
+**IF no detection triggers matched:**
+→ Skip this section entirely — continue to step 10 (display summary).
+
+### 10. Display Summary
 
 ```
 ## Cadrage Complete - {feature_id}
@@ -748,4 +925,6 @@ ba-writer.updateStatus({feature_id}, "framed")
 
 ## NEXT STEP
 
-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).