create-go-plate 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+## 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,104 @@
-# 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.
+Démarre n'importe quel projet d'application avec un cadrage prêt pour le développement avec un
+agent de code (Claude Code, Codex, Cursor, Copilot, Gemini…).
+
+```bash
+npm create go-plate@latest mon-projet
+```
+
+Puis :
+
+```bash
+cd mon-projet
+claude
+```
+
+et dans l'agent : `/cadrage`. L'agent te pose les questions et remplit le PRD, l'architecture,
+le design, les règles, la stratégie de test, le backlog, l'outillage et le squelette du code,
+avant toute ligne de fonctionnalité.
+
+## Ce qui est généré
+
+```
+mon-projet/
+├── AGENTS.md                 instructions de l'agent (source unique, standard multi-outils)
+├── CLAUDE.md                 importe AGENTS.md (+ spécificités Claude Code)
+├── TASKS.md                  avancement
+├── README.md
+├── .claude/
+│   ├── settings.json         permissions (secrets, git destructif) + hooks
+│   ├── hooks/                reprise de contexte, protection des fichiers, formatage auto
+│   ├── skills/               /cadrage, /stress-test, /spec, /fin-de-session, /audit-securite
+│   └── agents/               sous-agents reviewer et test-writer
+├── .mcp.json                 Context7 (doc à jour), Playwright (tests navigateur)
+├── .github/                  CI (squelette) + Dependabot
+├── docs/
+│   ├── PRD.md                quoi et pourquoi
+│   ├── ARCHITECTURE.md       comment
+│   ├── DESIGN.md             interface et expérience
+│   ├── RULES.md              interdits stricts
+│   ├── SECURITY.md           checklist sécurité
+│   ├── TESTING.md            définition de « fini »
+│   ├── SESSION-LOG.md        historique des sessions
+│   ├── decisions/            ADR (une décision = un fichier)
+│   └── specs/                une spec par fonctionnalité (spec → plan → tâches)
+├── .env.example
+├── .editorconfig
+├── .gitignore
+└── src/
+```
+
+En option : `docs/AI.md` et `evals/` pour les applications qui appellent un LLM.
+
+## Options
+
+```bash
+npm create go-plate@latest mon-projet -- --yes --ai
+```
+
+| Option | Effet |
+|---|---|
+| `-y`, `--yes` | Choix par défaut, sans question |
+| `--no-claude` | Sans CLAUDE.md, hooks, permissions ni `.mcp.json` |
+| `--no-ci` | Sans GitHub Actions ni Dependabot |
+| `--ai` | Ajoute le module « fonctionnalités IA » |
+| `--no-git` | Sans `git init` |
+| `-f`, `--force` | Autorise un dossier non vide |
+
+Avec `npm create`, les options se placent après `--`. Avec `npx create-go-plate`, ce
+n'est pas nécessaire.
+
+## Le cycle de travail
+
+1. `/cadrage` — une fois, au début.
+2. `/spec <fonctionnalité>` — pour chaque fonctionnalité : spec, plan, tâches, validés avant le code.
+3. `/fin-de-session` — à chaque arrêt. Au démarrage suivant, un hook redonne le contexte à l'agent.
+4. `/audit-securite` — avant chaque mise en production.
+
+## Prérequis
+
+- Node.js ≥ 20.16 (pour le générateur et les hooks).
+- Windows : les hooks passent par le shell ; installe Git for Windows (Git Bash).
+  Pour le serveur MCP Playwright, remplace dans `.mcp.json` `"command": "npx"` par
+  `"command": "cmd"` et préfixe les `args` par `"/c", "npx"`.
+
+## Développer ce générateur
+
+```bash
+npm test
+```
+
+```bash
+node bin/create.mjs /tmp/essai --yes
+```
+
+### 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.
+
+Le contenu généré vit dans `template/` (toujours copié) et `modules/<nom>/` (copiés selon les
+choix). Le fichier `template/gitignore` est renommé en `.gitignore` à la génération, car npm
+ne publie pas les fichiers `.gitignore`.

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

package/modules/claude/.claude/hooks/format.mjs

@@ -0,0 +1,37 @@
+// PostToolUse : formate automatiquement chaque fichier modifié par l'agent.
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { projectDir, readStdinJson, relativeToProject } from "./lib.mjs";
+
+// À RENSEIGNER pendant /cadrage, une fois la stack choisie. Le chemin du fichier est ajouté à la fin.
+// Exemples :
+//   "npx prettier --write --ignore-unknown"   (JS/TS, CSS, Markdown…)
+//   "npx @biomejs/biome format --write"        (JS/TS)
+//   "ruff format"                              (Python)
+//   "gofmt -w"                                 (Go)
+// Laisser vide désactive le formatage.
+const FORMAT_COMMAND = "";
+
+if (!FORMAT_COMMAND) process.exit(0);
+
+const input = readStdinJson();
+const filePath = input.tool_input?.file_path;
+if (!filePath) process.exit(0);
+
+const absolute = path.resolve(projectDir, filePath);
+const rel = relativeToProject(absolute);
+// Uniquement les fichiers du projet, hors dépendances.
+if (rel.startsWith("..") || /(^|\/)node_modules\//.test(rel) || !existsSync(absolute)) process.exit(0);
+
+const result = spawnSync(`${FORMAT_COMMAND} ${JSON.stringify(absolute)}`, {
+  cwd: projectDir,
+  shell: true,
+  encoding: "utf8",
+});
+
+if (result.status !== 0) {
+  // Code 1 = erreur non bloquante : affichée à l'utilisateur, l'agent continue.
+  process.stderr.write(`Formatage échoué pour ${rel} :\n${result.stderr || result.stdout || ""}`);
+  process.exit(1);
+}

package/modules/claude/.claude/hooks/lib.mjs

@@ -0,0 +1,32 @@
+// Utilitaires partagés par les hooks. Aucune dépendance : seulement Node.
+import { readFileSync } from "node:fs";
+import path from "node:path";
+
+export const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+
+export function readStdinJson() {
+  try {
+    const raw = readFileSync(0, "utf8");
+    return raw.trim() ? JSON.parse(raw) : {};
+  } catch {
+    return {};
+  }
+}
+
+export function readProjectFile(relativePath) {
+  try {
+    return readFileSync(path.join(projectDir, relativePath), "utf8");
+  } catch {
+    return null;
+  }
+}
+
+export function stripHtmlComments(text) {
+  return text.replace(/<!--[\s\S]*?-->/g, "");
+}
+
+// Chemin relatif au projet, avec des "/" quel que soit l'OS.
+export function relativeToProject(filePath) {
+  const absolute = path.resolve(projectDir, filePath);
+  return path.relative(projectDir, absolute).split(path.sep).join("/");
+}

package/modules/claude/.claude/hooks/protect-files.mjs

@@ -0,0 +1,69 @@
+// PreToolUse : bloque l'accès aux fichiers sensibles et les commandes git destructrices.
+// Sortie code 2 = action refusée ; le message sur stderr est renvoyé à l'agent.
+import path from "node:path";
+import { readStdinJson, relativeToProject } from "./lib.mjs";
+
+// Fichiers dont le contenu ne doit jamais être lu ni modifié par l'agent.
+const SECRET_FILE = /(^|\/)\.env(\.(?!example$)[^/]+)?$|\.(pem|key|p12|pfx)$/i;
+// Fichiers que l'agent peut lire mais ne doit modifier qu'avec les outils dédiés.
+const GENERATED_FILE =
+  /(^|\/)(package-lock\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb?|poetry\.lock|uv\.lock|Cargo\.lock)$/;
+const GIT_DIR = /(^|\/)\.git\//;
+
+// Commandes shell qui mentionnent un fichier .env réel (pas .env.example).
+const BASH_SECRET = /(^|[\s'"=<>|;&(/])\.env(\.(?!example\b)[\w.-]+)?(?![\w.-])/;
+const BASH_FORCE_PUSH = /\bgit\s+push\b[^;&|]*\s(--force(?!-with-lease)|-f)(\s|$)/;
+const BASH_RESET_HARD = /\bgit\s+reset\b[^;&|]*\s--hard\b/;
+
+function deny(message) {
+  process.stderr.write(`${message}\n`);
+  process.exit(2);
+}
+
+const input = readStdinJson();
+const tool = input.tool_name;
+const toolInput = input.tool_input || {};
+
+if (tool === "Bash") {
+  const command = String(toolInput.command || "");
+  if (BASH_SECRET.test(command)) {
+    deny(
+      "Bloqué par .claude/hooks/protect-files.mjs : la commande touche un fichier .env réel. " +
+        "Les secrets ne sont pas accessibles à l'agent ; demande à l'utilisateur de faire cette action lui-même " +
+        "(ou utilise .env.example pour documenter une variable)."
+    );
+  }
+  if (BASH_FORCE_PUSH.test(command) || BASH_RESET_HARD.test(command)) {
+    deny(
+      "Bloqué par .claude/hooks/protect-files.mjs : commande git destructrice (push --force / reset --hard). " +
+        "Voir docs/RULES.md. Si c'est vraiment nécessaire, l'utilisateur doit la lancer lui-même."
+    );
+  }
+  process.exit(0);
+}
+
+const filePath = toolInput.file_path || toolInput.notebook_path;
+if (!filePath) process.exit(0);
+
+const rel = relativeToProject(filePath);
+const name = path.posix.basename(rel);
+
+if (SECRET_FILE.test(rel)) {
+  deny(
+    `Bloqué par .claude/hooks/protect-files.mjs : ${name} peut contenir des secrets. ` +
+      "Documente les variables dans .env.example et demande à l'utilisateur de remplir le vrai fichier."
+  );
+}
+
+if (tool !== "Read" && GIT_DIR.test(`${rel}/`)) {
+  deny("Bloqué par .claude/hooks/protect-files.mjs : ne modifie pas le dossier .git directement, utilise les commandes git.");
+}
+
+if (tool !== "Read" && GENERATED_FILE.test(rel)) {
+  deny(
+    `Bloqué par .claude/hooks/protect-files.mjs : ${name} est généré. ` +
+      "Modifie-le via le gestionnaire de paquets (install / add / remove), pas à la main."
+  );
+}
+
+process.exit(0);

package/modules/claude/.claude/hooks/session-start.mjs

@@ -0,0 +1,50 @@
+// SessionStart : redonne à l'agent le contexte de reprise (statut du cadrage, tâches en cours,
+// dernière entrée du journal). Ce qui est écrit sur stdout est ajouté au contexte de la session.
+import { readProjectFile, stripHtmlComments } from "./lib.mjs";
+
+const MAX_CHARS = 3000;
+
+function section(markdown, title) {
+  const lines = stripHtmlComments(markdown).split("\n");
+  const start = lines.findIndex((l) => l.trim().toLowerCase() === `## ${title}`.toLowerCase());
+  if (start === -1) return "";
+  const end = lines.findIndex((l, i) => i > start && /^##\s/.test(l));
+  return lines
+    .slice(start + 1, end === -1 ? undefined : end)
+    .join("\n")
+    .trim();
+}
+
+function lastLogEntry(markdown) {
+  const text = stripHtmlComments(markdown);
+  const match = text.match(/^###\s[\s\S]*?(?=^###\s|(?![\s\S]))/m);
+  return match ? match[0].trim() : "";
+}
+
+const out = [];
+
+const agents = readProjectFile("AGENTS.md");
+if (agents) {
+  const status = section(agents, "Statut du cadrage").split("\n")[0].replace(/\*/g, "").trim();
+  if (status) out.push(`Statut du cadrage : ${status}`);
+  if (/NON FAIT/.test(status)) {
+    out.push("Le cadrage n'est pas fait : avant de coder une fonctionnalité, propose /cadrage.");
+  }
+}
+
+const tasks = readProjectFile("TASKS.md");
+if (tasks) {
+  const current = section(tasks, "En cours");
+  out.push(`Tâches en cours (TASKS.md) :\n${current || "(aucune)"}`);
+}
+
+const log = readProjectFile("docs/SESSION-LOG.md");
+if (log) {
+  const entry = lastLogEntry(log);
+  if (entry) out.push(`Dernière session (docs/SESSION-LOG.md) :\n${entry}`);
+}
+
+if (out.length) {
+  const text = `Contexte de reprise du projet\n\n${out.join("\n\n")}`;
+  process.stdout.write(text.length > MAX_CHARS ? `${text.slice(0, MAX_CHARS)}\n…(tronqué)` : text);
+}

package/modules/claude/.claude/settings.json

@@ -0,0 +1,61 @@
+{
+  "$schema": "https://json.schemastore.org/claude-code-settings.json",
+  "permissions": {
+    "deny": [
+      "Read(./.env)",
+      "Read(./.env.local)",
+      "Read(./.env.*.local)",
+      "Read(./.env.production)",
+      "Edit(./.env)",
+      "Edit(./.env.local)",
+      "Edit(./.env.*.local)",
+      "Edit(./.env.production)",
+      "Bash(git push --force *)",
+      "Bash(git push -f *)",
+      "Bash(git reset --hard *)"
+    ],
+    "ask": [
+      "Bash(git push *)",
+      "Bash(rm -rf *)",
+      "Bash(git clean *)",
+      "Bash(npm publish *)"
+    ]
+  },
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/session-start.mjs\"",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Read|Edit|Write|MultiEdit|NotebookEdit|Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/protect-files.mjs\"",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Edit|Write|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/format.mjs\"",
+            "timeout": 60
+          }
+        ]
+      }
+    ]
+  }
+}