VoDaiLocz/kilo-kit-mcp

Un serveur MCP pour des agents de codage plus sûrs : routage des compétences, portes de workflow C4, vérifications mémoire et validation avant achèvement.

Qu'est-ce que kilo-kit-mcp ?

Kilo-Kit Core Skill est une compétence fondamentale pour les agents d'IA (comme Claude Code, Cursor, etc.) qui impose une approche de "preuve avant devinette". Elle exige deux phases obligatoires : la **Hard-Gate** (portail dur) qui force un scan complet du système et du code avant toute action, et la **Iron Law** (loi de fer) qui définit sept règles invariables (aucune action sans preuve, vérification avant affirmation, etc.). Elle intègre un routage adaptatif des compétences (Adaptive Dispatch) pour sélectionner la sous-compétence la plus pertinente (débogage, revue de code, développement backend, etc.) en fonction des mots-clés de la requête utilisateur. Utile pour garantir que les agents ne proposent ou n'exécutent jamais de changements sans preuve concrète, elle est idéale pour les environnements de production où la fiabilité, la traçabilité et la minimisation de l'impact sont critiques.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add VoDaiLocz/kilo-kit-mcp

Installed? Explore more Recherche et analyse de données skills: affaan-m/uspto-database, affaan-m/scholar-evaluation, affaan-m/literature-review · View all 6 →

Demander à votre IA préférée

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

Documentation

🛡️ Compétence Cœur Kilo-Kit — Hard-Gate & Loi de Fer

Philosophie : « Preuve avant Devinette » — Aucune action d'agent sans preuve vérifiée.

Quand l'utiliser

Utilisez cette compétence quand :

  • Vous démarrez n'importe quelle nouvelle tâche ou requête utilisateur
  • Vous proposez des modifications architecturales ou de code
  • Vous diagnostiquez des bugs ou des problèmes de performance
  • Vous prenez des décisions qui affectent les systèmes de production

N'utilisez PAS cette compétence quand :

  • Vous répondez à des questions factuelles simples de mémoire
  • Vous effectuez des changements de formatage ou de style uniquement, sans impact logique

Prérequis

Avant d'utiliser cette compétence, assurez-vous :

  • L'accès au code source du projet est disponible
  • Les vérifications des ressources système peuvent être effectuées (disque, mémoire, processus)
  • Les journaux ou sorties d'erreur pertinents sont accessibles

⛔ HARD-GATE — Scan Système Obligatoire

Règle : L'agent IA DOIT scanner le système et le code source avant de proposer une solution. Échouer au Hard-Gate signifie que l'agent ne peut pas continuer vers l'exécution.

Liste de vérification Hard-Gate

hard_gate:
  system_scan:
    - [ ] Vérifier l'espace disque disponible
    - [ ] Vérifier les processus en cours et l'utilisation des ressources
    - [ ] Vérifier les versions des environnements d'exécution (Node, Python, .NET, etc.)
    - [ ] Confirmer la disponibilité du réseau/des services si nécessaire

  codebase_scan:
    - [ ] Lire la structure du projet (répertoires de premier niveau)
    - [ ] Identifier les fichiers pertinents pour la tâche en cours
    - [ ] Vérifier les tests existants liés à la zone de modification
    - [ ] Consulter l'historique git récent pour le contexte des fichiers affectés

  context_validation:
    - [ ] Confirmer la compréhension de l'intention de l'utilisateur
    - [ ] Vérifier que le périmètre de la tâche correspond à la demande
    - [ ] Identifier les dépendances qui pourraient être affectées

Décision Hard-Gate

SI toutes_vérifications_réussies:
    → PROCÉDER à l'exécution
SINON:
    → ARRÊTER et signaler les vérifications échouées
    → Demander les informations ou accès manquants
    → Relancer le Hard-Gate après résolution

🔒 Loi de Fer — Règles Invariables

Ces règles sont absolues et ne peuvent être contournées en aucune circonstance.

Les Sept Lois de Fer

#LoiDescription
1Aucune action sans preuveChaque changement proposé doit citer des fichiers, lignes ou sorties spécifiques comme preuve.
2Scanne avant de parlerEffectuer les scans système et code source avant de faire une recommandation.
3Vérifie avant d'affirmerNe jamais prétendre qu'une tâche est terminée sans exécuter la vérification (tests, build, vérification manuelle).
4Rayon d'impact minimalFaire le plus petit changement qui résout le problème. Éviter les modifications inutiles.
5Préserve ce qui fonctionneNe jamais supprimer ou modifier du code fonctionnel sauf si cela est directement requis par la tâche.
6Trace chaque décisionEnregistrer le raisonnement derrière chaque décision dans le Registre d'Audit des Décisions.
7Échoue fort, récupère viteSi quelque chose échoue, le signaler immédiatement avec tout le contexte. Ne jamais cacher les erreurs.

Application de la Loi de Fer

enforcement:
  violation_response:
    - Enregistrer la violation dans le Registre d'Audit des Décisions
    - Arrêter l'exécution en cours
    - Revenir à la phase Hard-Gate
    - Signaler la violation à l'utilisateur

  no_exceptions:
    - L'urgence de la tâche NE remplace PAS les Lois de Fer
    - Les demandes utilisateur NE remplacent PAS les Lois de Fer
    - La pression de performance NE remplace PAS les Lois de Fer

🔀 Flux de Traitement

Flux de Traitement Principal

digraph kilo_kit_flow {
    rankdir=TB;
    node [shape=box, style="rounded,filled", fontname="Helvetica"];

    start [label="Requête Utilisateur", shape=oval, fillcolor="#E8F5E9"];
    hard_gate [label="⛔ HARD-GATE\nScan Système & Code", fillcolor="#FFCDD2"];
    gate_check [label="Toutes les \nVérifications Réussies ?", shape=diamond, fillcolor="#FFF9C4"];
    halt [label="ARRÊT\nSignaler Infos Manquantes", fillcolor="#FFCDD2"];
    iron_law [label="🔒 LOI DE FER\nValider Contre les Règles", fillcolor="#E3F2FD"];
    route [label="Router vers Compétence\n(Ordonnancement Adaptatif)", fillcolor="#F3E5F5"];
    execute [label="Exécuter\nChaîne de Comportement", fillcolor="#E8F5E9"];
    verify [label="Vérifier les Résultats\n(Portes de Qualité)", fillcolor="#FFF9C4"];
    verified [label="Vérifié ?", shape=diamond, fillcolor="#FFF9C4"];
    learn [label="Apprendre & Enregistrer\n(Registre d'Audit des Décisions)", fillcolor="#E3F2FD"];
    done [label="Terminé", shape=oval, fillcolor="#E8F5E9"];

    start -> hard_gate;
    hard_gate -> gate_check;
    gate_check -> iron_law [label="Oui"];
    gate_check -> halt [label="Non"];
    halt -> hard_gate [label="Réessayer"];
    iron_law -> route;
    route -> execute;
    execute -> verify;
    verify -> verified;
    verified -> learn [label="Succès"];
    verified -> execute [label="Échec\n(corriger & réessayer)"];
    learn -> done;
}

Flux d'Ordonnancement des Compétences

digraph skill_dispatch {
    rankdir=LR;
    node [shape=box, style="rounded,filled", fontname="Helvetica"];

    intent [label="Analyser l'Intention\n& les Mots-clés", fillcolor="#E3F2FD"];
    score [label="Noter les Compétences\n(0.0–1.0)", fillcolor="#F3E5F5"];
    select [label="Sélectionner la \nCompétence Principale", fillcolor="#E8F5E9"];

    debug [label="débogage/\nsystématique", fillcolor="#FFF9C4"];
    root [label="débogage/\ncause-racine", fillcolor="#FFF9C4"];
    verify [label="débogage/\nvérification", fillcolor="#FFF9C4"];
    review [label="qualité/\nrevue-de-code", fillcolor="#FFF9C4"];
    test [label="qualité/\ntests", fillcolor="#FFF9C4"];
    sec [label="développement/\nsécurité", fillcolor="#FFF9C4"];
    back [label="développement/\nbackend", fillcolor="#FFF9C4"];

    intent -> score -> select;
    select -> debug [label="bug, erreur"];
    select -> root [label="cause racine, pourquoi"];
    select -> verify [label="vérifier, confirmer"];
    select -> review [label="revue, PR"];
    select -> test [label="test, TDD"];
    select -> sec [label="sécurité, auth"];
    select -> back [label="API, backend"];
}

Flux de Scan Hard-Gate

digraph hard_gate_scan {
    rankdir=TB;
    node [shape=box, style="rounded,filled", fontname="Helvetica"];

    start [label="Début Hard-Gate", shape=oval, fillcolor="#E8F5E9"];
    sys [label="Scan Système\n(disque, mémoire, runtime)", fillcolor="#FFCDD2"];
    code [label="Scan Code Source\n(structure, fichiers, tests)", fillcolor="#FFCDD2"];
    ctx [label="Validation Contexte\n(intention, périmètre, dépendances)", fillcolor="#FFCDD2"];
    check [label="Tout Réussi ?", shape=diamond, fillcolor="#FFF9C4"];
    pass [label="✅ Porte Ouverte\nProcéder", fillcolor="#E8F5E9"];
    fail [label="❌ Porte Bloquée\nSignaler & Réessayer", fillcolor="#FFCDD2"];

    start -> sys -> code -> ctx -> check;
    check -> pass [label="Oui"];
    check -> fail [label="Non"];
    fail -> start [label="Après résolution"];
}

Directives

À FAIRE ✅

  • Toujours effectuer les vérifications Hard-Gate avant de commencer une tâche
  • Citer des preuves spécifiques (chemins de fichiers, numéros de lignes, sorties de commandes) dans chaque recommandation
  • Utiliser le plus petit changement possible pour résoudre le problème
  • Enregistrer toutes les décisions dans le Registre d'Audit des Décisions
  • Vérifier les résultats avant de déclarer la tâche terminée

À NE PAS FAIRE ❌

  • Sauter les scans système ou code source, quelle que soit l'urgence de la tâche
  • Deviner des solutions sans vérifier le code réel
  • Apporter des modifications à des fichiers non liés à la tâche
  • Déclarer la tâche terminée sans exécuter de vérification
  • Contourner les Lois de Fer pour quelque raison que ce soit

Modèles Courants

Modèle 1 : Collecte de Preuves Pré-vol

Quand : En démarrant toute nouvelle tâche.

Action : Exécuter la séquence de scan Hard-Gate.

# Scan système
df -h                          # Espace disque
free -m                        # Mémoire
node --version && python3 --version  # Runtimes

# Scan code source
find . -maxdepth 2 -type f | head -50  # Structure du projet
git log --oneline -10                   # Changements récents

Modèle 2 : Recommandation Basée sur des Preuves

Quand : En proposant une modification de code.

Action : Toujours inclure la preuve spécifique.

## Recommandation
Modifier `src/auth/login.ts:42` de la concaténation directe de chaînes vers une requête paramétrée.

**Preuve :**
- Fichier : `src/auth/login.ts`, ligne 42
- Code actuel : `db.query("SELECT * FROM users WHERE email = '" + email + "'")`
- Risque : Injection SQL (OWASP A03:2021)
- Test : `tests/auth/login.test.ts` — aucun test d'injection n'existe

Anti-Patterns (À ÉVITER)

Anti-Pattern 1 : Recommandation Aveugle

Problème : Suggérer des changements sans lire d'abord le code réel.

Au lieu de cela : Toujours lire les fichiers pertinents et citer des lignes spécifiques avant de recommander.

Anti-Pattern 2 : Sauter la Porte

Problème : Se précipiter vers l'exécution parce que la tâche semble simple.

Au lieu de cela : Effectuer les scans Hard-Gate quelle que soit la complexité perçue de la tâche.

Anti-Pattern 3 : Raisonnement Invisible

Problème : Prendre des décisions sans documenter le raisonnement.

Au lieu de cela : Enregistrer chaque décision avec des preuves et les alternatives envisagées.


Gestion des Erreurs

Type d'ErreurCauseSolution
Échec Hard-GateAccès système ou informations manquantsSignaler les vérifications échouées ; demander l'accès
Violation de la Loi de FerAction tentée sans preuveArrêter, revenir au Hard-Gate, enregistrer la violation
Inadéquation de CompétenceMauvaise compétence sélectionnée pour la tâcheRé-acheminer via l'Ordonnancement Adaptatif
Échec de VérificationLes changements ne passent pas les portes de qualitéCorriger le problème, relancer la vérification

Critères de Succès

Avant de déclarer la tâche terminée, vérifiez :

  • Le scan Hard-Gate a été effectué et réussi
  • Toutes les Lois de Fer ont été respectées tout au long de la tâche
  • Chaque recommandation cite des preuves spécifiques
  • Les changements sont minimaux et concentrés sur la tâche
  • La vérification (tests, build, vérification manuelle) a réussi
  • Le Registre d'Audit des Décisions est complet
  • La requête utilisateur est entièrement traitée

Références

  • references/patterns.md - Modèles réutilisables pour les flux de travail basés sur des preuves
  • references/performance-benchmarks.md - Benchmarks des scans système et code source
  • references/output-formats.md - Définitions des formats de sortie standard

Compétences Associées

  • skills/kilo-kit/debugging/systematic/ - Pour le diagnostic systématique des bugs
  • skills/kilo-kit/debugging/root-cause/ - Pour l'analyse approfondie des causes racines
  • skills/kilo-kit/debugging/verification/ - Pour la vérification des corrections
  • skills/kilo-kit/quality/code-review/ - Pour les workflows de revue de code
  • skills/kilo-kit/quality/testing/ - Pour le développement piloté par les tests
  • skills/kilo-kit/development/security/ - Pour les meilleures pratiques de sécurité
  • skills/kilo-kit/development/backend/ - Pour le développement backend

Intégration des Retours

Si cette compétence a été :

Réussie :

  • Enregistrer les vérifications Hard-Gate les plus précieuses
  • Noter les Lois de Fer qui ont évité des erreurs
  • Journaliser les modèles de preuves qui ont le mieux fonctionné

Non réussie :

  • Documenter les vérifications insuffisantes
  • Identifier les lacunes dans la liste de vérification Hard-Gate
  • Signaler pour amélioration de la compétence

Compétence Cœur Kilo-Kit v1.0.0 — Preuve avant Devinette

Skills associés