@atlashub/smartstack-cli 4.80.0 → 5.0.0

package/templates/skills/business-analyse/references/04-file-allocation.md

@@ -1,162 +0,0 @@
-# File Allocation Rules
-
-> **Critical reference:** Defines which validation data belongs in `consolidation.json` vs `validation.json`.
-> Mixing contents across files is a BLOCKING ERROR.
-
-## Strict Allocation Table
-
-```
-+==============================================================================+
-|  FILE ALLOCATION REFERENCE — MANDATORY                                       |
-+==============================================================================+
-|                                                                              |
-|  consolidation.json contient UNIQUEMENT :                                    |
-|    - crossModuleInteractions                                                 |
-|    - sharedEntities                                                          |
-|    - permissionCoherence                                                     |
-|    - e2eFlows                                                                |
-|    - decision (approval)                                                     |
-|                                                                              |
-|  validation.json contient UNIQUEMENT :                                       |
-|    - semanticChecks                                                          |
-|    - contractChecks                                                          |
-|    - namingAudit                                                             |
-|    - acceptanceCriteria                                                      |
-|    - globalRiskAssessment                                                    |
-|                                                                              |
-|  INTERDICTION de melanger les contenus entre les deux fichiers.              |
-|  Toute cle ecrite dans le mauvais fichier = ERREUR BLOQUANTE.               |
-|                                                                              |
-+==============================================================================+
-```
-
-## Data Structures
-
-### consolidation.json structure
-
-```javascript
-{
-  crossModuleInteractions: [
-    {
-      fromModule: string,
-      toModule: string,
-      interactionType: "FK-reference|event|shared-lookup",
-      description: string,
-      entities: string[]
-    }
-  ],
-  sharedEntities: [
-    {
-      entity: string,
-      ownerModule: string,
-      referencedBy: string[],
-      sharedFields: string[]
-    }
-  ],
-  permissionCoherence: {
-    rolesConsistent: boolean,
-    pathFormatConsistent: boolean,
-    hierarchyRespected: boolean,
-    conflicts: any[],
-    warnings: any[]
-  },
-  e2eFlows: [
-    {
-      name: string,
-      modules: string[],
-      steps: object[]
-    }
-  ],
-  decision: {
-    approved: boolean,
-    reason: string,
-    approvedBy: string,
-    approvedAt: string
-  }
-}
-```
-
-### validation.json structure
-
-```javascript
-{
-  semanticChecks: [
-    {
-      check: string,
-      status: "PASS|WARNING|ERROR",
-      details: string[]
-    }
-  ],
-  contractChecks: [
-    {
-      module: string,
-      check: string,
-      details: string
-    }
-  ],
-  namingAudit: {
-    auditedAt: string,
-    issues: object[],
-    approved: boolean,
-    renames: object[]
-  },
-  acceptanceCriteria: [
-    {
-      module: string,
-      criteria: string,
-      type: "functional|business-rule|performance|security"
-    }
-  ],
-  globalRiskAssessment: [
-    {
-      risk: string,
-      severity: "low|medium|high",
-      mitigation?: string
-    }
-  ]
-}
-```
-
-## Data Writing Pattern
-
-Write consolidation.json:
-```javascript
-ba-writer.enrichSection({
-  featureId: {feature_id},
-  section: "consolidation",
-  data: {
-    crossModuleInteractions: [...],
-    sharedEntities: [...],
-    permissionCoherence: {...},
-    e2eFlows: [...],
-    decision: {...}
-  }
-});
-```
-
-Write validation.json:
-```javascript
-ba-writer.enrichSection({
-  featureId: {feature_id},
-  section: "validation",
-  data: {
-    semanticChecks: [...],
-    contractChecks: [...],
-    namingAudit: {...},
-    acceptanceCriteria: [...],
-    globalRiskAssessment: [...]
-  }
-});
-```
-
-## Validation Checklist
-
-Before writing either file, verify:
-
-- ✓ No keys from consolidation.json appear in validation.json
-- ✓ No keys from validation.json appear in consolidation.json
-- ✓ All cross-module FK references are in consolidation.json (not validation.json)
-- ✓ All semantic check results are in validation.json (not consolidation.json)
-- ✓ All naming audit results are in validation.json (not consolidation.json)
-- ✓ Client approval decision is in consolidation.json (not validation.json)
-- ✓ Risk assessment is in validation.json (not consolidation.json)

package/templates/skills/business-analyse/references/04-naming-audit-checks.md

@@ -1,174 +0,0 @@
-# Naming Audit Checks
-
-> **Purpose:** Validate that all application names, module codes, entity names, and permission paths follow conventions,
-> derive logically from their labels, and are free of collisions.
-
-## Naming Registry Collection
-
-Collect all names from the BA:
-
-```javascript
-const namingRegistry = {
-  application: {
-    label: application_name,
-    code: applicationCode,              // PascalCase
-    route: toKebabCase(applicationCode)  // kebab-case
-  },
-  modules: completedModules.map(m => ({
-    label: m.name,
-    code: m.code,                        // PascalCase
-    route: toKebabCase(m.code)           // kebab-case
-  })),
-  entities: completedModules.flatMap(m =>
-    m.entities.map(e => ({
-      name: e.name,                      // PascalCase (C# class name)
-      module: m.code,
-      tableName: e.tableName || pluralize(e.name)  // Plural convention
-    }))
-  ),
-  permissionRoots: [...new Set(
-    permissionPaths.map(p => p.path.split('.').slice(0, 2).join('.'))
-  )]
-};
-```
-
-## Naming Recap Display
-
-```
-═══════════════════════════════════════════════════════════════
-  NAMING AUDIT — {application_name}
-═══════════════════════════════════════════════════════════════
-
-APPLICATION
-| Label | Code (PascalCase) | Route (kebab-case) |
-|-------|-------------------|--------------------|
-| {application_name} | {applicationCode} | /{route} |
-
-MODULES
-| # | Label | Code (PascalCase) | Route (kebab-case) |
-|---|-------|-------------------|--------------------|
-{for each module: index | label | code | /app-route/module-route}
-
-ENTITIES
-| Entity (PascalCase) | Module | Table (plural) |
-|----------------------|--------|----------------|
-{for each entity: name | module | tableName}
-
-PERMISSION ROOTS
-{for each root: path}
-═══════════════════════════════════════════════════════════════
-```
-
-## Coherence Checks
-
-```javascript
-const namingIssues = [];
-
-// 1. Duplicate entity names across modules
-const entityNames = namingRegistry.entities.map(e => e.name);
-const duplicates = entityNames.filter((n, i) => entityNames.indexOf(n) !== i);
-if (duplicates.length > 0) {
-  namingIssues.push({ severity: "ERROR", issue: `Duplicate entity names: ${[...new Set(duplicates)].join(', ')}` });
-}
-
-// 2. Module code vs label coherence (code should derive logically from label)
-for (const mod of namingRegistry.modules) {
-  if (!mod.code || mod.code.length < 2) {
-    namingIssues.push({ severity: "ERROR", issue: `Module "${mod.label}" has invalid code: "${mod.code}"` });
-  }
-}
-
-// 3. Permission root alignment with module codes
-for (const root of namingRegistry.permissionRoots) {
-  const [appSegment, moduleSegment] = root.split('.');
-  const matchingModule = namingRegistry.modules.find(m =>
-    m.code.toLowerCase() === moduleSegment.toLowerCase()
-  );
-  if (!matchingModule) {
-    namingIssues.push({ severity: "WARNING", issue: `Permission root "${root}" has no matching module code` });
-  }
-}
-
-// 4. Route collision detection
-const allRoutes = namingRegistry.modules.map(m =>
-  `/${namingRegistry.application.route}/${m.route}`
-);
-const routeDuplicates = allRoutes.filter((r, i) => allRoutes.indexOf(r) !== i);
-if (routeDuplicates.length > 0) {
-  namingIssues.push({ severity: "ERROR", issue: `Route collisions: ${routeDuplicates.join(', ')}` });
-}
-```
-
-## MCP Validation
-
-```
-mcp__smartstack__validate_conventions({
-  checks: ["tables"],
-  context: {
-    applicationCode: applicationCode,
-    modules: namingRegistry.modules.map(m => m.code),
-    entities: namingRegistry.entities.map(e => e.name)
-  }
-})
-
-→ Merge MCP findings into namingIssues[]
-```
-
-## User Confirmation Flow
-
-**IF namingIssues.length > 0:**
-
-Display issues table:
-```
-| # | Severity | Issue |
-|---|----------|-------|
-{for each issue}
-```
-
-Ask via AskUserQuestion:
-```
-question: "{language == 'fr'
-  ? 'Validez-vous les noms ci-dessus pour l\\'ensemble de l\\'application ?'
-  : 'Do you approve all the names above for the entire application?'}"
-header: "Naming Audit"
-options:
-  - label: "{language == 'fr' ? 'Approuvé' : 'Approved'}"
-    description: "{language == 'fr' ? 'Tous les noms sont corrects' : 'All names are correct'}"
-  - label: "{language == 'fr' ? 'Renommer certains éléments' : 'Rename some elements'}"
-    description: "{language == 'fr' ? 'Corriger des noms avant de finaliser' : 'Fix names before finalizing'}"
-```
-
-**IF "Renommer certains éléments":**
-
-Ask via AskUserQuestion (open-ended):
-```
-question: "{language == 'fr'
-  ? 'Quels éléments souhaitez-vous renommer ? (ex: \"Module Ventes → Commerce\", \"Entity Invoice → BillingDocument\")'
-  : 'Which elements do you want to rename? (e.g., \"Module Sales → Commerce\", \"Entity Invoice → BillingDocument\")'}"
-header: "Renaming"
-```
-
-Process user response:
-1. Parse rename instructions
-2. Update `applicationCode`, module codes, entity names, permission paths accordingly in JSON files via ba-writer
-3. Re-run coherence checks on updated names
-4. Re-run MCP validation on updated names
-5. Re-display the naming recap table for final confirmation
-
-**IF "Approuvé":**
-
-Store naming audit result in `validation.json`:
-```javascript
-ba-writer.enrichSection({
-  featureId: {feature_id},
-  section: "namingAudit",
-  data: {
-    auditedAt: now(),
-    issues: namingIssues,
-    approved: true,
-    renames: []  // or list of applied renames
-  }
-});
-```
-
-Continue to next section.

package/templates/skills/business-analyse/references/04-semantic-validation-matrix.md

@@ -1,118 +0,0 @@
-# Semantic Validation Matrix
-
-> **Purpose:** Define all semantic validation checks and contract verification rules required before consolidation approval.
-> These checks catch data integrity gaps and ensure downstream skills have complete information.
-
-## 13 Semantic Checks (Per Module)
-
-Execute these checks for each completed module:
-
-```javascript
-const semanticChecks = [
-  { check: "permission-orpheline", severity: "WARNING" },
-  { check: "uc-sans-fr", severity: "WARNING" },
-  { check: "entity-sans-endpoint", severity: "WARNING" },
-  { check: "uc-sans-scenario", severity: "WARNING" },
-  { check: "role-sans-permissions", severity: "WARNING" },
-  { check: "navigation-sans-traduction", severity: "ERROR" },
-  { check: "lifecycle-terminal", severity: "WARNING" },
-  { check: "schema-conformity", severity: "ERROR" },
-  { check: "wireframe-coverage", severity: "ERROR" },
-  { check: "entity-doublon", severity: "ERROR" },
-  { check: "permission-fantome", severity: "ERROR" },
-  { check: "dashboard-coverage", severity: "WARNING" },
-  { check: "permission-uc-alignment", severity: "WARNING" }
-];
-```
-
-**Blocking rule:** 0 ERROR → PASS, ≥1 ERROR → BLOCK (user must fix before proceeding)
-
-## Contract Verification (Per Module)
-
-Verify the data contract that downstream skills (`/business-analyse-handoff`, `/business-analyse-develop`) depend on.
-These checks catch gaps that abstract semantic checks miss.
-
-```javascript
-for (const module of completedModules) {
-  const ent = module.entities || [];
-  const brs = ba-reader.readSection(module.code, "rules")?.rules || [];
-  const ucs = ba-reader.readSection(module.code, "usecases")?.useCases || [];
-  const perms = ba-reader.readSection(module.code, "permissions");
-
-  // CHECK 1: BR-CALC must have formula (C13)
-  for (const br of brs) {
-    if (br.category === 'calculation' && !br.formula) {
-      errors.push({module: module.code, check: "br-calc-sans-formula",
-        details: `${br.id} is category:calculation but missing 'formula' field`});
-    }
-  }
-
-  // CHECK 2: Computed attributes must have corresponding BR-CALC (C11)
-  for (const entity of ent) {
-    for (const attr of (entity.attributes || [])) {
-      if (attr.computed === true) {
-        const hasBRCalc = brs.some(br =>
-          br.category === 'calculation' && (br.entities || []).includes(entity.name)
-        );
-        if (!hasBRCalc) {
-          errors.push({module: module.code, check: "computed-sans-br-calc",
-            details: `${entity.name}.${attr.name} is computed:true but no BR-CALC references ${entity.name}`});
-        }
-      }
-    }
-  }
-
-  // CHECK 3: UC count minimum (C6)
-  if (ucs.length < 4) {
-    errors.push({module: module.code, check: "uc-count-critical",
-      details: `Only ${ucs.length} use cases (minimum: 4)`});
-  } else if (ucs.length < 6) {
-    warnings.push({module: module.code, check: "uc-count-low",
-      details: `Only ${ucs.length} use cases (recommended: >= 6)`});
-  }
-
-  // CHECK 4: Permission path count (C7)
-  const permCount = perms?.permissionPaths?.length || 0;
-  if (permCount < 5) {
-    warnings.push({module: module.code, check: "permission-count-low",
-      details: `Only ${permCount} permission paths (recommended: >= 5 — check for missing Export/Import)`});
-  }
-
-  // CHECK 5: Versioned attributes detection (C15)
-  const sensitiveKeywords = ['salary', 'rate', 'grade', 'price', 'tarif'];
-  for (const entity of ent) {
-    for (const attr of (entity.attributes || [])) {
-      if (sensitiveKeywords.some(k => attr.name.toLowerCase().includes(k))) {
-        if (!entity.versionedAttributes?.length) {
-          warnings.push({module: module.code, check: "missing-versioned-attributes",
-            details: `${entity.name}.${attr.name} may need versioning but no versionedAttributes defined`});
-        }
-      }
-    }
-  }
-}
-```
-
-## Execution Logic
-
-```javascript
-for (const module of completedModules) {
-  for (const check of semanticChecks) {
-    const result = executeSemanticCheck(module, check);
-    if (result.status === "ERROR") {
-      errors.push({module: module.code, check: check.check, details: result.details});
-    } else if (result.status === "WARNING") {
-      warnings.push({module: module.code, check: check.check, details: result.details});
-    }
-  }
-}
-
-// Blocking rule: 0 ERROR → PASS, ≥1 ERROR → BLOCK (ask user for each)
-if (errors.length > 0) {
-  BLOCKING_ERROR("Semantic validation failed");
-  for (const error of errors) {
-    ERROR(`  [${error.module}] ${error.check}: ${error.details}`);
-  }
-  STOP - User must fix before proceeding
-}
-```

package/templates/skills/business-analyse/references/acceptance-criteria.md

@@ -1,164 +0,0 @@
-# Module Acceptance Criteria (Shared Reference)
-
-> **Loaded by:** step-03-specify (post-check), business-analyse-develop step-01-task (input validation)
-> **Purpose:** Define measurable, bash-verifiable acceptance criteria that a module MUST pass before being marked "specified".
-> **Key principle:** These checks read the REAL JSON files on disk — NOT in-memory data the model "thinks" it wrote.
-
----
-
-## Why Bash-Verifiable?
-
-All previous checks were **pseudocode interpreted by the model**. The model can "decide" a check passes even when it fails (hallucination of validation). Bash checks are **objective** — they read the actual file and count real elements.
-
----
-
-## Acceptance Criteria Table
-
-| # | Criterion | Minimum | Field Path | Blocking | Category |
-|---|-----------|---------|------------|----------|----------|
-| AC-01 | Entities present | 2 | `analysis.entities[]` | YES | Data Model |
-| AC-02 | Entity attributes have `type` field | ALL | `analysis.entities[].attributes[].type` | YES | Data Model |
-| AC-03 | Use cases present | 2 | `specification.useCases[]` | YES | Requirements |
-| AC-04 | Functional requirements present | 4 | `specification.functionalRequirements[]` | YES | Requirements |
-| AC-05 | Wireframes present | 1 | `specification.uiWireframes[] \|\| specification.wireframes[]` | YES | UI |
-| AC-06 | Wireframes >= sections | count match | wireframes.length >= sections.length | YES | UI |
-| AC-07 | Wireframe content non-empty | ALL | `wireframe.mockup \|\| wireframe.ascii \|\| wireframe.content` | YES | UI |
-| AC-08 | Sections present | 1 | `specification.sections[]` | YES | UI |
-| AC-09 | SeedDataCore 9 arrays non-empty | 9/9 | `specification.seedDataCore.*` | YES | Seed Data |
-| AC-10 | Gherkin scenarios is array | `Array.isArray` | `specification.gherkinScenarios` | YES | Format |
-| AC-11 | API endpoints present | 1 | `specification.apiEndpoints[]` | YES | API |
-| AC-12 | Messages present | 4 | `specification.messages[]` | YES | Messages |
-| AC-13 | Validations present | 1 | `specification.validations[]` | YES | Validation |
-| AC-14 | Wireframe field naming | canonical | `screen` not `title`, `mockup` not `ascii` | WARNING | Convention |
-| AC-15 | Validation rules format | ALL array | `specification.validations[].rules` is `Array` | YES | Format |
-| AC-16 | Messages have `message` field | ALL present | `specification.messages[].message` truthy | YES | Format |
-| AC-17 | Gherkin content structure | ALL valid | Each element has `feature` (string) + `scenarios` (array) | YES | Format |
-
----
-
-## Bash Verification Script (node -e)
-
-> **Usage:** Called from step-03 post-check after writing module JSON files.
-> Also callable standalone for debugging: `node -e "..." path/to/index.json`
-
-```bash
-MODULE_JSON="{module_feature_json_path}"
-node -e "
-const fs = require('fs');
-const data = JSON.parse(fs.readFileSync(process.argv[1], 'utf-8'));
-const spec = data.specification || {};
-const analysis = data.analysis || {};
-const wf = spec.uiWireframes || spec.wireframes || [];
-const sections = spec.sections || [];
-const sdc = spec.seedDataCore || {};
-
-const checks = [
-  ['AC-01: entities >= 2',          (analysis.entities||[]).length,               2],
-  ['AC-03: useCases >= 2',          (spec.useCases||[]).length,                   2],
-  ['AC-04: FRs >= 4',               (spec.functionalRequirements||[]).length,     4],
-  ['AC-05: wireframes >= 1',        wf.length,                                    1],
-  ['AC-06: wireframes >= sections', wf.length,                                    sections.length],
-  ['AC-08: sections >= 1',          sections.length,                               1],
-  ['AC-09: seedDataCore 9 arrays',  Object.keys(sdc).filter(k => Array.isArray(sdc[k]) && sdc[k].length > 0).length, 9],
-  ['AC-10: gherkin is array',       Array.isArray(spec.gherkinScenarios) ? 1 : 0,  1],
-  ['AC-11: apiEndpoints >= 1',      (spec.apiEndpoints||[]).length,                1],
-  ['AC-12: messages >= 4',          (spec.messages||[]).length,                    4],
-  ['AC-13: validations >= 1',       (spec.validations||[]).length,                 1]
-];
-
-const fails = [];
-checks.forEach(c => {
-  if (c[1] < c[2]) {
-    fails.push(c);
-    console.error('FAIL: ' + c[0] + ' = ' + c[1] + ' (min: ' + c[2] + ')');
-  }
-});
-
-// AC-02: Entity attribute types
-const badAttrs = (analysis.entities||[]).flatMap(e =>
-  (e.attributes||[]).filter(a => !a.type).map(a => e.name + '.' + a.name)
-);
-if (badAttrs.length > 0) {
-  fails.push(['AC-02: attr.type missing', badAttrs.length, 0]);
-  console.error('FAIL: AC-02: ' + badAttrs.length + ' attributes without type: ' + badAttrs.slice(0, 5).join(', ') + (badAttrs.length > 5 ? '...' : ''));
-}
-
-// AC-07: Wireframe content non-empty
-const emptyWf = wf.filter(w => !w.mockup && !w.ascii && !w.content);
-if (emptyWf.length > 0) {
-  fails.push(['AC-07: wireframe content empty', emptyWf.length, 0]);
-  console.error('FAIL: AC-07: ' + emptyWf.length + ' wireframes have EMPTY content');
-}
-
-// AC-14: Wireframe field naming (WARNING only)
-const badFields = wf.filter(w => w.title || w.ascii || (w.name && !w.screen));
-if (badFields.length > 0) {
-  console.warn('WARNING: AC-14: ' + badFields.length + ' wireframes use non-canonical field names (title/ascii/name)');
-}
-
-// AC-15: Validation rules format (rules must be array, not string)
-const badRules = (spec.validations||[]).filter(v => v.rules && !Array.isArray(v.rules));
-if (badRules.length > 0) {
-  fails.push(['AC-15: validations[].rules not array', badRules.length, 0]);
-  console.error('FAIL: AC-15: ' + badRules.length + ' validations have rules as string instead of array');
-}
-
-// AC-16: Messages must have 'message' field
-const noMsg = (spec.messages||[]).filter(m => !m.message);
-if (noMsg.length > 0) {
-  fails.push(['AC-16: messages[].message missing', noMsg.length, 0]);
-  console.error('FAIL: AC-16: ' + noMsg.length + ' messages missing "message" field');
-}
-
-// AC-17: Gherkin content structure (each element needs feature + scenarios[])
-if (Array.isArray(spec.gherkinScenarios)) {
-  const badGherkin = spec.gherkinScenarios.filter(g => !g.feature || !Array.isArray(g.scenarios));
-  if (badGherkin.length > 0) {
-    fails.push(['AC-17: gherkin content invalid', badGherkin.length, 0]);
-    console.error('FAIL: AC-17: ' + badGherkin.length + ' gherkin entries missing feature or scenarios[]');
-  }
-}
-
-// Summary
-if (fails.length > 0) {
-  console.error('\\nBLOCKING: ' + fails.length + ' acceptance criteria FAILED');
-  process.exit(1);
-}
-console.log('PASS: All acceptance criteria met (AC-01 to AC-17)');
-" "$MODULE_JSON"
-```
-
----
-
-## Integration Points
-
-### 1. step-03-specify.md (post-check)
-
-After writing module JSON files, run the bash script above.
-IF FAIL → re-execute section 11 write with corrected data → re-run until PASS.
-
-### 2. business-analyse-develop step-01-task.md (input validation)
-
-At PRD load time, run the bash script on each module index.json.
-IF FAIL → BLOCKING: "Module {name} does not meet acceptance criteria — run /business-analyse to fix".
-This prevents business-analyse-develop from generating code from incomplete specifications.
-
----
-
-## Recovery Actions per Criterion
-
-| Criterion | Recovery |
-|-----------|----------|
-| AC-01/02 | Re-run step-03 entity specification |
-| AC-03/04 | Re-run step-03 use case / functional requirements |
-| AC-05/06/07 | Re-run step-03 wireframe generation |
-| AC-08 | Re-run step-03 section definition |
-| AC-09 | Re-run step-03 seedDataCore transform |
-| AC-10 | Auto-fix: wrap in array `[gherkinScenarios]` |
-| AC-11 | Re-run step-03 API endpoints |
-| AC-12 | Re-run step-03 messages |
-| AC-13 | Re-run step-03 validations |
-| AC-14 | Auto-fix: rename title→screen, ascii→mockup |
-| AC-15 | Auto-fix: wrap string in array `[rules]` |
-| AC-16 | Auto-fix: copy `description` → `message` |
-| AC-17 | Re-run step-03 gherkin — ensure each entry has `feature` string + `scenarios` array |