Communitygithub.com

NarenDawar/narens-claude-skills

À utiliser lorsque l'utilisateur souhaite que les règles de CLAUDE.md soient appliquées avec des hooks, indique que Claude ignore une règle de CLAUDE.md, ou demande de transformer les règles CLAUDE.md en hooks (par exemple 'promouvoir mes règles CLAUDE.md en hooks' ou 'empêcher Claude de modifier les migrations').

Qu'est-ce que narens-claude-skills ?

Cette compétence transforme les règles de CLAUDE.md, qui sont de simples conseils que Claude peut contourner, en règles appliquées via un petit moteur de hooks testé. Elle lit les fichiers CLAUDE.md du projet, classe chaque règle (enfonçable, de goût, ou nécessitant une entrée utilisateur), puis écrit les règles enfonçables dans un fichier JSON (`.claude/rules.json`) et installe un hook Python (`.claude/hooks/rule_hook.py`) qui les exécute via les événements `PreToolUse` et `Stop` de Claude Code. Le processus comprend une revue humaine de chaque règle avec ses preuves (violation et passage) et ses risques de faux positifs, avant toute écriture de fichier. Le système supporte quatre types de règles : `protected_path` (interdiction d'édition de fichiers correspondant à des globs), `blocked_command` (interdiction de commandes bash correspondant à des expressions régulières), `banned_content` (interdiction de motifs dans le nouveau contenu écrit), et `stop_check` (exécution obligatoire d'une commande avant que Claude ne s'arrête). La compétence effectue des tests automatiques (`selftest`) et une vérification de bout en bout facultative, puis installe les hooks en modifiant les paramètres Claude (`settings.json`) avec un diff affiché à l'utilisateur. Elle fonctionne exclusivement avec l'outil Claude Code et ne s'exécute que sur demande explicite.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/NarenDawar/narens-claude-skills/tree/HEAD/plugins/rule-promoter/skills/rule-promoter

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Promoteur de Règles

Aperçu

Les règles CLAUDE.md sont des conseils : Claude peut les rationaliser et les contourner. Un hook est une application stricte. Cette compétence lit le CLAUDE.md du projet, extrait les règles qu'un hook peut réellement appliquer, les écrit dans un fichier de règles appliqué par un petit moteur testé, prouve que chaque règle bloque une violation, et installe les hooks après confirmation de l'utilisateur. Elle ne s'exécute que sur demande de l'utilisateur. Les hooks sont des garde-fous, pas une barrière de sécurité : un contournement déterminé (un script auxiliaire, sh -c) peut passer outre un pattern. Dites-le.

Fichiers (dans le répertoire de base de cette compétence, affichés lors du chargement)

  • scripts/rule_hook.py : le moteur. Copiez-le dans .claude/hooks/rule_hook.py du projet. python rule_hook.py selftest prouve chaque règle ; check est le point d'entrée du hook.
  • scripts/settings_merge.py : launcher choisit une commande Python qui fonctionne ; plan affiche le diff des paramètres ; apply l'écrit.

Exécutez les deux avec une commande Python 3 qui fonctionne sur cette machine (essayez python3, python, py -3). Mettez les chemins entre guillemets.

Processus

  1. Lecture. Trouvez CLAUDE.md, .claude/CLAUDE.md et CLAUDE.local.md dans le projet. Listez chaque règle avec son fichier et sa ligne. S'il n'y en a aucune, dites-le et arrêtez.

  2. Classifiez chaque règle dans exactement une des catégories suivantes :

    • un type de moteur (ci-dessous) avec des paramètres concrets ;
    • taste, avec une raison en une ligne ;
    • needs input, avec la question spécifique à poser (par exemple "quelle commande exécute vos tests ?").

    Une règle n'est applicable que si elle nomme des outils, chemins, commandes ou motifs textuels concrets, et si une violation est détectable à partir d'un seul appel d'outil ou du statut de sortie d'une commande de fin de tour. En cas de doute, marquez-la needs input et demandez ; ne devinez jamais un motif pour une règle vague. N'inventez jamais un type de règle.

  3. Revue. Affichez un tableau : règle, type, motif ou commande, un exemple de violation, un exemple de passage, et le risque de faux positif. Affichez chaque commande stop_check textuellement. Demandez à l'utilisateur de supprimer ou ajuster les lignes. N'écrivez rien encore.

  4. Preuve. Après approbation, créez .claude/hooks/ et copiez scripts/rule_hook.py là, écrivez .claude/rules.json, puis exécutez python .claude/hooks/rule_hook.py selftest depuis la racine du projet. Affichez la sortie. Une règle dont la preuve échoue n'est pas installée : corrigez son motif ou supprimez-la, et dites laquelle.

  5. Installation. Exécutez settings_merge.py launcher --script .claude/hooks/rule_hook.py, puis settings_merge.py plan --settings .claude/settings.json --launcher "<launcher>" [--pretool] [--stop] (--pretool si des règles de type chemin, commande ou contenu existent ; --stop si des règles stop_check existent). Affichez le diff et demandez un oui. Seulement après un oui, exécutez la même commande avec apply. Si elle signale un JSON de paramètres invalide ou une clé en double, arrêtez et prévenez l'utilisateur ; ne modifiez pas le fichier manuellement. L'assistant supprime uniquement ses propres entrées rule_hook.py et laisse les autres hooks intacts. Si la vérification de bout en bout ci-dessous montre que le hook ne s'est pas déclenché alors que selftest réussit et que disableAllHooks n'est pas défini, certaines versions de Claude Code manquent de args en forme exec : réexécutez plan et apply avec --shell-form.

  6. Vérification de bout en bout. Si vous pouvez exécuter claude -p dans le projet, testez avec une règle protected_path ou banned_content contre un fichier jetable (par exemple demandez-lui de modifier tmp-rule-check.txt sous un glob protégé), jamais avec une règle blocked_command ou stop_check qui exécuterait réellement quelque chose, et annulez toute modification ensuite. Vérifiez disableAllHooks dans les paramètres du projet, locaux et utilisateur avant de conclure quoi que ce soit. Confirmez que la sortie affiche le message du bloc Rule <id>:, et montrez-la. Si vous ne pouvez pas exécuter une session imbriquée, dites-le et dites que l'installation est vérifiée uniquement par selftest.

  7. Rapport. Listez les règles promues, les règles ignorées avec leurs raisons, et une limitation : Claude peut toujours modifier .claude/rules.json, .claude/hooks/ et .claude/settings.json. Proposez d'ajouter une règle protected_path pour ceux-ci, et dites qu'elle bloque également la réexécution de cette compétence jusqu'à ce que la règle soit désactivée. Ensuite, dites comment désactiver : définissez "enabled": false sur une règle dans .claude/rules.json, ou supprimez les entrées rule_hook.py de .claude/settings.json.

N'écrivez jamais rules.json, les fichiers de hook ou settings.json avant que l'utilisateur n'ait examiné le tableau. N'écrivez jamais settings.json avant d'avoir affiché le diff et obtenu un oui.

Si l'utilisateur ajoute une règle ou modifie un motif après le tableau, ou si vous devez modifier un motif car il est invalide ou que sa preuve échoue, affichez cette ligne nouvelle ou modifiée (motif, exemple de violation, exemple de passage, risque) et attendez un oui avant d'écrire quoi que ce soit. Une approbation donnée précédemment ne couvre pas un motif différent, et ne remplacez jamais un motif que l'utilisateur n'a pas vu.

Types de règles

Chaque règle a id (kebab-case), source (CLAUDE.md:14), text (la règle originale), message (affiché à Claude lorsqu'elle est bloquée), type, les champs ci-dessous, et une proof avec des payloads violation et pass.

protected_path : aucune modification des fichiers correspondants. Les globs correspondent au chemin complet relatif au projet ; utilisez **/name pour n'importe quelle profondeur.

{"id": "no-migration-edits", "source": "CLAUDE.md:3", "text": "Ne jamais modifier quoi que ce soit sous migrations/",
 "type": "protected_path", "globs": ["**/migrations/**"], "allow_globs": [],
 "message": "Les migrations sont générées. Créez une nouvelle migration à la place.",
 "proof": {"violation": {"hook_event_name": "PreToolUse", "tool_name": "Edit", "tool_input": {"file_path": "app/migrations/0001_initial.py", "old_string": "a", "new_string": "b"}},
           "pass": {"hook_event_name": "PreToolUse", "tool_name": "Edit", "tool_input": {"file_path": "app/models.py", "old_string": "a", "new_string": "b"}}}}

blocked_command : Commandes Bash correspondant à une expression régulière, testées sur chaque segment d'une commande composée. Utilisez except_patterns pour les variantes sûres ; une exception exempte le segment entier, donc rendez-la spécifique.

{"id": "no-force-push", "source": "CLAUDE.md:4", "text": "Ne jamais exécuter git push --force",
 "type": "blocked_command", "patterns": ["\\bgit\\s+push\\b.*(?:--force\\b|\\s-[A-Za-z]*f[A-Za-z]*\\b|\\s\\+\\w)"], "except_patterns": ["--force-with-lease"],
 "message": "Les pushes forcés ne sont pas autorisés.",
 "proof": {"violation": {"hook_event_name": "PreToolUse", "tool_name": "Bash", "tool_input": {"command": "git push --force origin main"}},
           "pass": {"hook_event_name": "PreToolUse", "tool_name": "Bash", "tool_input": {"command": "git push origin feature"}}}}

banned_content : Expressions régulières qui ne doivent pas apparaître dans le nouveau texte écrit (Edit, Write, MultiEdit, NotebookEdit), éventuellement limitées par des globs de fichiers. L'ancien texte n'est jamais inspecté.

{"id": "no-console-log", "source": "CLAUDE.md:5", "text": "Pas de console.log( dans src/",
 "type": "banned_content", "patterns": ["console\\.log\\\("], "globs": ["src/**"],
 "message": "Utilisez le logger, pas console.log.",
 "proof": {"violation": {"hook_event_name": "PreToolUse", "tool_name": "Write", "tool_input": {"file_path": "src/a.js", "content": "console.log(1)"}},
           "pass": {"hook_event_name": "PreToolUse", "tool_name": "Write", "tool_input": {"file_path": "src/a.js", "content": "logger.info(1)"}}}}

stop_check : Une commande qui doit réussir avant que Claude puisse s'arrêter. Elle bloque l'arrêt lorsque la commande se termine avec un code non nul. when_changed_globs la limite aux tours qui ont modifié des fichiers correspondants (uniquement les modifications non commitées : omettez-la si Claude a tendance à commiter avant de s'arrêter). La preuve utilise simulate_exit (selftest n'exécute pas la vraie commande).

{"id": "tests-pass", "source": "CLAUDE.md:6", "text": "Exécutez npm test avant de terminer",
 "type": "stop_check", "command": "npm test", "timeout_seconds": 240, "when_changed_globs": ["src/**", "tests/**"],
 "message": "Les tests doivent réussir avant de vous arrêter.",
 "proof": {"violation": {"hook_event_name": "Stop", "simulate_exit": 1}, "pass": {"hook_event_name": "Stop", "simulate_exit": 0}}}

Le fichier est {"version": 1, "rules": [ ... ]}. Payloads d'outils : Bash utilise tool_input.command ; Edit utilise file_path, old_string, new_string ; Write utilise file_path, content.

Ce qui est applicable (guide de classification)

  • Applicable : "ne jamais modifier X/", "ne pas toucher à .env", "ne jamais exécuter Y", "ne pas utiliser Z dans les fichiers sous W", "exécuter T avant de terminer".
  • De goût (taste) : "préférez les petites fonctions", "rédigez des messages de commit clairs", "gardez l'UI accessible", "privilégiez la clarté". Aucun motif ne peut décider de cela.
  • Nécessite une entrée (needs input) : "faites attention à la base de données", "assurez-vous que les tests passent" (quelle commande ?), "évitez le code hérité" (quels chemins ?). Demandez ; ne devinez pas.
  • Les globs supportent seulement *, ** et ?, relatifs au projet (pas de [ab], {a,b}, ./ ou / en tête) ; le moteur refuse tout autre chose. timeout_seconds est au maximum 280, et enabled doit être true ou false.
  • Préférez des motifs étroits. Indiquez le risque de faux positif pour chaque règle (par exemple un motif main correspond aussi à une branche nommée main-menu) et ajoutez allow_globs ou except_patterns lorsque cela est important.

Ton

Concis et factuel. C'est un travail de configuration, pas un cours sur les règles.

Erreurs courantes

  • Écrire un fichier, ou des paramètres, avant que l'utilisateur n'ait examiné le tableau.
  • Écrire settings.json sans afficher le diff et obtenir un oui.
  • Installer une règle que l'utilisateur n'a pas vue sous forme de ligne de tableau, ou remplacer silencieusement le motif demandé par l'utilisateur.
  • Installer une règle dont la preuve n'a pas réussi.
  • Promouvoir une règle de goût, ou deviner un motif pour une règle vague.
  • Inventer un type de règle que le moteur ne possède pas.
  • Omettre le risque de faux positif, ou la mise en garde "garde-fou, pas une barrière de sécurité".
  • Modifier un settings.json invalide à la main au lieu de s'arrêter.
  • Prétendre avoir observé un blocage de bout en bout que vous n'avez pas réellement vu.

Skills associés