create-go-plate 0.0.0-stage → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+## 0.1.1 — 2026-10-18
+
+- README complet : démarrage rapide, fonctionnement, commandes, garde-fous, options, compatibilité, FAQ.
+- Liens vers le dépôt GitHub dans la fiche npm.
+- Tests automatiques du générateur sur Linux, macOS et Windows (Node 20, 22, 24).
+
+## 0.1.0 — 2026-10-18
+
+Première version.
+
+- Générateur `npm create go-plate` (interactif ou `--yes`), sans dépendance.
+- Cadrage : `AGENTS.md` source unique, PRD, architecture, design, règles, sécurité, tests,
+  journal de session, ADR, specs par fonctionnalité.
+- Skills : `/cadrage`, `/stress-test`, `/spec`, `/fin-de-session`, `/audit-securite`.
+- Sous-agents : `reviewer`, `test-writer`.
+- Module Claude Code : permissions, hooks (reprise de contexte, protection des secrets et du git
+  destructif, formatage automatique), `.mcp.json` (Context7, Playwright).
+- Modules optionnels : CI GitHub Actions + Dependabot, fonctionnalités IA (`docs/AI.md`, `evals/`).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jeanpierregaba
+
+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

@@ -1,3 +1,346 @@
-# Temporary Holding Version
+# create-go-plate
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**Le point de départ structuré pour développer une application avec un agent de code.**
+
+[![npm](https://img.shields.io/npm/v/create-go-plate?color=cb3837&logo=npm)](https://www.npmjs.com/package/create-go-plate)
+[![Tests](https://github.com/Jeanpierregaba/create-go-plate/actions/workflows/test.yml/badge.svg)](https://github.com/Jeanpierregaba/create-go-plate/actions/workflows/test.yml)
+[![Node](https://img.shields.io/node/v/create-go-plate?logo=node.js&logoColor=white)](https://nodejs.org)
+[![Licence MIT](https://img.shields.io/npm/l/create-go-plate)](LICENSE)
+
+```bash
+npm create go-plate@latest mon-projet
+```
+
+Une commande, et ton projet démarre avec tout ce qu'il faut pour que l'agent (Claude Code, Codex,
+Cursor, Copilot, Gemini…) construise **la bonne application, proprement, sans perdre le fil** :
+cadrage produit et technique, spécifications par fonctionnalité, mémoire entre les sessions,
+garde-fous de sécurité et vérifications automatiques.
+
+---
+
+## Sommaire
+
+- [Pourquoi go-plate ?](#pourquoi-go-plate-)
+- [Démarrage rapide](#démarrage-rapide)
+- [Comment ça marche](#comment-ça-marche)
+- [Ce qui est généré](#ce-qui-est-généré)
+- [Les commandes de l'agent](#les-commandes-de-lagent)
+- [Les garde-fous automatiques](#les-garde-fous-automatiques)
+- [Options du générateur](#options-du-générateur)
+- [Compatibilité](#compatibilité)
+- [FAQ](#faq)
+- [Contribuer](#contribuer)
+
+---
+
+## Pourquoi go-plate ?
+
+Un agent de code écrit vite. Sans cadre, il écrit aussi vite **dans la mauvaise direction** :
+
+| Sans cadrage | Avec go-plate |
+|---|---|
+| L'agent devine ce que tu veux construire | Un PRD et une spec par fonctionnalité, validés avant le code |
+| Chaque session repart de zéro | Le contexte (tâches en cours, dernière session) est réinjecté automatiquement |
+| Les choix techniques sont remis en cause en permanence | Chaque décision est tracée dans un ADR |
+| Clés exposées, accès non contrôlés, dépendances inventées | Checklist sécurité, audit dédié, fichiers sensibles bloqués |
+| « Ça marche » sans preuve | Lint, typecheck et tests lancés par l'agent, CI à chaque push |
+
+go-plate ne choisit **aucune stack** à ta place : c'est l'agent qui te la propose pendant le
+cadrage, en fonction de ton projet, et qui vérifie les versions à jour.
+
+---
+
+## Démarrage rapide
+
+### Prérequis
+
+- [Node.js](https://nodejs.org) 20.16 ou plus récent
+- Un agent de code — de préférence [Claude Code](https://claude.com/claude-code), qui profite de
+  toutes les fonctionnalités (voir [Compatibilité](#compatibilité))
+- Git (recommandé)
+
+### 1. Créer le projet
+
+```bash
+npm create go-plate@latest mon-projet
+```
+
+Le générateur pose 4 questions (Claude Code, CI GitHub, fonctionnalités IA, git) puis crée le
+dossier avec un premier commit. Pour accepter les choix par défaut :
+
+```bash
+npm create go-plate@latest mon-projet -- --yes
+```
+
+### 2. Cadrer le projet
+
+```bash
+cd mon-projet
+claude
+```
+
+Dans l'agent :
+
+```
+/cadrage
+```
+
+L'agent mène un entretien (4 questions maximum à la fois, avec des réponses proposées) et remplit
+pour toi, étape par étape :
+
+1. **Produit** — problème, utilisateurs, parcours, MVP, hors scope
+2. **Architecture** — stack proposée et justifiée, versions vérifiées, ADR
+3. **Design** — intention, design system, écrans, accessibilité
+4. **Stress-test** — ce qui va casser, cas limites oubliés, sur-engineering
+5. **Instructions de l'agent** — `AGENTS.md`
+6. **Garde-fous** — règles, sécurité, stratégie de test
+7. **Backlog** — `TASKS.md`
+8. **Outillage** — CI, formatage automatique, variables d'environnement, serveurs MCP
+9. **Squelette** — structure du code, qui compile et passe les tests à vide
+
+Tu peux t'arrêter à tout moment : `/cadrage` reprend à la première étape non terminée.
+
+### 3. Développer, une fonctionnalité à la fois
+
+```
+/spec inscription par email avec confirmation
+```
+
+L'agent crée `docs/specs/001-inscription/` avec la spec (le quoi), le plan (le comment) et la
+liste des tâches. **Tu valides chaque étape avant qu'il écrive du code.**
+
+---
+
+## Comment ça marche
+
+```
+ npm create go-plate                    une fois
+        │
+        ▼
+ /cadrage ─────────────────────────────  une fois : PRD, architecture, règles, backlog, squelette
+        │
+        ▼
+ ┌─► /spec <fonctionnalité> ───────────  spec → plan → tâches, validés par toi
+ │      │
+ │      ▼
+ │   implémentation tâche par tâche ──   lint + typecheck + tests après chaque tâche, commit
+ │      │
+ │      ▼
+ │   relecture (sous-agent reviewer)
+ │      │
+ │      ▼
+ └── /fin-de-session ──────────────────  TASKS.md + SESSION-LOG.md à jour
+        │
+        ▼
+ session suivante ─────────────────────  le hook SessionStart redonne le contexte à l'agent
+
+ avant la mise en production : /audit-securite
+```
+
+Le principe : **les documents sont la mémoire du projet**, les skills sont les procédures, les
+hooks et permissions sont les règles que l'agent ne peut pas contourner.
+
+---
+
+## Ce qui est généré
+
+```
+mon-projet/
+├── AGENTS.md                  instructions de l'agent — source unique, lue par tous les outils
+├── CLAUDE.md                  importe AGENTS.md + spécificités Claude Code
+├── TASKS.md                   avancement : en cours / à faire / terminé
+├── README.md
+├── .claude/
+│   ├── skills/                /cadrage, /spec, /stress-test, /fin-de-session, /audit-securite
+│   ├── agents/                sous-agents reviewer et test-writer
+│   ├── hooks/                 reprise de contexte, protection des fichiers, formatage
+│   └── settings.json          permissions et branchement des hooks
+├── .mcp.json                  Context7 (doc à jour des bibliothèques), Playwright (navigateur)
+├── .github/
+│   ├── workflows/ci.yml       CI à compléter pendant le cadrage
+│   └── dependabot.yml         mises à jour de sécurité automatiques
+├── docs/
+│   ├── PRD.md                 quoi construire et pourquoi
+│   ├── ARCHITECTURE.md        comment c'est construit
+│   ├── DESIGN.md              interface et expérience
+│   ├── RULES.md               interdits stricts
+│   ├── SECURITY.md            checklist sécurité
+│   ├── TESTING.md             définition de « fini »
+│   ├── SESSION-LOG.md         journal des sessions
+│   ├── decisions/             ADR : une décision technique = un fichier
+│   └── specs/                 une spec par fonctionnalité (spec → plan → tâches)
+├── src/                       squelette créé à la fin du cadrage
+├── .env.example
+├── .editorconfig
+└── .gitignore
+```
+
+En option (`--ai`) : `docs/AI.md` et `evals/` pour les applications qui appellent un LLM
+(prompts versionnés, évaluations, coûts, injection de prompt).
+
+Tous les fichiers sont des **modèles commentés** : chaque section explique ce qu'elle doit
+contenir. Rien ne t'oblige à passer par l'agent pour les remplir.
+
+---
+
+## Les commandes de l'agent
+
+| Commande | Quand l'utiliser | Ce qu'elle fait |
+|---|---|---|
+| `/cadrage` | Au début du projet | Entretien guidé et remplissage de tous les documents, jusqu'au squelette du code |
+| `/spec <description>` | Avant chaque fonctionnalité | Crée la spec, le plan et les tâches, à valider avant le code |
+| `/stress-test [fichier]` | Après un document important | Relecture critique : risques, cas limites, sur-engineering, contradictions |
+| `/fin-de-session` | À chaque arrêt | Met à jour l'avancement, le journal et les décisions |
+| `/audit-securite [périmètre]` | Avant une mise en production | Vérifie la checklist sécurité dans le code réel, rapport classé par gravité |
+
+Deux **sous-agents** complètent les skills :
+
+- **`reviewer`** relit les changements (exactitude, sécurité, règles, tests, simplicité) sans
+  modifier le code.
+- **`test-writer`** écrit les tests à partir de la spec, y compris avant l'implémentation pour
+  les parties critiques.
+
+---
+
+## Les garde-fous automatiques
+
+Avec Claude Code, ces règles sont **appliquées techniquement**, pas seulement demandées :
+
+| Protection | Mécanisme |
+|---|---|
+| L'agent ne lit ni ne modifie les fichiers `.env`, clés et certificats (`.env.example` reste accessible) | Hook `PreToolUse` + permissions |
+| Pas de `git push --force` ni de `git reset --hard` | Hook `PreToolUse` + permissions |
+| Pas de modification manuelle des fichiers de lock ni du dossier `.git` | Hook `PreToolUse` |
+| `git push`, `rm -rf`, `git clean`, `npm publish` demandent confirmation | Permissions |
+| Chaque fichier modifié est formaté | Hook `PostToolUse` (formateur choisi pendant le cadrage) |
+| Chaque session démarre avec le statut du cadrage, les tâches en cours et la dernière session | Hook `SessionStart` |
+
+Les hooks sont de simples scripts Node, lisibles et modifiables dans `.claude/hooks/`.
+
+---
+
+## Options du générateur
+
+```bash
+npm create go-plate@latest [dossier] -- [options]
+```
+
+| Option | Effet |
+|---|---|
+| `-y`, `--yes` | Accepte les choix par défaut sans poser de question |
+| `--no-claude` | Sans les fichiers propres à Claude Code (`CLAUDE.md`, hooks, permissions, `.mcp.json`) |
+| `--no-ci` | Sans GitHub Actions ni Dependabot |
+| `--ai` | Ajoute le module « fonctionnalités IA » |
+| `--no-git` | Sans initialiser de dépôt git |
+| `-f`, `--force` | Autorise un dossier cible non vide (les fichiers de même nom sont écrasés) |
+| `-h`, `--help` | Affiche l'aide |
+| `-v`, `--version` | Affiche la version |
+
+Avec `npm create`, les options se placent après `--`. Les commandes suivantes sont équivalentes :
+
+```bash
+npx create-go-plate mon-projet --yes
+```
+
+```bash
+pnpm create go-plate mon-projet --yes
+```
+
+```bash
+yarn create go-plate mon-projet --yes
+```
+
+```bash
+bun create go-plate mon-projet --yes
+```
+
+---
+
+## Compatibilité
+
+| Agent | Niveau de prise en charge |
+|---|---|
+| **Claude Code** | Complet : `CLAUDE.md`, skills en commandes `/`, sous-agents, hooks, permissions, MCP |
+| **Codex, Cursor, GitHub Copilot, Gemini CLI…** | `AGENTS.md` est lu nativement ; les skills sont des fichiers Markdown que l'agent peut suivre (« suis `.claude/skills/spec/SKILL.md` ») |
+
+| Système | Remarque |
+|---|---|
+| macOS, Linux | Aucune configuration particulière |
+| Windows | Installer [Git for Windows](https://git-scm.com/download/win) (les hooks passent par Git Bash). Pour le serveur MCP Playwright, remplacer `"command": "npx"` par `"command": "cmd"` et préfixer les `args` par `"/c", "npx"` dans `.mcp.json` |
+
+---
+
+## FAQ
+
+**Quelle stack technique est utilisée ?**
+Aucune n'est imposée. Pendant `/cadrage`, l'agent propose une stack adaptée à ton projet et à ton
+niveau, avec une alternative et les compromis, puis vérifie les versions actuelles dans la
+documentation officielle.
+
+**Je ne suis pas développeur, est-ce pour moi ?**
+Oui : le cadrage est un entretien en langage courant, et l'agent justifie chaque choix technique.
+Le cadre sert justement à éviter les pièges classiques des projets construits avec l'IA.
+
+**Puis-je l'ajouter à un projet existant ?**
+Oui, avec `--force` dans le dossier du projet, mais les fichiers de même nom (`README.md`,
+`.gitignore`…) sont **écrasés**. Le plus sûr : générer dans un dossier à part, puis copier ce
+dont tu as besoin.
+
+```bash
+npm create go-plate@latest go-plate-tmp -- --yes --no-git
+```
+
+**Je n'ai pas besoin de tous les fichiers.**
+Supprime-les : chaque document est indépendant. Pense seulement à retirer sa ligne dans le
+tableau « Où ranger quoi » d'`AGENTS.md`.
+
+**Le contenu est-il en anglais ?**
+Non, tous les modèles sont en français. L'agent te répondra dans la langue de tes messages.
+
+**Comment mettre à jour un projet déjà généré ?**
+Le générateur ne sait pas mettre à jour un projet existant. Pour profiter d'une nouvelle version, génère
+un projet temporaire et compare les fichiers qui t'intéressent (skills, hooks).
+
+---
+
+## Contribuer
+
+Les suggestions et corrections sont les bienvenues via les
+[issues](https://github.com/Jeanpierregaba/create-go-plate/issues) et les pull requests.
+
+```bash
+git clone https://github.com/Jeanpierregaba/create-go-plate.git
+```
+
+```bash
+cd create-go-plate && npm test
+```
+
+Essayer le générateur en local :
+
+```bash
+node bin/create.mjs /tmp/essai --yes
+```
+
+| Dossier | Contenu |
+|---|---|
+| `bin/create.mjs` | Le générateur (aucune dépendance, uniquement Node) |
+| `template/` | Fichiers copiés dans tous les projets |
+| `modules/claude/`, `modules/ci-github/`, `modules/ai/` | Fichiers copiés selon les options |
+| `test/` | Tests (`node --test`) |
+
+Le fichier `template/gitignore` est renommé en `.gitignore` à la génération, car npm ne publie
+pas les fichiers `.gitignore`.
+
+### Publier une version
+
+1. Mettre à jour `CHANGELOG.md`.
+2. `npm version patch` (ou `minor` / `major`).
+3. `npm publish` — les tests sont relancés automatiquement avant la publication.
+4. `git push --follow-tags`
+
+---
+
+## Licence
+
+[MIT](LICENSE) © 2026 Jeanpierregaba

package/bin/create.mjs

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+// Générateur : copie le cadrage de vibecoding dans un nouveau dossier projet.
+// Aucune dépendance : uniquement des modules natifs de Node.
+import { spawnSync } from "node:child_process";
+import { cpSync, existsSync, readdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+
+const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const { version } = JSON.parse(readFileSync(path.join(PACKAGE_ROOT, "package.json"), "utf8"));
+
+const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+const paint = (code) => (text) => (useColor ? `\x1b[${code}m${text}\x1b[0m` : text);
+const bold = paint(1);
+const dim = paint(2);
+const green = paint(32);
+const red = paint(31);
+const cyan = paint(36);
+
+const HELP = `
+${bold("create-go-plate")} ${dim(`v${version}`)}
+
+Crée un nouveau projet avec le cadrage pour développer avec un agent de code.
+
+${bold("Usage")}
+  npm create go-plate@latest [dossier] -- [options]
+  npx create-go-plate [dossier] [options]
+
+${bold("Options")}
+  -y, --yes       Accepte les choix par défaut sans poser de question
+  --no-claude     Sans les fichiers propres à Claude Code (CLAUDE.md, hooks, permissions, .mcp.json)
+  --no-ci         Sans la CI GitHub Actions ni Dependabot
+  --ai            Avec le module « fonctionnalités IA » (docs/AI.md, evals/)
+  --no-git        Sans initialiser de dépôt git
+  -f, --force     Autorise un dossier cible non vide (les fichiers existants sont écrasés)
+  -h, --help      Affiche cette aide
+  -v, --version   Affiche la version
+`;
+
+function fail(message) {
+  console.error(`\n${red("✖")} ${message}\n`);
+  process.exit(1);
+}
+
+let args;
+try {
+  args = parseArgs({
+    allowPositionals: true,
+    allowNegative: true,
+    options: {
+      yes: { type: "boolean", short: "y", default: false },
+      claude: { type: "boolean" },
+      ci: { type: "boolean" },
+      ai: { type: "boolean" },
+      git: { type: "boolean" },
+      force: { type: "boolean", short: "f", default: false },
+      help: { type: "boolean", short: "h", default: false },
+      version: { type: "boolean", short: "v", default: false },
+    },
+  });
+} catch (error) {
+  fail(`${error.message}\nLance avec --help pour voir les options.`);
+}
+
+const { values: flags, positionals } = args;
+if (flags.help) {
+  console.log(HELP);
+  process.exit(0);
+}
+if (flags.version) {
+  console.log(version);
+  process.exit(0);
+}
+
+const interactive = process.stdin.isTTY && process.stdout.isTTY && !flags.yes;
+const rl = interactive ? readline.createInterface({ input: process.stdin, output: process.stdout }) : null;
+
+function cancel() {
+  console.log(`\n\n${dim("Annulé, aucun fichier créé.")}\n`);
+  process.exit(130);
+}
+rl?.on("SIGINT", cancel);
+
+// Ctrl+D (fin de saisie) pendant une question : on annule proprement au lieu de planter.
+async function ask(prompt) {
+  try {
+    return (await rl.question(prompt)).trim();
+  } catch {
+    cancel();
+  }
+}
+
+async function askText(question, fallback) {
+  if (!rl) return fallback;
+  const answer = await ask(`${cyan("?")} ${question} ${dim(`(${fallback})`)} `);
+  return answer || fallback;
+}
+
+async function askYesNo(question, fallback) {
+  if (!rl) return fallback;
+  const hint = fallback ? "O/n" : "o/N";
+  const answer = (await ask(`${cyan("?")} ${question} ${dim(`(${hint})`)} `)).toLowerCase();
+  if (!answer) return fallback;
+  return ["o", "oui", "y", "yes"].includes(answer);
+}
+
+// Une option passée en ligne de commande l'emporte ; sinon on pose la question.
+const choose = (flag, question, fallback) => (flag !== undefined ? flag : askYesNo(question, fallback));
+
+console.log(`\n${bold("create-go-plate")} ${dim(`v${version}`)}\n`);
+
+const targetArg = positionals[0] ?? (await askText("Dossier du projet :", "mon-projet"));
+const targetDir = path.resolve(process.cwd(), targetArg);
+const projectName = path.basename(targetDir);
+
+if (existsSync(targetDir) && readdirSync(targetDir).length > 0 && !flags.force) {
+  rl?.close();
+  fail(`Le dossier ${bold(targetArg)} existe et n'est pas vide. Choisis un autre nom ou ajoute --force.`);
+}
+
+const options = {
+  claude: await choose(flags.claude, "Utiliser Claude Code (CLAUDE.md, hooks, permissions, MCP) ?", true),
+  ci: await choose(flags.ci, "Ajouter la CI GitHub Actions et Dependabot ?", true),
+  ai: await choose(flags.ai, "L'application aura-t-elle des fonctionnalités IA (appels à un LLM) ?", false),
+  git: await choose(flags.git, "Initialiser un dépôt git ?", true),
+};
+rl?.close();
+
+// 1. Copie de la base, puis des modules choisis.
+const copy = (from) =>
+  cpSync(path.join(PACKAGE_ROOT, from), targetDir, { recursive: true, force: true });
+
+copy("template");
+if (options.claude) copy("modules/claude");
+if (options.ci) copy("modules/ci-github");
+if (options.ai) copy("modules/ai");
+
+// 2. npm ne publie pas les fichiers .gitignore : le template le livre sous le nom "gitignore".
+const shippedGitignore = path.join(targetDir, "gitignore");
+if (existsSync(shippedGitignore)) renameSync(shippedGitignore, path.join(targetDir, ".gitignore"));
+
+// 3. Ajustements selon les choix.
+function edit(relativePath, transform) {
+  const file = path.join(targetDir, relativePath);
+  if (!existsSync(file)) return;
+  writeFileSync(file, transform(readFileSync(file, "utf8")));
+}
+
+edit("README.md", (text) => text.replaceAll("{{PROJECT_NAME}}", projectName));
+
+if (!options.claude) {
+  // Sans les permissions et hooks de Claude Code, ces règles ne sont plus bloquées techniquement.
+  edit("docs/RULES.md", (text) => text.replaceAll(" [bloqué]", ""));
+  edit("README.md", (text) => text.replace(/^\| `\.mcp\.json` .*\n/m, ""));
+}
+
+if (options.ai) {
+  edit("AGENTS.md", (text) =>
+    text.replace(
+      /^(\| Charte visuelle.*\n)/m,
+      "$1| Fonctionnalités IA : prompts, évals, coûts | `docs/AI.md`, `evals/` |\n"
+    )
+  );
+}
+
+// 4. Dépôt git avec un premier commit (ignoré proprement si git n'est pas disponible).
+let gitStatus = "non initialisé";
+if (options.git && !existsSync(path.join(targetDir, ".git"))) {
+  const git = (...gitArgs) => spawnSync("git", gitArgs, { cwd: targetDir, stdio: "ignore" }).status === 0;
+  if (!git("init", "-q")) {
+    gitStatus = "échec (git est-il installé ?)";
+  } else if (git("add", "-A") && git("commit", "-q", "-m", "chore: initialisation depuis create-go-plate")) {
+    gitStatus = "initialisé avec un premier commit";
+  } else {
+    gitStatus = "initialisé (premier commit impossible : configure user.name / user.email)";
+  }
+}
+
+// 5. Récapitulatif.
+const fromCwd = path.relative(process.cwd(), targetDir) || ".";
+const relativeTarget = fromCwd.startsWith("..") ? targetDir : fromCwd;
+const check = (on) => (on ? green("✔") : dim("–"));
+console.log(`
+${green("✔")} Projet créé dans ${bold(relativeTarget)}
+
+  ${check(true)} Cadrage (AGENTS.md, docs/, skills, sous-agents)
+  ${check(options.claude)} Claude Code (CLAUDE.md, hooks, permissions, .mcp.json)
+  ${check(options.ci)} CI GitHub Actions + Dependabot
+  ${check(options.ai)} Module IA (docs/AI.md, evals/)
+  ${check(options.git)} Git : ${gitStatus}
+
+${bold("Prochaines étapes")}
+  ${cyan(`cd ${relativeTarget}`)}
+  ${cyan("claude")}            ${dim("(ou ton agent de code)")}
+  ${cyan("/cadrage")}          ${dim("l'agent te pose les questions et remplit le cadrage")}
+`);

package/modules/ai/docs/AI.md

@@ -0,0 +1,20 @@
+# AI — Fonctionnalités basées sur un modèle de langage
+
+<!-- À REMPLIR si l'application appelle un LLM. Supprime ce fichier sinon. -->
+
+## Usages
+<!-- Pour chaque fonctionnalité IA : ce qu'elle fait, entrée, sortie attendue, modèle utilisé et pourquoi. -->
+
+## Prompts
+<!-- Où sont stockés les prompts (fichiers versionnés, pas des chaînes éparpillées dans le code),
+et règle : toute modification de prompt est suivie d'une exécution des évals. -->
+
+## Évaluations
+<!-- Comment on mesure la qualité : jeu de cas dans evals/, critères, seuil minimal. Voir evals/README.md. -->
+
+## Sécurité
+<!-- Séparation instructions / données externes (injection de prompt), outils accessibles au modèle,
+données envoyées au fournisseur (RGPD), sorties affichées sans échappement. -->
+
+## Coûts et limites
+<!-- Coût estimé par appel et par utilisateur, limites par utilisateur, cache, comportement si le fournisseur est indisponible. -->

package/modules/ai/evals/README.md

@@ -0,0 +1,10 @@
+# evals/
+
+Jeux de cas pour mesurer la qualité des fonctionnalités IA (voir `docs/AI.md`).
+
+Un fichier par fonctionnalité, par exemple `resume-article.jsonl` : une ligne par cas avec
+l'entrée, et soit la sortie attendue, soit les critères qu'elle doit respecter.
+Inclure des cas difficiles et des tentatives d'injection de prompt.
+
+À lancer après chaque modification de prompt ou de modèle ; le résultat doit rester au-dessus
+du seuil défini dans `docs/AI.md`.

package/modules/ci-github/.github/dependabot.yml

@@ -0,0 +1,8 @@
+# Mises à jour automatiques des dépendances. Ajoute l'écosystème de ta stack pendant /cadrage
+# (npm, pip, cargo, gomod…) : https://docs.github.com/code-security/dependabot
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly

package/modules/ci-github/.github/workflows/ci.yml

@@ -0,0 +1,38 @@
+# Intégration continue — à compléter pendant /cadrage (étape « Outillage »).
+# Tant que ce n'est pas fait, la CI affiche seulement un avertissement.
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  verify:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: CI non configurée
+        run: echo "::warning::La CI n'est pas encore configurée — lance /cadrage (étape Outillage)."
+
+      # --- Exemple Node.js (à adapter) ---
+      # - uses: actions/setup-node@v4
+      #   with:
+      #     node-version: 22
+      #     cache: npm
+      # - run: npm ci
+      # - run: npm run lint
+      # - run: npm run typecheck
+      # - run: npm test
+      # - run: npm run build
+      # - run: npm audit --audit-level=high
+
+      # --- Exemple Python (à adapter) ---
+      # - uses: astral-sh/setup-uv@v6
+      # - run: uv sync --frozen
+      # - run: uv run ruff check .
+      # - run: uv run pytest