@atlashub/smartstack-cli 4.20.0 → 4.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlashub/smartstack-cli",
-  "version": "4.20.0",
+  "version": "4.21.0",
   "description": "SmartStack Claude Code automation toolkit - GitFlow, EF Core migrations, prompts and more",
   "author": {
     "name": "SmartStack",
@@ -54,7 +54,7 @@
   "scripts": {
     "postinstall": "node scripts/postinstall.js || exit 0",
     "dev": "tsup --watch",
-    "build:html": "node templates/skills/business-analyse/html/build-html.js",
+    "build:html": "node templates/skills/ba-generate-html/html/build-html.js",
     "build": "npm run build:html && npx tsup",
     "lint": "eslint src --ext .ts",
     "format": "prettier --write \"src/**/*.ts\"",

package/templates/skills/ba-generate-html/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: ba-generate-html
+description: "Generate the interactive HTML document from business analysis JSON data"
+model: opus
+user_invocable: true
+---
+
+# /ba-generate-html
+
+Generate the interactive HTML document of the business analysis from the JSON analysis files.
+
+## Triggers
+
+- Explicit invocation: `/ba-generate-html <feature-id>`
+- After `/business-analyse` step-04 (consolidation complete)
+- Delegation from `/ba-review` (after review corrections applied)
+
+## Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `<feature-id>` | Yes | Feature identifier (e.g., FEAT-001) |
+| `--force` | No | Regenerate even if HTML already exists |
+
+## Prerequisites
+
+- JSON analysis files must exist (at minimum `index.json` + `cadrage.json`)
+- PRD files must exist (`.ralph/prd-{moduleCode}.json`) — run `/derive-prd` first
+- Feature status must be `consolidated`
+
+## Workflow
+
+4 progressive steps:
+
+| Step | File | Role |
+|------|------|------|
+| 01 | `steps/step-01-collect.md` | Read JSON sources (index, cadrage, modules, consolidation) |
+| 02 | `steps/step-02-build-data.md` | Build FEATURE_DATA + EMBEDDED_ARTIFACTS objects |
+| 03 | `steps/step-03-render.md` | Inject into ba-interactive.html template, write final file |
+| 04 | `steps/step-04-verify.md` | POST-CHECK (size, sections, coherence) |
+
+## Absolute Rules
+
+- **NEVER** deploy an empty template — FEATURE_DATA must be injected
+- **moduleSpecs** MUST have ONE entry per module (empty = BROKEN)
+- **Scope keys** MUST be converted: `mustHave` → `vital`, `shouldHave` → `important`, `couldHave` → `optional`, `outOfScope` → `excluded`
+- **Wireframe fields** MUST be renamed: `mockupFormat` → `format`, `mockup` → `content`
+- **Final file** MUST be > 100KB
+
+## References
+
+| File | Content |
+|------|---------|
+| `references/data-mapping.md` | JSON → FEATURE_DATA field mapping |
+| `references/data-build.md` | FEATURE_DATA & EMBEDDED_ARTIFACTS construction |
+| `references/output-modes.md` | Standard, micro, delta, multi-app modes |
+
+## Entry Point
+
+**FIRST ACTION:** Load `steps/step-01-collect.md`

package/templates/skills/{business-analyse/references/deploy-data-build.md → ba-generate-html/references/data-build.md}

@@ -1,7 +1,7 @@
 # FEATURE_DATA & EMBEDDED_ARTIFACTS Build Reference
 
-> Reference for step-05-deploy.md — complete mapping specification for the interactive HTML.
-> **Canonical field mapping reference:** See also `html-data-mapping.md` for the authoritative field name mapping between module JSON files and HTML data objects.
+> Reference for `/ba-generate-html` skill (step-02-build-data) — complete mapping specification for the interactive HTML.
+> **Canonical field mapping reference:** See also `data-mapping.md` for the authoritative field name mapping between module JSON files and HTML data objects.
 
 ## FEATURE_DATA Object
 

package/templates/skills/{business-analyse/references/html-data-mapping.md → ba-generate-html/references/data-mapping.md}

@@ -1,6 +1,6 @@
-# HTML Data Mapping Reference (references/html-data-mapping.md)
+# HTML Data Mapping Reference
 
-> **Used by:** step-05-deploy (Deploy Interactive HTML)
+> **Used by:** `/ba-generate-html` skill (step-02-build-data)
 > **Purpose:** Exact mapping from module JSON files to HTML FEATURE_DATA and EMBEDDED_ARTIFACTS objects
 
 ---

package/templates/skills/{business-analyse/references/deploy-modes.md → ba-generate-html/references/output-modes.md}

@@ -1,6 +1,6 @@
 # Deploy Mode Support & Troubleshooting
 
-> Reference for step-05-deploy.md (HTML deployment) and `/derive-prd` skill (handoff + PRD generation) — mode variations and common issues.
+> Reference for `/ba-generate-html` skill (HTML deployment) and `/derive-prd` skill (handoff + PRD generation) — mode variations and common issues.
 
 ## Mode Support
 

package/templates/skills/ba-generate-html/steps/step-01-collect.md

@@ -0,0 +1,113 @@
+---
+name: step-01-collect
+description: Collect all JSON source data for HTML generation
+model: opus
+next_step: steps/step-02-build-data.md
+---
+
+# Step 1: Collect JSON Sources
+
+## YOUR TASK
+
+Read all JSON analysis files for the feature and store them as `{collected_data}` for the next step.
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Locate Feature
+
+```
+1. Read feature_id from parameters
+2. Locate master index.json:
+   - Multi-app (project): docs/business-analyse/v{version}/index.json
+   - Single-app: docs/{app}/business-analyse/v{version}/index.json
+3. IF index.json NOT found → BLOCKING ERROR: "index.json not found — run /business-analyse first"
+```
+
+### 2. Detect Mode
+
+```
+IF index.json contains "applications[]" with multiple entries:
+  mode = "project" (multi-app)
+ELSE:
+  mode = "single-app"
+
+Store: workflow.mode
+```
+
+### 3. Verify PRD Exists
+
+```
+FOR each module in modules:
+  prdPath = ".ralph/prd-{moduleCode}.json"
+  IF NOT exists(prdPath):
+    BLOCKING ERROR: "PRD not found: {prdPath} — Run /derive-prd first"
+    STOP
+  IF fileSize(prdPath) < 100:
+    BLOCKING ERROR: "PRD file too small: {prdPath} — Run /derive-prd to regenerate"
+    STOP
+```
+
+### 4. Verify Consolidation Status
+
+```
+IF workflow.mode === "project":
+  projectFeature = ba-reader.findProjectFeature()
+  FOR each app in projectFeature.applications:
+    appFeature = ba-reader.findFeature(app.featureJsonPath)
+    IF appFeature.status !== "consolidated":
+      BLOCKING ERROR: "Application {app.code} not consolidated"
+ELSE:
+  feature = ba-reader.findFeature({feature_id})
+  IF feature.status !== "consolidated":
+    BLOCKING ERROR: "Feature status: {feature.status}, expected consolidated"
+```
+
+### 5. Read All JSON Files
+
+```
+collected_data = {
+  master: {
+    index: READ(index.json),           // metadata, modules[], consolidation, handoff
+    cadrage: READ(cadrage.json)         // context, stakeholders, scope, risks
+  },
+  modules: {}
+}
+
+FOR each module in master.index.modules[]:
+  moduleIndexPath = module.featureJsonPath || "{module.code}/business-analyse/v{version}/index.json"
+  moduleIndex = READ(moduleIndexPath)
+
+  collected_data.modules[module.code] = {
+    index: moduleIndex,
+    specification: moduleIndex.specification || {},
+    analysis: moduleIndex.analysis || {}
+  }
+```
+
+### 6. Display Collection Summary
+
+```
+PRD verified: {module_count} modules
+  .ralph/prd-{module1}.json ({size} bytes)
+  .ralph/prd-{module2}.json ({size} bytes)
+
+JSON collected:
+  Master: index.json + cadrage.json
+  Modules: {module_count} module index files
+→ Proceeding to data build...
+```
+
+---
+
+## VALIDATION
+
+- BLOCK if index.json absent
+- BLOCK if 0 modules found
+- BLOCK if any PRD file missing
+- BLOCK if feature not consolidated
+
+## NEXT STEP
+
+Load: `steps/step-02-build-data.md`

package/templates/skills/ba-generate-html/steps/step-02-build-data.md

@@ -0,0 +1,237 @@
+---
+name: step-02-build-data
+description: Build FEATURE_DATA and EMBEDDED_ARTIFACTS objects from collected JSON data
+model: opus
+next_step: steps/step-03-render.md
+---
+
+> **Reference files:** `references/data-mapping.md` | `references/data-build.md`
+
+# Step 2: Build Data Objects
+
+## YOUR TASK
+
+Build `FEATURE_DATA` and `EMBEDDED_ARTIFACTS` objects from `{collected_data}` collected in step-01.
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Build FEATURE_DATA
+
+Construct the complete FEATURE_DATA object following the exact mapping in `references/data-mapping.md`:
+
+**metadata:**
+```javascript
+metadata: {
+  applicationName: master.metadata.application,
+  applicationId: master.id,
+  version: master.version,
+  createdAt: master.metadata.createdAt,
+  lastModified: master.metadata.updatedAt,
+  analysisMode: master.metadata.analysisMode || "interactive"
+}
+```
+
+**cadrage.context** (lean format):
+```javascript
+context: {
+  problem: master.cadrage.problem || "",
+  trigger: master.cadrage.trigger || "",
+  currentSituation: master.cadrage.asIs || "",        // asIs → currentSituation
+  desiredSituation: master.cadrage.toBe || "",        // toBe → desiredSituation
+  painPoints: (master.cadrage.stakeholders || []).flatMap(s => s.painPoints || []).join("\n"),
+  acceptanceCriteria: (master.cadrage.acceptanceCriteria || []).map(ac => ac.criterion).join("\n")
+}
+```
+
+**cadrage.stakeholders** (with frequency/access conversion):
+```javascript
+stakeholders: master.cadrage.stakeholders.map(s => ({
+  role: s.role,
+  function: s.function || "",
+  tasks: s.tasks || [],
+  frequency: mapFrequency(s.frequency),     // "Quotidien"→"daily", "Hebdomadaire"→"weekly", "Mensuel"→"monthly"
+  access: mapAccess(s.involvement),         // "decision-maker"→"admin", "end-user"→"contributor", "observer"→"viewer"
+  frustrations: (s.painPoints || []).join("\n")
+}))
+```
+
+**cadrage.scope** (KEY CONVERSION — CRITICAL):
+```javascript
+scope: {
+  vital: (master.cadrage.globalScope?.mustHave || []).map(item => ({ name: item, description: "" })),
+  important: (master.cadrage.globalScope?.shouldHave || []).map(item => ({ name: item, description: "" })),
+  optional: (master.cadrage.globalScope?.couldHave || []).map(item => ({ name: item, description: "" })),
+  excluded: (master.cadrage.globalScope?.outOfScope || []).map(item => ({ name: item, description: "" }))
+}
+```
+
+> Safety net: also check `master.cadrage.coverageMatrix` as alternative source for scope items.
+
+**cadrage.risks:**
+```javascript
+risks: (master.cadrage.risks || []).map(r => ({
+  description: r.description,
+  probability: r.probability,
+  impact: r.impact,
+  mitigation: r.mitigation || ""
+}))
+```
+
+**modules[]:**
+```javascript
+modules: master.modules.map(m => ({
+  code: m.code,
+  name: m.name || m.code,                   // display name (MANDATORY)
+  description: m.description || "",
+  featureType: m.featureType || "data-centric",
+  priority: m.priority || "must",
+  entities: m.entities || [],
+  anticipatedSections: m.anticipatedSections || [],
+  dependencies: m.dependencies || [],
+  dependents: m.dependents || [],
+  estimatedComplexity: m.estimatedComplexity || "medium",
+  status: m.status || "handed-off"
+}))
+```
+
+**moduleSpecs{} — ONE entry per module (CRITICAL):**
+
+For EACH module, read the module index.json and map:
+
+```javascript
+moduleSpecs[moduleCode] = {
+  useCases: (moduleFeature.specification?.useCases || []).map(uc => ({
+    name: uc.name,
+    actor: uc.primaryActor,
+    steps: (uc.mainScenario || []).join("\n"),
+    alternative: (uc.alternativeScenarios || []).map(a => a.name + ": " + (a.steps || []).join(", ")).join("\n")
+  })),
+  businessRules: (moduleFeature.analysis?.businessRules || []).map(br => ({
+    name: br.name,
+    category: br.category,
+    statement: br.statement,
+    example: (br.examples || []).map(e => e.input + " → " + e.expected).join("; ")
+  })),
+  // ENTITY SAFETY NET: map fields[] → attributes[] if agent deviated
+  entities: (moduleFeature.analysis?.entities || []).map(ent => ({
+    name: ent.name,
+    description: ent.description || "",
+    attributes: (ent.attributes || []).length > 0
+      ? ent.attributes.map(a => ({ name: a.name, description: a.description || "" }))
+      : (ent.fields || []).map(f => ({ name: f.name, description: f.description || f.type || "" })),
+    relationships: (ent.relationships || []).map(r =>
+      typeof r === 'string' ? r : r.target + " (" + r.type + ") - " + (r.description || ""))
+  })),
+  permissions: buildPermissionKeys(moduleFeature),
+  apiEndpoints: moduleFeature.specification?.apiEndpoints || []
+}
+```
+
+> See `references/data-mapping.md` for `buildPermissionKeys()` implementation.
+
+**consolidation:**
+```javascript
+consolidation: {
+  interactions: (master.consolidation?.crossModuleInteractions || []).map(i => ({
+    from: i.fromModule,
+    to: i.toModule,
+    description: i.description || ""
+  })),
+  sharedEntities: master.consolidation?.sharedEntities || [],
+  e2eFlows: (master.consolidation?.e2eFlows || []).map(f => ({
+    name: f.name,
+    steps: (f.steps || []).map(s => ({ module: s.module, action: s.action })),
+    actors: (f.steps || []).map(s => s.permission).join(", ")
+  }))
+}
+```
+
+**handoff:**
+```javascript
+handoff: {
+  complexity: master.handoff?.complexity,
+  implementationStrategy: master.handoff?.implementationStrategy,
+  moduleOrder: master.handoff?.moduleOrder,
+  filesToCreate: master.handoff?.filesToCreate,
+  brToCodeMapping: master.handoff?.brToCodeMapping,
+  apiEndpointSummary: master.handoff?.apiEndpointSummary
+}
+```
+
+---
+
+### 2. Build EMBEDDED_ARTIFACTS
+
+> **FIELD RENAME WARNING:** Module JSON uses `mockupFormat`/`mockup`. HTML reads `format`/`content`. You MUST rename.
+
+**wireframes{} — per moduleCode:**
+```javascript
+wireframes: {
+  [moduleCode]: (moduleFeature.specification.uiWireframes || moduleFeature.specification.wireframes || []).map(wf => ({
+    screen: wf.screen || wf.name || wf.title || wf.id || "",
+    section: wf.section || "",
+    format: wf.mockupFormat || "ascii",                   // RENAME: mockupFormat → format
+    content: wf.mockup || wf.ascii || wf.content || "",   // RENAME: mockup → content
+    svgContent: null,
+    description: wf.description || "",
+    elements: wf.elements || [],
+    actions: wf.actions || [],
+    componentMapping: Array.isArray(wf.componentMapping) ? wf.componentMapping
+      : typeof wf.componentMapping === 'object' && wf.componentMapping !== null
+        ? Object.entries(wf.componentMapping).map(([k, v]) => ({ wireframeElement: k, reactComponent: v }))
+        : [],
+    layout: typeof wf.layout === 'object' ? wf.layout : null,
+    permissionsRequired: wf.permissionsRequired || []
+  }))
+}
+```
+
+**e2eFlows[]:**
+```javascript
+e2eFlows: (master.consolidation?.e2eFlows || []).map(flow => ({
+  name: flow.name,
+  diagram: flow.steps.map(s => s.action + "(" + s.module + ")").join(" ──→ "),
+  steps: flow.steps || [],
+  actors: [...new Set(flow.steps.map(s => s.permission?.split(".")[0]).filter(Boolean))].join(", "),
+  modules: [...new Set(flow.steps.map(s => s.module))].join(" → ")
+}))
+```
+
+**dependencyGraph:**
+```javascript
+dependencyGraph: {
+  nodes: (master.modules || []).map(m => ({
+    id: m.code, label: m.code, type: m.featureType || "data-centric"
+  })),
+  edges: (master.dependencyGraph?.edges || []).map(e => ({
+    from: e.from, to: e.to, description: e.description || ""
+  }))
+}
+```
+
+---
+
+### 3. Generate SVG Wireframes (Parallel, Optional)
+
+> This step is NEVER blocking — ASCII-only wireframes are acceptable.
+> **Reference:** `business-analyse/references/wireframe-svg-style-guide.md` for full agent prompt template
+
+1. Collect all wireframes where `content` exists and `svgContent` is null
+2. Spawn parallel Task(sonnet) agents — ONE per wireframe
+3. Validate results: strip markdown fences, verify SVG syntax
+4. Inject valid SVGs into `EMBEDDED_ARTIFACTS.wireframes[moduleCode][index].svgContent`
+5. Display: `"SVG wireframe generation: {successCount}/{total} generated, {failCount} fallback (ASCII)"`
+
+---
+
+## VALIDATION
+
+- FEATURE_DATA.moduleSpecs must have ONE entry per module
+- cadrage.scope uses HTML keys (vital/important/optional/excluded)
+- Wireframe fields use format/content (NOT mockupFormat/mockup)
+
+## NEXT STEP
+
+Load: `steps/step-03-render.md`

package/templates/skills/ba-generate-html/steps/step-03-render.md

@@ -0,0 +1,75 @@
+---
+name: step-03-render
+description: Inject data into HTML template and write final file
+model: opus
+next_step: steps/step-04-verify.md
+---
+
+# Step 3: Render HTML
+
+## YOUR TASK
+
+Inject FEATURE_DATA and EMBEDDED_ARTIFACTS into the HTML template and write the final file.
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Locate Template
+
+```
+1. Primary: ~/.claude/skills/ba-generate-html/html/ba-interactive.html
+2. Fallback: templates/skills/ba-generate-html/html/ba-interactive.html (project CLI path)
+3. IF neither found → BLOCKING ERROR: "HTML template not found"
+```
+
+### 2. Read Template
+
+```
+Read the full HTML template file.
+Verify it contains placeholders: {{FEATURE_DATA}}, {{EMBEDDED_ARTIFACTS}}
+```
+
+### 3. Replace Placeholders
+
+Serialize and inject:
+
+```
+1. {{FEATURE_DATA}}        → JSON.stringify(FEATURE_DATA, null, 2)
+2. {{EMBEDDED_ARTIFACTS}}  → JSON.stringify(EMBEDDED_ARTIFACTS, null, 2)
+3. {{APPLICATION_NAME}}    → metadata.applicationName
+4. {{APPLICATION_ID}}      → metadata.applicationId
+5. {{VERSION}}             → metadata.version
+6. {{CREATED_AT}}          → ISO timestamp (now)
+```
+
+> Verify: grep for remaining `{{` to confirm ALL placeholders are replaced.
+
+### 4. Determine Output Path
+
+```
+IF workflow.mode === "project" (multi-app):
+  outputPath = "docs/business-analyse/v{version}/ba-interactive.html"
+ELSE (single-app):
+  outputPath = "docs/{app}/business-analyse/v{version}/ba-interactive.html"
+```
+
+### 5. Write File
+
+```
+1. Create parent directories if needed
+2. Write the final HTML file to outputPath
+3. Display: "HTML written: {outputPath} ({fileSize} bytes)"
+```
+
+---
+
+## VALIDATION
+
+- Template was found and read
+- All placeholders replaced (no remaining `{{`)
+- File written successfully
+
+## NEXT STEP
+
+Load: `steps/step-04-verify.md`

package/templates/skills/ba-generate-html/steps/step-04-verify.md

@@ -0,0 +1,83 @@
+---
+name: step-04-verify
+description: Post-check verification of generated HTML
+model: opus
+---
+
+# Step 4: Verify Generated HTML
+
+## YOUR TASK
+
+Run 5 blocking validations on the generated HTML file and display the completion summary.
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Blocking Validations
+
+**Check 1 — File size > 100KB:**
+```
+if [ $(stat --format=%s ba-interactive.html) -lt 100000 ]; then
+  BLOCKING_ERROR("ba-interactive.html not pre-populated — file too small")
+fi
+```
+
+**Check 2 — moduleSpecs present in HTML:**
+```
+if ! grep -q '"moduleSpecs"' ba-interactive.html; then
+  BLOCKING_ERROR("moduleSpecs not found — FEATURE_DATA not serialized")
+fi
+```
+
+**Check 3 — cadrage.scope uses HTML keys (vital/important, NOT mustHave):**
+```
+if grep -q '"mustHave"' ba-interactive.html; then
+  BLOCKING_ERROR("cadrage.scope still has JSON keys — conversion failed")
+fi
+```
+
+**Check 4 — Wireframe field names correct (format/content, NOT mockupFormat/mockup):**
+```
+if grep -q '"mockupFormat"' ba-interactive.html; then
+  BLOCKING_ERROR("Wireframes use 'mockupFormat' — must be 'format'")
+fi
+```
+
+**Check 5 — All modules have specs AND wireframes:**
+```
+FOR each module in FEATURE_DATA.modules:
+  IF FEATURE_DATA.moduleSpecs[module.code] undefined:
+    BLOCKING_ERROR("Module {module.code} not in moduleSpecs")
+  IF EMBEDDED_ARTIFACTS.wireframes[module.code] undefined:
+    BLOCKING_ERROR("Module {module.code} not in wireframes")
+```
+
+> **IF any check fails:** fix the issue and re-run the failing step before completing.
+
+---
+
+### 2. Display Completion Summary
+
+```
+══════════════════════════════════════════════════════════════
+  [OK] HTML DEPLOY COMPLETE — {application_name}
+══════════════════════════════════════════════════════════════
+
+Modules: {count} ({names})
+
+[DIR] Artifact generated:
+  ba-interactive.html — Interactive document
+     Path: {output_path}
+     Pre-populated: {module_count} modules, {total_uc} use cases,
+       {total_br} business rules, {total_wireframes} wireframes
+
+[NEXT] Review & Validation:
+  1. Open ba-interactive.html in browser
+  2. Review all modules, use cases, business rules
+  3. Validate wireframes and permissions
+  4. If OK: /derive-prd then /ralph-loop to begin development
+  5. If changes needed: /business-analyse to iterate
+
+══════════════════════════════════════════════════════════════
+```

package/templates/skills/ba-review/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: ba-review
+description: "Apply client corrections from ba-review.json and regenerate the interactive HTML document"
+model: opus
+user_invocable: true
+---
+
+# /ba-review
+
+Apply corrections exported from the interactive HTML review (`ba-review.json`) to create a new version of the business analysis, then regenerate the HTML document.
+
+## Triggers
+
+- Explicit invocation: `/ba-review`
+- When `ba-review.json` is detected in the project root
+
+## Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `--path` | No | Path to ba-review.json (default: project root) |
+
+## Prerequisites
+
+- `ba-review.json` must exist (exported from the interactive HTML)
+- Business analysis JSON files must exist (at minimum `index.json` + `cadrage.json`)
+- Feature status must be `consolidated` or `reviewed`
+
+## Workflow
+
+| Step | File | Role |
+|------|------|------|
+| 01 | `steps/step-01-apply.md` | Read ba-review.json, create new version, apply corrections to JSON files |
+
+After step-01 completes, delegate to `/ba-generate-html` to regenerate the interactive HTML document.
+
+## References
+
+| File | Content |
+|------|---------|
+| `references/review-data-mapping.md` | Reverse mapping from ba-review.json to module JSON files |
+
+## Entry Point
+
+**FIRST ACTION:** Load `steps/step-01-apply.md`

package/templates/skills/{business-analyse → ba-review}/references/review-data-mapping.md

@@ -1,8 +1,8 @@
 # Review Data Mapping Reference (references/review-data-mapping.md)
 
-> **Used by:** step-06-review (Apply Review Corrections)
+> **Used by:** /ba-review step-01-apply (Apply Review Corrections)
 > **Purpose:** Reverse mapping from ba-review.json (HTML export) back to module JSON files format
-> **Complement of:** `references/html-data-mapping.md` (forward mapping)
+> **Complement of:** `/ba-generate-html/references/data-mapping.md` (forward mapping)
 
 ---