@atlashub/smartstack-cli 2.7.1 → 2.7.3

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

@@ -208,6 +208,115 @@ Store results in consolidation.semanticChecks[]:
 - ≥1 ERROR → BLOCK (fix before handoff, ask user for each)
 - WARNING only → PASS with user notification
 
+### 4-bis. Structural Schema Conformity Check (MANDATORY)
+
+> **Post-generation validation.** After semantic checks, verify that ALL module feature.json files conform to the JSON schema structure. This catches field name mismatches, missing sections, and wrong nesting.
+
+For EACH module feature.json, run these structural checks:
+
+**A. Required Sections Presence**
+
+| Section | Required | Check |
+|---------|----------|-------|
+| `metadata` | YES | Must have: app, module, language, featureDescription, featureType |
+| `discovery` | YES | Must exist (even if minimal) |
+| `analysis.entities[]` | YES | Must have ≥1 entity |
+| `analysis.businessRules[]` | YES | Must have ≥1 BR |
+| `analysis.objectives[]` | YES | Must have ≥1 objective |
+| `analysis.processFlow` | YES | Must have entryPoints, mainFlow, decisionPoints |
+| `analysis.dataLifecycle` | YES | Must have retention, archival, deletion, gdprRelevant |
+| `specification.useCases[]` | YES | Must have ≥1 UC |
+| `specification.functionalRequirements[]` | YES | Must have ≥1 FR |
+| `specification.permissionMatrix` | YES | Must be `{permissions[], roleAssignments[]}` (NOT flat array) |
+| `specification.sections[]` | YES | Must have ≥1 section with resources |
+| `specification.uiWireframes[]` | YES | Must have ≥1 wireframe with `layout` object |
+| `specification.lifeCycles[]` | IF entities have status | States must be objects (NOT strings) |
+| `specification.seedDataCore` | YES | Must have 5 arrays: navigationModules, navigationTranslations, permissions, rolePermissions, permissionConstants |
+| `specification.gherkinScenarios` | YES | Must be `{feature, scenarios[]}` (NOT flat array) |
+| `specification.navigation` | YES | Must have entries[] |
+| `specification.i18nKeys[]` | YES | Must have ≥1 key with fr, en, nl, de |
+| `validation` | YES | Must have completenessChecks, consistencyChecks, semanticChecks, decision |
+| `handoff` | Written by step-05 | Checked post-handoff |
+
+**B. Field Name Conformity**
+
+For each section, verify NO FORBIDDEN field names are used:
+
+| Section | FORBIDDEN fields | Correct fields |
+|---------|-----------------|----------------|
+| `entities[].attributes[]` | `type`, `values`, `rules` | `description`, `unique`, `validation` |
+| `businessRules[]` | `rule`, `condition` (singular), `action` | `name`, `statement`, `conditions[]` |
+| `useCases[]` | `actor`, `linkedBRs`, `linkedFRs` | `primaryActor`, `linkedRules` |
+| `functionalRequirements[]` | `name`, `description`, `linkedUCs`, `linkedBRs` | `statement`, `linkedUseCases`, `linkedRules` |
+| `permissionMatrix` | flat array with `resource`/`roles` | `{permissions[], roleAssignments[]}` |
+| `lifeCycles[].states[]` | string values like `"Active"` | objects with `{id, displayName, color, isTerminal}` |
+| `seedDataCore` | flat object, string values | 5 typed arrays |
+| `gherkinScenarios` | flat scenario array | `{feature, scenarios[]}` nested |
+
+**C. ID Pattern Conformity**
+
+| ID Type | Pattern | Example |
+|---------|---------|---------|
+| BR | `BR-(VAL\|CALC\|WF\|SEC\|DATA)-{PREFIX}-\d{3}` | BR-VAL-RM-001 |
+| UC | `UC-{PREFIX}-\d{3}` | UC-RM-001 |
+| FR | `FR-{PREFIX}-\d{3}` | FR-RM-001 |
+| Permissions | `business.{app}.{module}.{resource}.{action}` | business.freebike.repairs.create |
+
+Verify all IDs use the correct module prefix (2-4 uppercase letters).
+
+**D. Cross-Module ID Uniqueness**
+
+Verify no ID collision across modules:
+```
+SET all_ids = {}
+FOR each module:
+  FOR each BR, UC, FR id:
+    IF id IN all_ids → ERROR: "Duplicate {id} in {module1} and {module2}"
+    ADD id to all_ids
+```
+
+**E. Wireframe Layout Completeness**
+
+For each `uiWireframes[]`:
+```
+IF missing componentMapping[] → ERROR
+IF missing layout object → ERROR
+IF missing layout.regions[] → ERROR
+FOR each region in layout.regions[]:
+  IF missing position → ERROR
+  IF missing components[] → ERROR
+```
+
+**F. SeedDataCore Translation Coverage**
+
+```
+FOR each navigationModules[].code:
+  FOR each language in [fr, en, nl, de]:
+    IF NOT EXISTS navigationTranslations[] with moduleCode AND language → ERROR
+```
+
+**Result aggregation:**
+```json
+{
+  "structuralChecks": [
+    { "check": "required-sections", "module": "...", "status": "PASS|ERROR", "details": "Missing: analysis.objectives" },
+    { "check": "field-names", "module": "...", "status": "PASS|ERROR", "details": "businessRules[0] uses 'rule' instead of 'name'+'statement'" },
+    { "check": "id-patterns", "module": "...", "status": "PASS|ERROR", "details": "BR-001 missing category segment" },
+    { "check": "id-uniqueness", "module": "...", "status": "PASS|ERROR", "details": "UC-RM-003 duplicated in Vehicles and Repairs" },
+    { "check": "wireframe-layout", "module": "...", "status": "PASS|ERROR", "details": "Wireframe repairs-list missing layout object" },
+    { "check": "seeddata-translations", "module": "...", "status": "PASS|ERROR", "details": "Missing nl translation for NavigationModuleRepairs" }
+  ]
+}
+```
+
+**Blocking rule:**
+- 0 ERROR → PASS (merge structuralChecks into consolidation.semanticChecks[])
+- ≥1 ERROR → BLOCK. For each ERROR:
+  1. Attempt AUTO-FIX (rename fields, restructure)
+  2. Re-write the module feature.json with fixes
+  3. Re-check
+  4. If still ERROR → ask user
+
 ### 5. End-to-End Flows
 
 Identify business processes that span multiple modules:
@@ -308,21 +417,77 @@ IF "Modifier les interactions":
 
 ### 9. Write Consolidation
 
+> **STRUCTURE CARD: consolidation** — Must match `application-schema.json`. Follow this structure exactly.
+
 ```
 ba-writer.enrichSection({
   featureId: {feature_id},
   section: "consolidation",
   data: {
-    crossModuleInteractions: { fkReferences, sharedEntities, events, sharedReferenceData },
-    permissionCoherence: { roleConsistency, pathFormat, hierarchy, conflicts, resolved },
-    e2eFlows: [...],
-    globalRiskAssessment: {...}
+    crossModuleInteractions: [
+      {
+        "fromModule": "Orders",
+        "toModule": "Customers",
+        "interactionType": "FK-reference|event-publish|event-subscribe|shared-lookup|cascade-delete|cascade-update",
+        "description": "Order references customer via FK",
+        "entities": ["Order→Customer"]
+      }
+    ],
+    sharedEntities: [
+      {
+        "entity": "Customer",
+        "ownerModule": "Customers",
+        "referencedBy": ["Orders", "Invoices"],
+        "sharedFields": ["code", "name"]
+      }
+    ],
+    permissionCoherence: {
+      "rolesConsistent": true,
+      "pathFormatConsistent": true,
+      "hierarchyRespected": true,
+      "conflicts": [],
+      "warnings": []
+    },
+    e2eFlows: [
+      {
+        "name": "Order to Invoice",
+        "modules": ["Customers", "Orders", "Invoices"],
+        "steps": [
+          { "module": "Orders", "action": "Create order", "permission": "business.sales.orders.create", "dataFlow": "Customer → Order" }
+        ]
+      }
+    ],
+    globalRiskAssessment: [
+      {
+        "risk": "Cross-module coupling complexity",
+        "category": "coupling|complexity|dependency-chain|security|scope",
+        "severity": "critical|high|medium|low",
+        "mitigation": "Event-driven communication instead of direct FK"
+      }
+    ],
+    semanticChecks: [
+      { "check": "permission-orpheline", "status": "PASS|WARNING|ERROR", "details": "..." },
+      { "check": "uc-sans-fr", "status": "PASS|WARNING|ERROR", "details": "..." },
+      { "check": "wireframe-coverage", "status": "PASS|WARNING|ERROR", "details": "..." }
+    ],
+    decision: {
+      "approved": true,
+      "reason": "All cross-module validations passed",
+      "approvedBy": "Client",
+      "approvedAt": "{ISO timestamp}"
+    }
   }
 })
 
 ba-writer.updateStatus({feature_id}, "consolidated")
 ```
 
+> **STRUCTURE DIFFERENCES FROM OLD FORMAT:**
+> - `crossModuleInteractions` is a FLAT ARRAY (not `{fkReferences, sharedEntities, events}` nested object)
+> - `sharedEntities` is TOP-LEVEL (not nested inside crossModuleInteractions)
+> - `decision` is an OBJECT with `approved`, `reason`, `approvedBy`, `approvedAt` (not `clientApproval` string)
+> - `globalRiskAssessment` is an ARRAY of risk objects (not `{totalEntities: {value, threshold}}`)
+
 Add changelog entry:
 ```json
 {

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

@@ -759,6 +759,30 @@ COLORS:
 
 #### 9a. Module Handoff Loop (MANDATORY)
 
+> **STRUCTURE CARD: handoff** — Field names are EXACT. Include ALL fields below.
+> ```json
+> {
+>   "complexity": "simple|medium|complex",
+>   "filesToCreate": {
+>     "domain": [{"path": "...", "type": "Entity|ValueObject|Enum", "linkedFRs": [], "linkedUCs": [], "module": "..."}],
+>     "application": [{"path": "...", "type": "Service|Dto|Validator", "linkedFRs": [], "linkedUCs": [], "module": "..."}],
+>     "infrastructure": [{"path": "...", "type": "Repository|DbContext", "linkedFRs": [], "module": "..."}],
+>     "api": [{"path": "...", "type": "ApiController", "linkedUCs": [], "linkedFRs": [], "module": "..."}],
+>     "frontend": [{"path": "...", "type": "Page|Component|Hook|DashboardPage", "linkedUCs": [], "linkedWireframes": [], "module": "..."}],
+>     "seedData": [{"path": "...", "type": "HasData", "category": "core|business", "source": "...", "module": "..."}],
+>     "tests": [{"path": "...", "type": "UnitTests|IntegrationTests|SecurityTests", "linkedFRs": [], "linkedUCs": [], "module": "..."}]
+>   },
+>   "brToCodeMapping": [{"ruleId": "BR-...", "files": ["path1", "path2"], "implementation": "description"}],
+>   "apiEndpointSummary": [{"method": "GET|POST|PUT|DELETE", "path": "/api/...", "permission": "business.{app}.{module}.{action}", "linkedUC": "UC-..."}],
+>   "prdFile": ".ralph/prd-{module}.json",
+>   "totalFiles": 0,
+>   "totalTasks": 0,
+>   "handedOffAt": "{ISO timestamp}"
+> }
+> ```
+> **MANDATORY fields:** ALL of the above. `filesToCreate` MUST have all 7 categories (even if empty arrays).
+> **FORBIDDEN:** `handoff: {}` (empty object is a CRITICAL BUG). Missing `brToCodeMapping` or `apiEndpointSummary`.
+
 **For i = 0; i < modules.length; i++:**
 
 ```

package/templates/skills/efcore/steps/squash/step-03-create.md

@@ -131,6 +131,45 @@ echo "  Up methods: $UP_METHODS"
 echo "  Down methods: $DOWN_METHODS"
 ```
 
+### 6. Inject SQL Objects (Functions, Views, SP)
+
+EF Core ne génère PAS de DDL pour les TVF, vues et procédures stockées.
+Les scripts SQL source sont dans `Persistence/SqlObjects/` (Embedded Resources).
+Après un squash, il faut les réinjecter dans la migration consolidée.
+
+```bash
+# Check if SqlObjects folder exists with .sql files
+SQL_OBJECTS_DIR="$INFRA_PROJECT_DIR/Persistence/SqlObjects"
+SQL_FILES=$(find "$SQL_OBJECTS_DIR" -name "*.sql" 2>/dev/null | wc -l)
+
+if [ "$SQL_FILES" -gt 0 ]; then
+  echo ""
+  echo "Found $SQL_FILES SQL object(s) in SqlObjects/"
+  echo "Injecting SqlObjectHelper.ApplyAll(migrationBuilder) into migration..."
+
+  # Add using directive if not present
+  if ! grep -q "using SmartStack.Infrastructure.Persistence.SqlObjects;" "$MIGRATION_FILE"; then
+    sed -i '1s/^/using SmartStack.Infrastructure.Persistence.SqlObjects;\n/' "$MIGRATION_FILE"
+  fi
+
+  # Add SqlObjectHelper.ApplyAll at the end of Up() method
+  # Find the closing brace of Up() and insert before it
+  sed -i '/protected override void Up/,/^        }/ {
+    /^        }/ i\
+\            // Apply SQL objects (TVF, Views, SP) from embedded resources\
+\            SqlObjectHelper.ApplyAll(migrationBuilder);
+  }' "$MIGRATION_FILE"
+
+  echo "  ✅ SqlObjectHelper.ApplyAll(migrationBuilder) injected"
+  find "$SQL_OBJECTS_DIR" -name "*.sql" -exec basename {} \; | while read f; do
+    echo "  📄 $f"
+  done
+else
+  echo ""
+  echo "No SQL objects found in SqlObjects/ - skipping injection"
+fi
+```
+
 ---
 
 ## EXPECTED RESULT:

package/templates/skills/ralph-loop/SKILL.md

@@ -108,7 +108,7 @@ The loop only stops when this exact tag is output or max iterations reached.
 </ralph_concept>
 
 <workflow>
-**Standard flow:**
+**Standard flow (single module):**
 1. Parse flags and task description
 2. Verify MCP servers are available (MANDATORY)
 3. Initialize .ralph/ structure and state files
@@ -117,6 +117,15 @@ The loop only stops when this exact tag is output or max iterations reached.
 6. Commit changes, update progress
 7. Check completion criteria
 8. If complete: generate final report
+
+**Multi-module flow (from BA handoff):**
+1-3. Same as standard flow
+4. Detect `prd-*.json` files → create `modules-queue.json`
+5. Copy current module's prd to `prd.json`
+6. Execute all tasks for current module (standard loop: steps 01→02→03→04)
+7. When module complete: advance to next module in queue
+8. Repeat steps 5-7 for each module
+9. When all modules done: generate cross-module report
 </workflow>
 
 <state_variables>
@@ -136,6 +145,8 @@ The loop only stops when this exact tag is output or max iterations reached.
 | `{task_category}` | string | Task category (domain/application/infrastructure/api/frontend/i18n/test/validation) |
 | `{files_created}` | string[] | Files created during current task |
 | `{files_modified}` | string[] | Files modified during current task |
+| `{current_module}` | string\|null | Current module code (multi-module only) |
+| `{modules_queue}` | object\|null | Module queue state (multi-module only) |
 
 </state_variables>
 
@@ -184,14 +195,33 @@ Before ANY work, verify MCP servers:
 
 ```
 .ralph/
-├── prd.json          # Task list with status
-├── progress.txt      # Persistent memory between iterations
+├── prd.json              # Task list with status (current module or single)
+├── progress.txt          # Persistent memory between iterations
+├── modules-queue.json    # Multi-module tracking (only if multiple prd-*.json exist)
+├── prd-{module1}.json    # Per-module PRD from BA handoff (source, not modified)
+├── prd-{module2}.json    # Per-module PRD from BA handoff (source, not modified)
 ├── logs/
 │   └── {timestamp}.log
 └── reports/
     └── {feature-name}.md
 ```
 
+**modules-queue.json structure (multi-module only):**
+```json
+{
+  "modules": [
+    {
+      "code": "module-code",
+      "prdFile": ".ralph/prd-module-code.json",
+      "status": "pending|in-progress|completed|failed|partial"
+    }
+  ],
+  "currentIndex": 0,
+  "totalModules": 3,
+  "completedModules": 0
+}
+```
+
 **prd.json structure:**
 ```json
 {
@@ -267,6 +297,8 @@ Before ANY work, verify MCP servers:
 - Completion promise output when genuinely complete
 - Final report generated in `.ralph/reports/`
 - `prd.json` top-level `status` set to `"completed"` or `"partial"`
+- **Multi-module:** All modules in `modules-queue.json` processed sequentially
+- **Multi-module:** Cross-module aggregation in final report
 </success_criteria>
 
 <available_commands>

package/templates/skills/ralph-loop/steps/step-00-init.md

@@ -163,6 +163,22 @@ fi
    - Read `prd.config.completion_promise` → `{completion_promise}`
    - Read `prd.config.max_iterations` → `{max_iterations}`
    - Read progress.txt for context
+
+6. **Restore multi-module state (if applicable):**
+   ```javascript
+   if (fileExists('.ralph/modules-queue.json')) {
+     const queue = readJSON('.ralph/modules-queue.json');
+     const currentModule = queue.modules[queue.currentIndex];
+
+     // Restore module state
+     {modules_queue} = queue;
+     {current_module} = currentModule.code;
+
+     console.log(`Resuming multi-module: ${currentModule.code} (${queue.currentIndex + 1}/${queue.totalModules})`);
+     console.log(`Modules completed: ${queue.completedModules}/${queue.totalModules}`);
+   }
+   ```
+
    - Continue to step-01
 
 ### 4. Initialize .ralph/ Structure (new loop)
@@ -183,6 +199,80 @@ mkdir -p .ralph/logs
 mkdir -p .ralph/reports
 ```
 
+### 4b. Detect Multi-Module PRDs (from BA Handoff)
+
+**After creating `.ralph/` directory, check for per-module PRD files:**
+
+```bash
+# Count prd-*.json files (generated by BA handoff via ss derive-prd)
+PRD_FILES=$(ls .ralph/prd-*.json 2>/dev/null)
+PRD_COUNT=$(echo "$PRD_FILES" | grep -c "prd-" 2>/dev/null || echo "0")
+```
+
+**If multiple prd-*.json files found (PRD_COUNT > 0):**
+
+1. **Read module order from master feature.json (if available):**
+```bash
+# Look for master feature.json that references modules
+MASTER_FEATURE=$(find docs/business -maxdepth 4 -name "feature.json" -path "*/business-analyse/*" | head -1)
+```
+
+2. **Build module queue:**
+```javascript
+const modules = [];
+
+if (MASTER_FEATURE && masterJson.metadata?.workflow?.moduleOrder) {
+  // Use order from BA master feature.json
+  for (const mod of masterJson.metadata.workflow.moduleOrder) {
+    const prdFile = `.ralph/prd-${mod.code}.json`;
+    if (fileExists(prdFile)) {
+      modules.push({ code: mod.code, prdFile, status: "pending" });
+    }
+  }
+} else {
+  // Fallback: alphabetical order from prd-*.json filenames
+  for (const file of prdFiles) {
+    const code = file.match(/prd-(.+)\.json$/)[1];
+    modules.push({ code, prdFile: `.ralph/${file}`, status: "pending" });
+  }
+}
+```
+
+3. **Create modules-queue.json:**
+```json
+{
+  "modules": [
+    { "code": "mod1", "prdFile": ".ralph/prd-mod1.json", "status": "pending" },
+    { "code": "mod2", "prdFile": ".ralph/prd-mod2.json", "status": "pending" }
+  ],
+  "currentIndex": 0,
+  "totalModules": 2,
+  "completedModules": 0
+}
+```
+
+4. **Set first module as active:**
+```javascript
+modules[0].status = "in-progress";
+```
+
+5. **Log detection:**
+```
+Multi-module detected: {PRD_COUNT} modules
+Queue: {module codes joined by " → "}
+Starting with: {modules[0].code}
+```
+
+**If only `.ralph/prd.json` exists (single module):**
+- Skip queue creation (backward compatible)
+- Proceed normally
+
+**Store:**
+```
+{modules_queue} = queue object or null
+{current_module} = first module code or null
+```
+
 ### 5. Validate Completion Promise
 
 **If {completion_promise} is null:**
@@ -251,10 +341,12 @@ Branch: {CURRENT_BRANCH}
 ║  MCP: ✅ Ready                                                  ║
 ║  Schema: v2.0.0                                                 ║
 ║  Branch: {CURRENT_BRANCH}                                       ║
+║  {modules_queue ? "Modules: " + totalModules + " (" + module_codes.join(" → ") + ")" : "Mode: single module"} ║
 ╠══════════════════════════════════════════════════════════════════╣
 ║  Files:                                                          ║
 ║  - .ralph/prd.json (tasks)                                       ║
 ║  - .ralph/progress.txt (memory)                                  ║
+║  {modules_queue ? "- .ralph/modules-queue.json (module tracking)" : ""} ║
 ╚══════════════════════════════════════════════════════════════════╝
 
 -> Loading tasks...
@@ -273,6 +365,7 @@ Branch: {CURRENT_BRANCH}
 - Metadata collected (branch, version, MCP status)
 - prd.json v2 schema validated (if resume)
 - Branch integrity validated (if resume)
+- Multi-module prd files detected and modules-queue.json created (if applicable)
 - Output is COMPACT
 - Proceeded to step-01 immediately after summary