@atlashub/smartstack-cli 4.80.0 → 5.0.0

package/templates/skills/business-analyse/create-ba-order/cli/create-ba-order/__tests__/generate.test.ts

@@ -0,0 +1,151 @@
+/**
+ * generate.test.ts — Tests for BA order markdown generation.
+ */
+import { describe, it, expect } from 'vitest';
+import { generateBaOrder } from '../generate.js';
+import type { BaOrderPlan, ModuleKey } from '../types.js';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function minimalPlan(overrides: Partial<BaOrderPlan> = {}): BaOrderPlan {
+  return {
+    generatedAt: '2026-05-26',
+    apps: ['ERP'],
+    totalModules: 2,
+    totalDeps: 1,
+    waves: [
+      {
+        level: 1,
+        modules: [
+          {
+            appCode: 'ERP',
+            moduleCode: 'REFERENCES',
+            key: 'ERP/REFERENCES' as ModuleKey,
+            dependsOn: [],
+            isExternal: false,
+            warnings: [],
+          },
+        ],
+      },
+      {
+        level: 2,
+        modules: [
+          {
+            appCode: 'ERP',
+            moduleCode: 'CUSTOMERS',
+            key: 'ERP/CUSTOMERS' as ModuleKey,
+            dependsOn: ['ERP/REFERENCES' as ModuleKey],
+            isExternal: false,
+            warnings: [],
+          },
+        ],
+      },
+    ],
+    cycles: [],
+    warnings: [],
+    source: 'context',
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('generateBaOrder', () => {
+  it('produces markdown with anchor comment', () => {
+    const plan = minimalPlan();
+    const file = generateBaOrder(plan, '_plan/ba-order.md');
+
+    expect(file.path).toBe('_plan/ba-order.md');
+    expect(file.content).toContain('<!-- ba:plan kind=ba-order');
+    expect(file.content).toContain('generated=2026-05-26');
+    expect(file.content).toContain('apps=ERP');
+    expect(file.content).toContain('source=context');
+  });
+
+  it('includes heading with module and wave count', () => {
+    const plan = minimalPlan();
+    const file = generateBaOrder(plan, '_plan/ba-order.md');
+
+    expect(file.content).toContain("# Ordre d'analyse BA — ERP");
+    expect(file.content).toContain('2 modules · 2 vagues');
+  });
+
+  it('includes summary table', () => {
+    const plan = minimalPlan();
+    const file = generateBaOrder(plan, '_plan/ba-order.md');
+
+    expect(file.content).toContain('| Modules dans le scope | 2 |');
+    expect(file.content).toContain('| Vagues BA | 2 |');
+    expect(file.content).toContain('| Dépendances inter-modules | 1 |');
+  });
+
+  it('generates wave sections with dependency info', () => {
+    const plan = minimalPlan();
+    const file = generateBaOrder(plan, '_plan/ba-order.md');
+
+    expect(file.content).toContain('## Wave 1 — Fondations');
+    expect(file.content).toContain('| ERP/REFERENCES | — |');
+    expect(file.content).toContain('## Wave 2');
+    expect(file.content).toContain('| ERP/CUSTOMERS | ERP/REFERENCES |');
+  });
+
+  it('includes Mermaid graph', () => {
+    const plan = minimalPlan();
+    const file = generateBaOrder(plan, '_plan/ba-order.md');
+
+    expect(file.content).toContain('```mermaid');
+    expect(file.content).toContain('graph LR');
+    expect(file.content).toContain('ERP_REFERENCES["ERP/REFERENCES"]');
+    expect(file.content).toContain('ERP_REFERENCES --> ERP_CUSTOMERS');
+  });
+
+  it('includes next steps with BA phase order', () => {
+    const plan = minimalPlan();
+    const file = generateBaOrder(plan, '_plan/ba-order.md');
+
+    expect(file.content).toContain('/ba-create-actors');
+    expect(file.content).toContain('/ba-create-screen');
+  });
+
+  it('renders external prerequisites in Wave 0', () => {
+    const plan = minimalPlan({
+      waves: [
+        {
+          level: 0,
+          modules: [
+            {
+              appCode: 'HR',
+              moduleCode: 'EMPLOYEES',
+              key: 'HR/EMPLOYEES' as ModuleKey,
+              dependsOn: [],
+              isExternal: true,
+              referencedBy: ['ERP/CUSTOMERS' as ModuleKey],
+              warnings: [],
+            },
+          ],
+        },
+        ...minimalPlan().waves,
+      ],
+    });
+    const file = generateBaOrder(plan, '_plan/ba-order.md');
+
+    expect(file.content).toContain('Wave 0 — Prérequis externes');
+    expect(file.content).toContain('HR/EMPLOYEES');
+    expect(file.content).toContain('ERP/CUSTOMERS');
+  });
+
+  it('renders cycle warnings', () => {
+    const plan = minimalPlan({
+      cycles: [['X/A' as ModuleKey, 'X/B' as ModuleKey]],
+      warnings: ['Dépendance cyclique détectée : X/A ↔ X/B'],
+    });
+    const file = generateBaOrder(plan, '_plan/ba-order.md');
+
+    expect(file.content).toContain('Dépendances cycliques');
+    expect(file.content).toContain('X/A ↔ X/B');
+  });
+});

package/templates/skills/business-analyse/create-ba-order/cli/create-ba-order/__tests__/graph.test.ts

@@ -0,0 +1,173 @@
+/**
+ * graph.test.ts — Tests for BA order dependency graph and topological sort.
+ */
+import { describe, it, expect } from 'vitest';
+import { buildBaOrderPlan } from '../graph.js';
+import type { ModuleDep, ModuleKey, BaWave } from '../types.js';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Create a minimal ModuleDep for testing. */
+function mod(
+  app: string,
+  module: string,
+  deps: string[] = [],
+): ModuleDep {
+  return {
+    appCode: app,
+    moduleCode: module,
+    key: `${app}/${module}` as ModuleKey,
+    dependsOn: deps as ModuleKey[],
+  };
+}
+
+/** Get internal (non-external) waves. */
+function baWaves(waves: BaWave[]): BaWave[] {
+  return waves.filter((w) => w.level > 0);
+}
+
+/** Get module keys from a wave. */
+function waveKeys(wave: BaWave): string[] {
+  return wave.modules.map((m) => m.key).sort();
+}
+
+// ---------------------------------------------------------------------------
+// buildBaOrderPlan
+// ---------------------------------------------------------------------------
+
+describe('buildBaOrderPlan', () => {
+  it('places all independent modules in Wave 1', () => {
+    const modules = [
+      mod('CRM', 'CONTACTS'),
+      mod('CRM', 'SETTINGS'),
+      mod('BILLING', 'PRODUCTS'),
+    ];
+    const plan = buildBaOrderPlan(modules, ['CRM', 'BILLING']);
+    const waves = baWaves(plan.waves);
+
+    expect(waves).toHaveLength(1);
+    expect(waves[0].level).toBe(1);
+    expect(waveKeys(waves[0])).toEqual([
+      'BILLING/PRODUCTS',
+      'CRM/CONTACTS',
+      'CRM/SETTINGS',
+    ]);
+    expect(plan.cycles).toHaveLength(0);
+    expect(plan.source).toBe('context');
+  });
+
+  it('chains dependent modules across waves', () => {
+    const modules = [
+      mod('ERP', 'REFERENCES'),
+      mod('ERP', 'CUSTOMERS', ['ERP/REFERENCES']),
+    ];
+    const plan = buildBaOrderPlan(modules, ['ERP']);
+    const waves = baWaves(plan.waves);
+
+    expect(waves).toHaveLength(2);
+    expect(waveKeys(waves[0])).toEqual(['ERP/REFERENCES']);
+    expect(waveKeys(waves[1])).toEqual(['ERP/CUSTOMERS']);
+  });
+
+  it('handles diamond dependencies', () => {
+    // BILLING depends on REFERENCES and CUSTOMERS; both are independent
+    const modules = [
+      mod('ERP', 'REFERENCES'),
+      mod('ERP', 'CUSTOMERS'),
+      mod('ERP', 'BILLING', ['ERP/REFERENCES', 'ERP/CUSTOMERS']),
+    ];
+    const plan = buildBaOrderPlan(modules, ['ERP']);
+    const waves = baWaves(plan.waves);
+
+    expect(waves).toHaveLength(2);
+    expect(waveKeys(waves[0])).toEqual(['ERP/CUSTOMERS', 'ERP/REFERENCES']);
+    expect(waveKeys(waves[1])).toEqual(['ERP/BILLING']);
+  });
+
+  it('handles a linear chain A → B → C', () => {
+    const modules = [
+      mod('A', 'REF'),
+      mod('A', 'CLIENTS', ['A/REF']),
+      mod('A', 'ORDERS', ['A/CLIENTS']),
+    ];
+    const plan = buildBaOrderPlan(modules, ['A']);
+    const waves = baWaves(plan.waves);
+
+    expect(waves).toHaveLength(3);
+    expect(waveKeys(waves[0])).toEqual(['A/REF']);
+    expect(waveKeys(waves[1])).toEqual(['A/CLIENTS']);
+    expect(waveKeys(waves[2])).toEqual(['A/ORDERS']);
+  });
+
+  it('places external deps in Wave 0', () => {
+    // INVOICES depends on CRM/CONTACTS, but CRM is not in scope
+    const modules = [
+      mod('BILLING', 'INVOICES', ['CRM/CONTACTS']),
+    ];
+    const plan = buildBaOrderPlan(modules, ['BILLING']);
+
+    const wave0 = plan.waves.find((w) => w.level === 0);
+    expect(wave0).toBeDefined();
+    expect(wave0!.modules).toHaveLength(1);
+    expect(wave0!.modules[0].key).toBe('CRM/CONTACTS');
+    expect(wave0!.modules[0].isExternal).toBe(true);
+    expect(wave0!.modules[0].referencedBy).toContain('BILLING/INVOICES');
+
+    // INVOICES should be in Wave 1 (its only dep is external)
+    const waves = baWaves(plan.waves);
+    expect(waves).toHaveLength(1);
+    expect(waveKeys(waves[0])).toEqual(['BILLING/INVOICES']);
+  });
+
+  it('detects and groups cycles in the same wave', () => {
+    // A depends on B, B depends on A
+    const modules = [
+      mod('X', 'A', ['X/B']),
+      mod('X', 'B', ['X/A']),
+    ];
+    const plan = buildBaOrderPlan(modules, ['X']);
+
+    expect(plan.cycles).toHaveLength(1);
+    expect(plan.cycles[0].sort()).toEqual(['X/A', 'X/B']);
+
+    // Both should be in the same wave
+    const waves = baWaves(plan.waves);
+    expect(waves).toHaveLength(1);
+    expect(waveKeys(waves[0])).toEqual(['X/A', 'X/B']);
+  });
+
+  it('handles cross-app dependencies within scope', () => {
+    const modules = [
+      mod('CRM', 'CONTACTS'),
+      mod('BILLING', 'INVOICES', ['CRM/CONTACTS']),
+    ];
+    const plan = buildBaOrderPlan(modules, ['CRM', 'BILLING']);
+
+    // No external deps
+    expect(plan.waves.find((w) => w.level === 0)).toBeUndefined();
+
+    const waves = baWaves(plan.waves);
+    expect(waves).toHaveLength(2);
+    expect(waveKeys(waves[0])).toEqual(['CRM/CONTACTS']);
+    expect(waveKeys(waves[1])).toEqual(['BILLING/INVOICES']);
+  });
+
+  it('reports correct totalDeps', () => {
+    const modules = [
+      mod('CRM', 'CONTACTS'),
+      mod('CRM', 'PIPELINE', ['CRM/CONTACTS']),
+      mod('BILLING', 'INVOICES', ['CRM/CONTACTS', 'CRM/PIPELINE']),
+    ];
+    const plan = buildBaOrderPlan(modules, ['CRM', 'BILLING']);
+    expect(plan.totalDeps).toBe(3);
+  });
+
+  it('handles empty module list', () => {
+    const plan = buildBaOrderPlan([], ['CRM']);
+    expect(plan.waves).toHaveLength(0);
+    expect(plan.cycles).toHaveLength(0);
+    expect(plan.totalModules).toBe(0);
+  });
+});

package/templates/skills/business-analyse/create-ba-order/cli/create-ba-order/generate.ts

@@ -0,0 +1,273 @@
+/**
+ * generate.ts — Generate the BA order plan as Markdown + JSON.
+ *
+ * Produces:
+ * - Summary table
+ * - Wave 0 (external prerequisites) if applicable
+ * - Wave 1+ BA order tables
+ * - Mermaid dependency graph
+ * - Warnings
+ * - Next steps (which modules to analyze first)
+ */
+import type {
+  BaOrderPlan,
+  BaWave,
+  BaWaveModule,
+  GeneratedFile,
+  ModuleKey,
+} from './types.js';
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Generate the BA order plan markdown.
+ */
+export function generateBaOrder(
+  plan: BaOrderPlan,
+  outputPath: string,
+): GeneratedFile {
+  const lines: string[] = [];
+
+  lines.push(anchor(plan));
+  lines.push('');
+  lines.push(heading(plan));
+  lines.push('');
+  lines.push(summary(plan));
+  lines.push('');
+
+  // Wave 0 — external prerequisites
+  const wave0 = plan.waves.find((w) => w.level === 0);
+  if (wave0 && wave0.modules.length > 0) {
+    lines.push(externalPrereqs(wave0));
+    lines.push('');
+  }
+
+  // Wave 1+ — BA order waves
+  const baWaves = plan.waves.filter((w) => w.level > 0);
+  for (const wave of baWaves) {
+    lines.push(waveSection(wave));
+    lines.push('');
+  }
+
+  // Mermaid graph
+  lines.push(mermaidGraph(plan));
+  lines.push('');
+
+  // Cycles
+  if (plan.cycles.length > 0) {
+    lines.push(cyclesSection(plan.cycles));
+    lines.push('');
+  }
+
+  // Warnings
+  if (plan.warnings.length > 0) {
+    lines.push(warningsSection(plan.warnings));
+    lines.push('');
+  }
+
+  // Next steps
+  lines.push(nextSteps(plan));
+  lines.push('');
+
+  return { path: outputPath, content: lines.join('\n') };
+}
+
+// ---------------------------------------------------------------------------
+// Section generators
+// ---------------------------------------------------------------------------
+
+function anchor(plan: BaOrderPlan): string {
+  return `<!-- ba:plan kind=ba-order generated=${plan.generatedAt} apps=${plan.apps.join(',')} source=${plan.source} -->`;
+}
+
+function heading(plan: BaOrderPlan): string {
+  const baWaves = plan.waves.filter((w) => w.level > 0);
+  const inScopeModules = baWaves.reduce((sum, w) => sum + w.modules.length, 0);
+  return [
+    `# Ordre d'analyse BA — ${plan.apps.join(', ')}`,
+    '',
+    `_Généré le ${plan.generatedAt} · ${inScopeModules} modules · ${baWaves.length} vagues_`,
+  ].join('\n');
+}
+
+function summary(plan: BaOrderPlan): string {
+  const wave0 = plan.waves.find((w) => w.level === 0);
+  const baWaves = plan.waves.filter((w) => w.level > 0);
+  const externalCount = wave0?.modules.length ?? 0;
+  const inScopeModules = baWaves.reduce((sum, w) => sum + w.modules.length, 0);
+
+  return [
+    '## Résumé',
+    '',
+    '| Métrique | Valeur |',
+    '|----------|--------|',
+    `| Applications | ${plan.apps.length} (${plan.apps.join(', ')}) |`,
+    `| Modules dans le scope | ${inScopeModules} |`,
+    `| Prérequis externes | ${externalCount}${externalCount > 0 ? ' ⚠️' : ''} |`,
+    `| Vagues BA | ${baWaves.length} |`,
+    `| Dépendances inter-modules | ${plan.totalDeps} |`,
+    `| Cycles détectés | ${plan.cycles.length}${plan.cycles.length > 0 ? ' ⚠️' : ''} |`,
+    `| Source | Contexte menu (pré-data model) |`,
+  ].join('\n');
+}
+
+function externalPrereqs(wave0: BaWave): string {
+  const lines = [
+    '## ⚠️ Wave 0 — Prérequis externes',
+    '',
+    '> Modules hors scope référencés comme dépendances.',
+    '> Leur analyse BA doit être complétée en amont.',
+    '',
+    '| Module | Requis par |',
+    '|--------|------------|',
+  ];
+
+  for (const mod of wave0.modules) {
+    const refs = mod.referencedBy?.join(', ') ?? '—';
+    lines.push(`| ${mod.key} | ${refs} |`);
+  }
+
+  return lines.join('\n');
+}
+
+function waveSection(wave: BaWave): string {
+  const subtitle =
+    wave.level === 1
+      ? ' — Fondations (aucune dépendance intra-scope)'
+      : '';
+
+  const lines = [
+    `## Wave ${wave.level}${subtitle}`,
+    '',
+    '> Compléter **toutes les phases BA** (acteurs → use cases → règles → RBAC → data model → écrans) pour ces modules avant de passer à la vague suivante.',
+    '',
+    '| Module | Dépend de |',
+    '|--------|-----------|',
+  ];
+
+  for (const mod of wave.modules) {
+    const deps = mod.dependsOn.length > 0 ? mod.dependsOn.join(', ') : '—';
+    lines.push(`| ${mod.key} | ${deps} |`);
+  }
+
+  if (wave.modules.length > 1) {
+    lines.push('');
+    lines.push(`_${wave.modules.length} modules dans cette vague — parallélisables._`);
+  }
+
+  return lines.join('\n');
+}
+
+function mermaidGraph(plan: BaOrderPlan): string {
+  const lines = ['## Graphe de dépendances', '', '```mermaid', 'graph LR'];
+
+  const allWaves = plan.waves;
+  for (const wave of allWaves) {
+    const label =
+      wave.level === 0
+        ? 'Wave 0 — External'
+        : `Wave ${wave.level}`;
+    lines.push(`  subgraph "${label}"`);
+
+    for (const mod of wave.modules) {
+      const nodeId = mermaidNodeId(mod.key);
+      const prefix = mod.isExternal ? '⚠️ ' : '';
+      lines.push(`    ${nodeId}["${prefix}${mod.key}"]`);
+    }
+
+    lines.push('  end');
+  }
+
+  // Collect edges: dependency → dependent (arrow means "must be done before")
+  const edges = new Set<string>();
+  const baWaves = allWaves.filter((w) => w.level > 0);
+  for (const wave of baWaves) {
+    for (const mod of wave.modules) {
+      for (const dep of mod.dependsOn) {
+        const fromId = mermaidNodeId(dep);
+        const toId = mermaidNodeId(mod.key);
+        const edge = `  ${fromId} --> ${toId}`;
+        edges.add(edge);
+      }
+    }
+  }
+
+  // Add edges from externals to their dependents
+  const wave0 = allWaves.find((w) => w.level === 0);
+  if (wave0) {
+    for (const ext of wave0.modules) {
+      for (const ref of ext.referencedBy ?? []) {
+        const fromId = mermaidNodeId(ext.key);
+        const toId = mermaidNodeId(ref);
+        const edge = `  ${fromId} --> ${toId}`;
+        edges.add(edge);
+      }
+    }
+  }
+
+  for (const edge of edges) {
+    lines.push(edge);
+  }
+
+  lines.push('```');
+  return lines.join('\n');
+}
+
+/** Convert MODULE_KEY (APP/MODULE) to a valid Mermaid node ID. */
+function mermaidNodeId(key: ModuleKey | string): string {
+  return key.replace(/\//g, '_').replace(/-/g, '_');
+}
+
+function cyclesSection(cycles: ModuleKey[][]): string {
+  const lines = [
+    '## ⚠️ Dépendances cycliques',
+    '',
+    '> Les modules dans un cycle ont des dépendances mutuelles.',
+    '> Ils sont placés dans la même vague et doivent être co-analysés.',
+    '',
+  ];
+
+  for (let i = 0; i < cycles.length; i++) {
+    lines.push(`${i + 1}. ${cycles[i].join(' ↔ ')}`);
+  }
+
+  return lines.join('\n');
+}
+
+function warningsSection(warnings: string[]): string {
+  const lines = ['## ⚠️ Avertissements', ''];
+  for (const w of warnings) {
+    lines.push(`- ${w}`);
+  }
+  return lines.join('\n');
+}
+
+function nextSteps(plan: BaOrderPlan): string {
+  const lines = ['## Prochaines étapes', ''];
+  let step = 1;
+
+  const wave0 = plan.waves.find((w) => w.level === 0);
+  if (wave0 && wave0.modules.length > 0) {
+    lines.push(
+      `${step++}. **Wave 0** : compléter l'analyse BA des prérequis externes (${wave0.modules.map((m) => m.key).join(', ')})`,
+    );
+  }
+
+  const baWaves = plan.waves.filter((w) => w.level > 0);
+  for (const wave of baWaves) {
+    const moduleList = wave.modules.map((m) => `\`${m.key}\``).join(', ');
+    const parallel = wave.modules.length > 1 ? ' (parallélisable)' : '';
+    lines.push(
+      `${step++}. **Wave ${wave.level}** : phases 2-7 pour ${moduleList}${parallel}`,
+    );
+  }
+
+  lines.push('');
+  lines.push(
+    '> Pour chaque module : `/ba-create-actors` → `/ba-create-use-case` → `/ba-create-business-rules` → `/ba-create-rbac` → `/ba-create-data-model` → `/ba-create-screen`',
+  );
+
+  return lines.join('\n');
+}