aiad-sdd 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Steeve Evers — AIAD Framework
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,146 @@
+# aiad-sdd
+
+**Spec Driven Development pour Claude Code** — Framework de développement spec-first avec agents IA.
+
+```bash
+npx aiad-sdd init
+```
+
+---
+
+## Qu'est-ce que SDD Mode ?
+
+SDD Mode (Spec Driven Development Mode) est le framework de développement d'[AIAD](https://aiad.ovh). Il définit comment les équipes transforment des intentions produit en code de qualité en faisant des SPECs le pivot entre l'humain et l'agent IA.
+
+**3 principes fondateurs :**
+
+1. **Spec as Living Invariant** — La SPEC reste la source de vérité entre intention et code
+2. **Drift = Échec de processus** — Code et SPEC toujours synchronisés
+3. **Context Budget** — Le PE gère le budget de contexte de chaque session agent
+
+## Installation
+
+```bash
+# Initialisation complète (structure + gouvernance + commandes Claude Code)
+npx aiad-sdd init
+
+# Sans les agents de gouvernance
+npx aiad-sdd init --sans-gouvernance
+
+# Mettre à jour les agents de gouvernance
+npx aiad-sdd gouvernance
+
+# Voir l'état du projet
+npx aiad-sdd status
+```
+
+## Ce qui est installé
+
+### Structure `.aiad/`
+
+```
+.aiad/
+├── PRD.md                  ← Vision produit (template)
+├── ARCHITECTURE.md         ← Standards techniques (template)
+├── AGENT-GUIDE.md          ← Contexte permanent agent (template)
+├── gouvernance/            ← Agents Tier 1 (droit de veto)
+│   ├── CLAUDE-AI-ACT.md    ← Conformité EU AI Act
+│   ├── CLAUDE-RGPD.md      ← Privacy by Design, RGPD
+│   ├── CLAUDE-RGAA.md      ← Accessibilité RGAA 4.1 / WCAG 2.1
+│   └── CLAUDE-RGESN.md     ← Écoconception numérique
+├── intents/                ← Intent Statements
+│   └── _index.md
+├── specs/                  ← SPECs techniques
+│   └── _index.md
+└── CHANGELOG-ARTEFACTS.md  ← Historique des mises à jour
+```
+
+### Commandes Claude Code
+
+| Commande | Phase | Description |
+|----------|-------|-------------|
+| `/sdd-init` | Cadrage | Initialiser PRD + ARCHITECTURE + AGENT-GUIDE |
+| `/sdd-intent` | Intention | Capturer un Intent Statement (POURQUOI) |
+| `/sdd-spec` | Spécification | Rédiger une SPEC depuis un Intent |
+| `/sdd-gate` | Validation | Execution Gate + Spec Quality Score |
+| `/sdd-validate` | Validation | Valider le code produit par l'agent |
+| `/sdd-drift-check` | Intégration | Vérifier synchronisation artefacts/code |
+| `/aiad-retro` | Amélioration | Rétrospective de fin d'itération |
+| `/aiad-intention` | Alignement | Atelier d'Intention (rituel mensuel) |
+| `/aiad-status` | Monitoring | État du projet SDD |
+
+### CLAUDE.md
+
+Un `CLAUDE.md` est créé (ou enrichi) avec le contexte SDD Mode complet : cycle de développement, hiérarchie documentaire, règles absolues, gouvernance.
+
+## Cycle de développement
+
+```
+┌─────────────┐     ┌──────────┐     ┌──────────────┐
+│  /sdd-intent │────▶│ /sdd-spec │────▶│  /sdd-gate   │
+│  Intention   │     │  SPEC    │     │  SQS ≥ 4/5   │
+└─────────────┘     └──────────┘     └──────┬───────┘
+                                             │
+     ┌───────────────────────────────────────┘
+     ▼
+┌──────────────┐     ┌──────────────┐     ┌────────────────┐
+│  Développement│────▶│ /sdd-validate│────▶│/sdd-drift-check│
+│  Agent IA    │     │  Validation  │     │  Drift Lock    │
+└──────────────┘     └──────────────┘     └────────────────┘
+```
+
+## Démarrage rapide
+
+```bash
+# 1. Initialiser SDD Mode
+npx aiad-sdd init
+
+# 2. Dans Claude Code, lancer le cadrage
+/sdd-init
+
+# 3. Capturer la première intention
+/sdd-intent
+
+# 4. Rédiger la première SPEC
+/sdd-spec
+
+# 5. Valider la SPEC (Execution Gate)
+/sdd-gate
+
+# 6. Développer (Claude Code gère l'orchestration agent)
+
+# 7. Valider et verrouiller
+/sdd-validate
+/sdd-drift-check
+```
+
+## Agents de gouvernance
+
+Les 4 agents Tier 1 ont un **droit de veto** sur toute implémentation non conforme :
+
+| Agent | Périmètre | Référentiel |
+|-------|-----------|-------------|
+| **CLAUDE-AI-ACT** | Composants IA | Règlement (UE) 2024/1689 |
+| **CLAUDE-RGPD** | Données personnelles | RGPD + ePrivacy |
+| **CLAUDE-RGAA** | Interfaces utilisateur | RGAA 4.1 / WCAG 2.1 |
+| **CLAUDE-RGESN** | Écoconception | RGESN v2 |
+
+## Compatibilité
+
+SDD Mode est conçu pour Claude Code mais les artefacts sont compatibles avec :
+- **Cursor** — `.aiad/AGENT-GUIDE.md` ↔ Memory Bank (`.cursor/rules`)
+- **AWS Kiro** — `.aiad/` ↔ `.kiro/` (steering files)
+- **GitHub Spec Kit** — `.aiad/specs/` ↔ Spec files
+
+## Framework AIAD
+
+AIAD (AI-Agent Iterative Development) est un framework open source pour le développement logiciel à l'ère des agents IA.
+
+- **Site** : [aiad.ovh](https://aiad.ovh)
+- **Constitution** : 6 valeurs fondatrices, gouvernance gardien/communauté
+- **5 responsabilités** : PM, Product Engineer, Agents Engineer, QA Engineer, Tech Lead
+- **ALIS** : Système d'évolution lunaire (mise à jour à chaque pleine lune)
+
+## Licence
+
+MIT — Steeve Evers — [aiad.ovh](https://aiad.ovh)

package/bin/aiad-sdd.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+
+import { argv, exit, cwd } from 'node:process';
+import { init } from '../lib/init.js';
+import { addGovernance } from '../lib/governance.js';
+import { showStatus } from '../lib/status.js';
+
+const VERSION = '1.0.0';
+const command = argv[2];
+const flags = argv.slice(3);
+
+const AIDE = `
+  aiad-sdd v${VERSION} — Spec Driven Development pour Claude Code
+  https://aiad.ovh
+
+  Commandes :
+    init [options]        Initialise SDD Mode dans le projet courant
+    gouvernance           Ajoute/met à jour les agents de gouvernance
+    status                Affiche l'état SDD du projet
+    help                  Affiche cette aide
+
+  Options init :
+    --sans-gouvernance    Initialise sans les agents de gouvernance
+    --force               Écrase les fichiers existants
+
+  Exemples :
+    npx aiad-sdd init                  Initialisation complète
+    npx aiad-sdd init --force          Réinitialisation (écrase)
+    npx aiad-sdd gouvernance           Met à jour les agents de gouvernance
+    npx aiad-sdd status                État du projet SDD
+
+  Framework AIAD — AI-Agent Iterative Development — Open Source
+`;
+
+async function main() {
+  switch (command) {
+    case 'init':
+      await init(cwd(), {
+        sansGouvernance: flags.includes('--sans-gouvernance'),
+        force: flags.includes('--force'),
+      });
+      break;
+
+    case 'gouvernance':
+      await addGovernance(cwd(), { force: flags.includes('--force') });
+      break;
+
+    case 'status':
+      await showStatus(cwd());
+      break;
+
+    case 'help':
+    case '--help':
+    case '-h':
+    case undefined:
+      console.log(AIDE);
+      break;
+
+    case 'version':
+    case '--version':
+    case '-v':
+      console.log(`aiad-sdd v${VERSION}`);
+      break;
+
+    default:
+      console.error(`\n  Commande inconnue : "${command}"\n`);
+      console.log(AIDE);
+      exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error('\n  Erreur :', err.message);
+  exit(1);
+});

package/lib/governance.js

@@ -0,0 +1,101 @@
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const TEMPLATES_DIR = join(__dirname, '..', 'templates');
+
+const COULEURS = {
+  vert: '\x1b[32m',
+  jaune: '\x1b[33m',
+  cyan: '\x1b[36m',
+  gris: '\x1b[90m',
+  gras: '\x1b[1m',
+  reset: '\x1b[0m',
+};
+
+const AGENTS = [
+  { fichier: 'CLAUDE-AI-ACT.md', nom: 'EU AI Act', description: 'Conformité Règlement (UE) 2024/1689' },
+  { fichier: 'CLAUDE-RGPD.md', nom: 'RGPD', description: 'Privacy by Design, conformité RGPD' },
+  { fichier: 'CLAUDE-RGAA.md', nom: 'RGAA', description: 'Accessibilité numérique RGAA 4.1 / WCAG 2.1' },
+  { fichier: 'CLAUDE-RGESN.md', nom: 'RGESN', description: 'Écoconception de services numériques' },
+];
+
+export async function addGovernance(projetDir, options = {}) {
+  const { force = false, silencieux = false } = options;
+
+  if (!silencieux) {
+    console.log(`\n${COULEURS.cyan}${COULEURS.gras}  AIAD — Agents de Gouvernance${COULEURS.reset}\n`);
+  }
+
+  const gouvernanceDir = join(projetDir, '.aiad', 'gouvernance');
+  if (!existsSync(gouvernanceDir)) {
+    mkdirSync(gouvernanceDir, { recursive: true });
+  }
+
+  const sourceDir = join(TEMPLATES_DIR, '.aiad', 'gouvernance');
+
+  for (const agent of AGENTS) {
+    const source = join(sourceDir, agent.fichier);
+    const dest = join(gouvernanceDir, agent.fichier);
+
+    if (!existsSync(source)) {
+      console.log(`  ${COULEURS.jaune}?${COULEURS.reset} ${agent.fichier} — template non trouvé`);
+      continue;
+    }
+
+    if (existsSync(dest) && !force) {
+      console.log(`  ${COULEURS.jaune}~${COULEURS.reset} ${agent.nom} ${COULEURS.gris}(existe déjà, ignoré)${COULEURS.reset}`);
+    } else {
+      const contenu = readFileSync(source, 'utf-8');
+      writeFileSync(dest, contenu, 'utf-8');
+      console.log(`  ${COULEURS.vert}+${COULEURS.reset} ${agent.nom} — ${agent.description}`);
+    }
+  }
+
+  // Créer l'index des agents de gouvernance
+  const indexContenu = `# Agents de Gouvernance AIAD — Tier 1
+
+> Ces agents ont un **droit de veto** sur toute implémentation non conforme.
+> Ils sont injectés dans chaque session de développement via le CLAUDE.md.
+
+## Agents installés
+
+| Agent | Fichier | Périmètre |
+|-------|---------|-----------|
+${AGENTS.map(a => `| **${a.nom}** | \`${a.fichier}\` | ${a.description} |`).join('\n')}
+
+## Activation
+
+Les agents de gouvernance sont activés par défaut dans le CLAUDE.md.
+Pour désactiver temporairement un agent, commentez la ligne correspondante dans CLAUDE.md.
+
+## Hiérarchie
+
+\`\`\`
+Constitution AIAD (valeurs immuables)
+  └── Agents de Gouvernance Tier 1 (droit de veto)
+       ├── CLAUDE-AI-ACT    → Tout composant IA
+       ├── CLAUDE-RGPD      → Toute donnée personnelle
+       ├── CLAUDE-RGAA      → Toute interface utilisateur
+       └── CLAUDE-RGESN     → Toute décision technique
+            └── AGENT-GUIDE projet (contexte permanent)
+                 └── SPEC (activation par tâche)
+\`\`\`
+
+## Mise à jour
+
+Les agents de gouvernance suivent le cycle ALIS (mise à jour à chaque pleine lune).
+Pour mettre à jour : \`npx aiad-sdd gouvernance --force\`
+`;
+
+  const indexDest = join(gouvernanceDir, '_index.md');
+  writeFileSync(indexDest, indexContenu, 'utf-8');
+
+  if (!silencieux) {
+    console.log(`\n  ${COULEURS.vert}+${COULEURS.reset} Index de gouvernance créé`);
+    console.log(`\n  ${COULEURS.gris}4 agents Tier 1 installés — droit de veto actif${COULEURS.reset}\n`);
+  }
+}

package/lib/init.js

@@ -0,0 +1,176 @@
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+import { addGovernance } from './governance.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const TEMPLATES_DIR = join(__dirname, '..', 'templates');
+
+const COULEURS = {
+  vert: '\x1b[32m',
+  jaune: '\x1b[33m',
+  cyan: '\x1b[36m',
+  gris: '\x1b[90m',
+  gras: '\x1b[1m',
+  reset: '\x1b[0m',
+};
+
+function log(symbole, message) {
+  console.log(`  ${symbole} ${message}`);
+}
+
+function logCreation(chemin) {
+  log(`${COULEURS.vert}+${COULEURS.reset}`, chemin);
+}
+
+function logExiste(chemin) {
+  log(`${COULEURS.jaune}~${COULEURS.reset}`, `${chemin} ${COULEURS.gris}(existe déjà, ignoré)${COULEURS.reset}`);
+}
+
+function logEcrase(chemin) {
+  log(`${COULEURS.jaune}!${COULEURS.reset}`, `${chemin} ${COULEURS.gris}(écrasé)${COULEURS.reset}`);
+}
+
+function ecrireFichier(destination, contenu, force = false) {
+  if (existsSync(destination) && !force) {
+    logExiste(relative(process.cwd(), destination));
+    return false;
+  }
+  const dir = dirname(destination);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(destination, contenu, 'utf-8');
+  if (force && existsSync(destination)) {
+    logEcrase(relative(process.cwd(), destination));
+  } else {
+    logCreation(relative(process.cwd(), destination));
+  }
+  return true;
+}
+
+function copierDossierRecursif(source, destination, force = false) {
+  if (!existsSync(source)) return;
+  const elements = readdirSync(source);
+  for (const element of elements) {
+    const cheminSource = join(source, element);
+    const cheminDest = join(destination, element);
+    const stat = statSync(cheminSource);
+    if (stat.isDirectory()) {
+      if (!existsSync(cheminDest)) {
+        mkdirSync(cheminDest, { recursive: true });
+      }
+      copierDossierRecursif(cheminSource, cheminDest, force);
+    } else {
+      const contenu = readFileSync(cheminSource, 'utf-8');
+      ecrireFichier(cheminDest, contenu, force);
+    }
+  }
+}
+
+export async function init(projetDir, options = {}) {
+  const { sansGouvernance = false, force = false } = options;
+
+  console.log(`
+${COULEURS.cyan}${COULEURS.gras}  AIAD SDD Mode — Initialisation${COULEURS.reset}
+${COULEURS.gris}  Spec Driven Development pour Claude Code${COULEURS.reset}
+`);
+
+  // 1. Structure .aiad/
+  console.log(`${COULEURS.gras}  Structure .aiad/${COULEURS.reset}\n`);
+
+  const aiadDir = join(projetDir, '.aiad');
+  const dossiers = [
+    join(aiadDir, 'intents'),
+    join(aiadDir, 'intents', 'archive'),
+    join(aiadDir, 'specs'),
+    join(aiadDir, 'specs', 'archive'),
+  ];
+
+  for (const dossier of dossiers) {
+    if (!existsSync(dossier)) {
+      mkdirSync(dossier, { recursive: true });
+      logCreation(relative(projetDir, dossier) + '/');
+    }
+  }
+
+  // Copier les templates .aiad/
+  copierDossierRecursif(
+    join(TEMPLATES_DIR, '.aiad'),
+    aiadDir,
+    force
+  );
+
+  // 2. Commandes Claude Code
+  console.log(`\n${COULEURS.gras}  Commandes Claude Code (.claude/commands/)${COULEURS.reset}\n`);
+
+  copierDossierRecursif(
+    join(TEMPLATES_DIR, '.claude'),
+    join(projetDir, '.claude'),
+    force
+  );
+
+  // 3. CLAUDE.md
+  console.log(`\n${COULEURS.gras}  Configuration agent (CLAUDE.md)${COULEURS.reset}\n`);
+
+  const claudeMdSource = join(TEMPLATES_DIR, 'CLAUDE.md');
+  const claudeMdDest = join(projetDir, 'CLAUDE.md');
+
+  if (existsSync(claudeMdDest) && !force) {
+    // Append SDD section si CLAUDE.md existe déjà
+    const contenuExistant = readFileSync(claudeMdDest, 'utf-8');
+    if (!contenuExistant.includes('# SDD Mode')) {
+      const sddSection = readFileSync(claudeMdSource, 'utf-8');
+      writeFileSync(claudeMdDest, contenuExistant + '\n\n' + sddSection, 'utf-8');
+      log(`${COULEURS.vert}+${COULEURS.reset}`, 'CLAUDE.md — section SDD Mode ajoutée');
+    } else {
+      logExiste('CLAUDE.md (section SDD Mode déjà présente)');
+    }
+  } else {
+    const contenu = readFileSync(claudeMdSource, 'utf-8');
+    ecrireFichier(claudeMdDest, contenu, force);
+  }
+
+  // 4. Gouvernance
+  if (!sansGouvernance) {
+    console.log(`\n${COULEURS.gras}  Agents de gouvernance${COULEURS.reset}\n`);
+    await addGovernance(projetDir, { force, silencieux: true });
+  }
+
+  // 5. .gitignore update
+  const gitignorePath = join(projetDir, '.gitignore');
+  if (existsSync(gitignorePath)) {
+    const gitignore = readFileSync(gitignorePath, 'utf-8');
+    if (!gitignore.includes('.aiad/intents/archive')) {
+      writeFileSync(gitignorePath, gitignore + '\n# AIAD SDD Mode\n# (aucun fichier ignoré — tout est versionné)\n', 'utf-8');
+    }
+  }
+
+  // Résumé
+  console.log(`
+${COULEURS.cyan}${COULEURS.gras}  SDD Mode initialisé avec succès !${COULEURS.reset}
+
+${COULEURS.gras}  Prochaines étapes :${COULEURS.reset}
+
+  ${COULEURS.cyan}1.${COULEURS.reset} Rédiger le PRD           ${COULEURS.gris}→ .aiad/PRD.md${COULEURS.reset}
+  ${COULEURS.cyan}2.${COULEURS.reset} Définir l'architecture   ${COULEURS.gris}→ .aiad/ARCHITECTURE.md${COULEURS.reset}
+  ${COULEURS.cyan}3.${COULEURS.reset} Configurer l'agent       ${COULEURS.gris}→ .aiad/AGENT-GUIDE.md${COULEURS.reset}
+  ${COULEURS.cyan}4.${COULEURS.reset} Commencer à spécifier    ${COULEURS.gris}→ /sdd-intent dans Claude Code${COULEURS.reset}
+
+${COULEURS.gras}  Commandes disponibles dans Claude Code :${COULEURS.reset}
+
+  ${COULEURS.cyan}/sdd-init${COULEURS.reset}          Cadrage initial (PRD + ARCHITECTURE)
+  ${COULEURS.cyan}/sdd-intent${COULEURS.reset}        Capturer une intention (Intent Statement)
+  ${COULEURS.cyan}/sdd-spec${COULEURS.reset}          Rédiger une SPEC depuis un Intent
+  ${COULEURS.cyan}/sdd-gate${COULEURS.reset}          Valider une SPEC (Execution Gate + SQS)
+  ${COULEURS.cyan}/sdd-validate${COULEURS.reset}      Valider le code produit par l'agent
+  ${COULEURS.cyan}/sdd-drift-check${COULEURS.reset}   Vérifier la synchronisation artefacts/code
+  ${COULEURS.cyan}/aiad-retro${COULEURS.reset}        Rétrospective de fin d'itération
+  ${COULEURS.cyan}/aiad-intention${COULEURS.reset}    Atelier d'Intention (rituel mensuel)
+  ${COULEURS.cyan}/aiad-status${COULEURS.reset}       État du projet SDD
+
+  ${COULEURS.gris}Framework AIAD v1.5 — SDD Mode v1.1 — aiad.ovh${COULEURS.reset}
+`);
+}

package/lib/status.js

@@ -0,0 +1,109 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+const COULEURS = {
+  vert: '\x1b[32m',
+  rouge: '\x1b[31m',
+  jaune: '\x1b[33m',
+  cyan: '\x1b[36m',
+  gris: '\x1b[90m',
+  gras: '\x1b[1m',
+  reset: '\x1b[0m',
+};
+
+function check(condition) {
+  return condition
+    ? `${COULEURS.vert}OK${COULEURS.reset}`
+    : `${COULEURS.rouge}--${COULEURS.reset}`;
+}
+
+function compterFichiersMd(dir) {
+  if (!existsSync(dir)) return 0;
+  return readdirSync(dir).filter(f => f.endsWith('.md') && !f.startsWith('_')).length;
+}
+
+export async function showStatus(projetDir) {
+  const aiadDir = join(projetDir, '.aiad');
+
+  if (!existsSync(aiadDir)) {
+    console.log(`
+${COULEURS.rouge}  SDD Mode non initialisé dans ce projet.${COULEURS.reset}
+  Lancez : ${COULEURS.cyan}npx aiad-sdd init${COULEURS.reset}
+`);
+    return;
+  }
+
+  const hasPrd = existsSync(join(aiadDir, 'PRD.md'));
+  const hasArchi = existsSync(join(aiadDir, 'ARCHITECTURE.md'));
+  const hasGuide = existsSync(join(aiadDir, 'AGENT-GUIDE.md'));
+  const hasClaude = existsSync(join(projetDir, 'CLAUDE.md'));
+  const hasCommands = existsSync(join(projetDir, '.claude', 'commands'));
+
+  const nbIntents = compterFichiersMd(join(aiadDir, 'intents'));
+  const nbSpecs = compterFichiersMd(join(aiadDir, 'specs'));
+  const nbGouv = compterFichiersMd(join(aiadDir, 'gouvernance'));
+
+  // Vérifier le contenu du PRD (non-template)
+  let prdRempli = false;
+  if (hasPrd) {
+    const contenu = readFileSync(join(aiadDir, 'PRD.md'), 'utf-8');
+    prdRempli = !contenu.includes('[Titre fonctionnel court]');
+  }
+
+  let archiRempli = false;
+  if (hasArchi) {
+    const contenu = readFileSync(join(aiadDir, 'ARCHITECTURE.md'), 'utf-8');
+    archiRempli = !contenu.includes('[max 5 principes]');
+  }
+
+  let guideRempli = false;
+  if (hasGuide) {
+    const contenu = readFileSync(join(aiadDir, 'AGENT-GUIDE.md'), 'utf-8');
+    guideRempli = !contenu.includes('[Nom du projet]');
+  }
+
+  console.log(`
+${COULEURS.cyan}${COULEURS.gras}  AIAD SDD Mode — État du projet${COULEURS.reset}
+${COULEURS.gris}  ${projetDir}${COULEURS.reset}
+
+${COULEURS.gras}  Artefacts fondamentaux${COULEURS.reset}
+
+  ${check(hasPrd)}  PRD.md              ${prdRempli ? COULEURS.vert + 'rédigé' : hasPrd ? COULEURS.jaune + 'template' : COULEURS.gris + 'absent'}${COULEURS.reset}
+  ${check(hasArchi)}  ARCHITECTURE.md     ${archiRempli ? COULEURS.vert + 'rédigé' : hasArchi ? COULEURS.jaune + 'template' : COULEURS.gris + 'absent'}${COULEURS.reset}
+  ${check(hasGuide)}  AGENT-GUIDE.md      ${guideRempli ? COULEURS.vert + 'rédigé' : hasGuide ? COULEURS.jaune + 'template' : COULEURS.gris + 'absent'}${COULEURS.reset}
+
+${COULEURS.gras}  Cycle SDD${COULEURS.reset}
+
+  Intent Statements    ${COULEURS.cyan}${nbIntents}${COULEURS.reset} actif(s)
+  SPECs                ${COULEURS.cyan}${nbSpecs}${COULEURS.reset} active(s)
+
+${COULEURS.gras}  Infrastructure${COULEURS.reset}
+
+  ${check(hasClaude)}  CLAUDE.md           ${hasClaude ? COULEURS.vert + 'configuré' : COULEURS.gris + 'absent'}${COULEURS.reset}
+  ${check(hasCommands)}  Commandes Claude    ${hasCommands ? COULEURS.vert + 'installées' : COULEURS.gris + 'absentes'}${COULEURS.reset}
+  ${check(nbGouv >= 4)}  Gouvernance         ${COULEURS.cyan}${nbGouv}${COULEURS.reset} agent(s) Tier 1
+
+${COULEURS.gras}  Maturité SDD${COULEURS.reset}
+
+  ${getMaturite(hasPrd, prdRempli, hasArchi, archiRempli, hasGuide, guideRempli, nbIntents, nbSpecs)}
+`);
+}
+
+function getMaturite(hasPrd, prdRempli, hasArchi, archiRempli, hasGuide, guideRempli, nbIntents, nbSpecs) {
+  const score = [prdRempli, archiRempli, guideRempli, nbIntents > 0, nbSpecs > 0]
+    .filter(Boolean).length;
+
+  const niveaux = [
+    { seuil: 0, label: 'Non initialisé', couleur: COULEURS.rouge },
+    { seuil: 1, label: 'Démarrage', couleur: COULEURS.jaune },
+    { seuil: 2, label: 'Cadrage', couleur: COULEURS.jaune },
+    { seuil: 3, label: 'Opérationnel', couleur: COULEURS.cyan },
+    { seuil: 4, label: 'Actif', couleur: COULEURS.vert },
+    { seuil: 5, label: 'Complet', couleur: COULEURS.vert },
+  ];
+
+  const niveau = niveaux[score];
+  const barre = '█'.repeat(score) + '░'.repeat(5 - score);
+
+  return `${niveau.couleur}${barre} ${niveau.label}${COULEURS.reset} ${COULEURS.gris}(${score}/5)${COULEURS.reset}`;
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "aiad-sdd",
+  "version": "1.0.0",
+  "description": "AIAD SDD Mode — Spec Driven Development pour Claude Code. Framework de développement spec-first avec agents IA.",
+  "keywords": [
+    "aiad",
+    "sdd",
+    "spec-driven-development",
+    "claude-code",
+    "ai-agents",
+    "product-engineering",
+    "spec-first",
+    "context-engineering"
+  ],
+  "author": "Steeve Evers <evers.steeve@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aiad-framework/aiad-sdd"
+  },
+  "homepage": "https://aiad.ovh",
+  "bin": {
+    "aiad-sdd": "./bin/aiad-sdd.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "templates/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "type": "module"
+}