Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
kin — Contrôle de version sémantique basé sur les graphes pour le code écrit par l'IA. Suit les entités et les relations au lieu des diffs de fichiers, permettant l'analyse du rayon d'impact, la revue de fusion fantôme et le contexte d'agent propulsé par MCP pour un logiciel généré par l'IA digne de confiance. | Kitploit
Outils/GitHubGitHub/firelock-ai/kin
Analyse StatiqueAnalyse de CodeDevSecOpsSécurité de la Chaîne LogistiqueApprentissage et ÉducationRessources OrganiséesSécurité de l'IA
GitHubfirelock-ai/kin

kin

Voir le dépôt
44489il y a 1 moisVérifié par Kitploit
Site web

À propos

Contrôle de version sémantique basé sur les graphes pour le code écrit par l'IA. Suit les entités et les relations au lieu des diffs de fichiers, permettant l'analyse du rayon d'impact, la revue de fusion fantôme et le contexte d'agent propulsé par MCP pour un logiciel généré par l'IA digne de confiance.

Partager
<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/12665/55686ad4696e166589300e948ce2ed89f45622266654371a433a31c612829ec8.png" alt="Kin, un dépôt de code pour les agents IA et les personnes qui construisent avec eux" width="100%" />
</p>

<h3 align="center">Une nouvelle fondation pour le code.</h3>

<p align="center">
  <a href="https://github.com/firelock-ai/kin/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-Apache--2.0-blue.svg" alt="Apache-2.0" /></a>
  <a href="https://github.com/kinlab-ai/kin/releases/latest"><img src="https://img.shields.io/badge/release-latest-6E56CF.svg" alt="Latest release" /></a>
</p>

**Kin est un dépôt de code natif graphe pour les agents IA et les personnes qui construisent avec eux.** Il stocke le code source, les relations de code enregistrées et l'historique versionné en tant qu'état du dépôt. Le graphe est le modèle du dépôt, et non un index de recherche maintenu à côté d'un autre dépôt.

Les fonctions, les types et les relations entre eux sont des données que vous commitez, branchez et fusionnez. Le code source exact est préservé octet par octet, et des projections de système de fichiers permettent aux outils pris en charge de continuer à fonctionner avec des fichiers ordinaires.

**Bêta publique.** Essayez Kin sur un projet réel que vous connaissez bien. Attendez-vous à quelques aspérités.

[Démarrage rapide](#quickstart) · [Documentation](https://github.com/firelock-ai/kin/blob/main/docs/quickstart.md) · [Démo navigateur](https://kinlab.ai/demo)

<p align="center">
  <img src="https://raw.githubusercontent.com/firelock-ai/kin/main/docs/assets/kin-impact-human-bytes.gif" alt="kin impact human_bytes --file crates/kin-cli/src/commands/cache.rs --kind function --depth 1, montrant ses appelants directs dans le propre codebase de Kin à côté d'une recherche git grep pour le même nom" width="100%" />
</p>

Une étoile aide d'autres personnes à trouver Kin, et les [Discussions](https://github.com/kinlab-ai/kin/discussions) sont l'endroit où poser une question à son sujet.

## Voir ce qui est connecté

Avant de modifier une fonction partagée, que devriez-vous inspecter d'autre ? Kin vous permet de rechercher ses appelants enregistrés et d'explorer le code associé. La CLI et le serveur MCP interrogent le même graphe, afin que vous et votre agent puissiez travailler à partir du même enregistrement.

<img src="https://assets.kitploit.com/production/public/readmes/12665/43f73477ba09d6aa7a5bb446cadaea9c36981cc1d093faacaa03b9b61346b955.png" alt="Une requête kin impact enregistrée sur ripgrep, montrant les entités associées pour un changement de signature" width="100%" />

*Enregistré sur un graphe ripgrep préparé à `e89fff89ac9af12e8d4ce9d5fd07beb408ca730f`. Les artefacts bruts d'exécution ne sont pas publics. Ceci illustre un flux de travail, et non un benchmark de performance.*

## Utilisez-le depuis Claude Code, Codex ou Cursor

Pour Claude Code :

```
/plugin marketplace add kinlab-ai/kin
/plugin install kin@kin
```

Pour [Codex](https://github.com/firelock-ai/kin/blob/main/plugins/kin-codex/README.md#install), ajoutez le marketplace et installez le plugin, ou laissez `kin setup --intent agent` écrire le serveur MCP dans `~/.codex/config.toml` pour vous.

Pour Cursor, ajoutez le serveur MCP manuellement ; consultez [plugins/kin-cursor](https://github.com/firelock-ai/kin/blob/main/plugins/kin-cursor/README.md#install) pour l'extrait exact.

Après l'installation, exécutez `kin init .` dans un clone récent d'un projet que vous connaissez bien ; la compétence `kin-setup` vous guide pour le reste.

Kin n'est pas publié sur crates.io. La crate `kin` qui s'y trouve est un projet sans rapport.

## Démarrage rapide

Commencez dans un clone récent et complet d'un projet que vous connaissez bien. `kin init` lit votre historique Git sans le modifier ni toucher à vos fichiers suivis. Il conserve son store en dehors de votre checkout, dans `~/.kin/stores`, et n'écrit rien dans le dépôt ; `kin store path` affiche l'emplacement du store d'un checkout. Par défaut, il admet d'abord le commit extrait, de sorte que les questions obtiennent une réponse dès que cette arborescence est lue, puis importe en arrière-plan, à faible priorité, chaque commit atteint par vos branches et tags ; `kin init --history full` importe tout l'historique d'emblée, et `--history none` ne l'importe jamais. L'import de l'historique consomme du temps, de la mémoire et de l'espace disque qui augmentent avec l'historique plutôt qu'avec la taille du checkout. Avant de commencer, `kin init` vérifie la mémoire et l'espace disque libre et s'arrête en affichant les chiffres lorsqu'il peut déjà déterminer que la machine est à court de ressources. **Un clone superficiel n'admet que son commit extrait, et les submodules et Git LFS ne sont pas pris en charge**, et les hooks Git, un checkout partiel ou un merge ou rebase inachevé bloquent également l'import. `kin init` indique la correction pour chacun, et un clone récent évite la plupart d'entre eux.

### 1. Installation

Sur macOS, Linux et WSL2, une seule commande installe Kin et connecte les outils de codage IA qu'il
détecte. Elle nécessite Node.js 20 ou une version plus récente :

```sh
npx -y @kinlab/kin setup
```

Sur une machine sans Node, exécutez plutôt l'installateur. `get.kinlab.ai` et `get.kinlab.dev` servent le même script :

```sh
curl -fsSL https://get.kinlab.dev/install | sh
```

Dans les deux cas, rechargez votre shell dans une commande séparée, car l'installation place `kin` dans
`~/.kin/bin` et ajoute ce répertoire à votre profil de shell pour les nouvelles sessions :

```sh
exec "$SHELL" -l
```

Sur Windows x64 natif, installez depuis PowerShell avec `irm https://get.kinlab.dev/install.ps1 | iex`.
Cela installe la CLI `kin` et ne connecte pas les outils de codage IA, car WSL2 reste le
chemin recommandé sous Windows. L'entrée Windows dans [Limites de la bêta](#beta-limits)
indique ce qui y fonctionne. Aucune build native Windows ARM64 n'est publiée. Sur une machine ARM64, exécutez
cette ligne depuis PowerShell x64 pour installer la build x86_64 sous émulation, ou utilisez WSL2.
L'installateur ajoute `kin` à votre PATH utilisateur, donc ouvrez une nouvelle fenêtre PowerShell à la place de
`exec "$SHELL" -l` avant l'étape suivante.

Pour d'autres installateurs ou pour le dépannage, consultez le [guide de démarrage complet](https://github.com/firelock-ai/kin/blob/main/docs/quickstart.md#1-install).

### 2. Initialiser le dépôt

À la nouvelle invite, clonez un dépôt avec Kin :

```sh
kin clone https://github.com/pallets/itsdangerous
```

Ou initialisez-en un que vous possédez déjà, en remplaçant le chemin ci-dessous :

```sh
cd /path/to/your/repository &&
kin init . &&
kin overview &&
kin status
```

Les deux se terminent par la commande suivante à exécuter, une question `kin refs` sur une fonction de ce dépôt. Ils connectent également Codex CLI et Grok CLI à celui-ci lorsque vous l'avez autorisé lors de la configuration, car ces clients conservent une entrée qui nomme un dépôt.

Windows PowerShell 5.1 ne dispose pas de `&&`, donc sous Windows natif, exécutez les mêmes commandes une par une et arrêtez-vous si l'une échoue :

```powershell
cd C:\path\to\your\repository
kin init .
kin overview
kin status
```

`kin overview` affiche les entités importées par Kin. `kin status` indique ce qui a été admis et l'état de l'arbre de travail par rapport à celui-ci. `kin graph status` rapporte le graphe de requêtes actif du démon et sa couverture. Les modifications non validées et non suivies ne font pas partie de l'historique Git importé ; `kin init` indique ce qui a été omis.

### 3. Posez une question que vous pouvez vérifier

Cherchez quelque chose dont vous savez déjà qu'il se trouve dans le code :

```sh
kin locate "<something you already know is in this repository>"
```

Remplacez `ExactEntityName` ci-dessous par un symbole issu du résultat :

```sh
kin refs ExactEntityName
kin trace ExactEntityName
kin impact ExactEntityName
```

`refs` renvoie les références enregistrées, `trace` apporte le contexte proche, et `impact` explore les effets potentiels à travers le graphe. Vérifiez les résultats par rapport à la source.

### 4. Vos outils de codage IA et la recherche sémantique

`kin setup` a déjà demandé avant de connecter les outils de codage IA qu'il a trouvés, et les a connectés
si vous avez répondu oui. Il n'y a pas d'étape de liaison séparée. Après avoir installé un autre outil, exécutez
`kin setup` à nouveau, et `kin setup status` affiche ce qui est connecté. Sous Windows, connectez les outils
IA dans WSL2.

`kin runtime status --json` vérifie l'installation partagée du CLI et du daemon, y compris
leur identité source exacte. Les commandes normales refusent les paires non concordantes ; les builds
de développement utilisent un état isolé. Voir [installation du runtime](https://github.com/firelock-ai/kin/blob/main/docs/runtime-installation.md).

La récupération par graphe et lexicale fonctionne sans modèle. Les embeddings et le reranking sont optionnels,
et leurs fournisseurs de modèles sont par défaut à `none`. Les builds standard du CLI et du daemon incluent la prise en charge
des modèles HTTP externes. Les modèles intégrés nécessitent un build avec l'inférence locale optionnelle activée.

Pour construire un index d'embeddings à l'aide d'un endpoint compatible OpenAI que vous exploitez :

```sh
KIN_MODEL_EMBEDDINGS_PROVIDER=external \
KIN_MODEL_EMBEDDINGS_BASE_URL=http://localhost:1234/v1 \
KIN_MODEL_EMBEDDINGS_MODEL=your-served-embedding-model kin embed
```

Les points de terminaison de modèle reçoivent le texte de l'entité sélectionnée nécessaire à leur étape.
[Paramètres du modèle](https://github.com/firelock-ai/kin/blob/main/docs/env-vars.md) décrivent les fournisseurs, les identités de modèle et les noms des variables d'environnement d'identification.

Kin prend en charge Claude Code, Codex, Cursor, Gemini et d'autres clients MCP. Utilisez `kin setup --intent editor` pour VS Code. Kin inclut également `kin agent run` pour les points de terminaison de modèle compatibles OpenAI locaux ou hébergés.

[Configuration du client](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#works-with-your-agent) · [Outils MCP](https://github.com/firelock-ai/kin/blob/main/docs/mcp-tools.md) · [Agent intégré](https://github.com/firelock-ai/kin/blob/main/docs/cli-reference.md#kin-agent)

Les imports locaux, le stockage et les requêtes de graphe s'exécutent sur votre machine. L'installation de Kin nécessite un accès réseau ; le chemin de récupération de graphe par défaut ne nécessite aucun téléchargement de modèle. Lorsqu'un fournisseur d'embeddings est sélectionné, les requêtes indiquent sa couverture vectorielle et les éventuelles lacunes.

## Examiner une modification

Après avoir exécuté `kin init` sur la branche Git que vous souhaitez examiner, comparez des SHA de commit explicites à `main` :

```sh
kin review shadow "$(git rev-parse main)..$(git rev-parse HEAD)"
```

Le rapport renvoie `PASS`, `NEEDS ATTENTION` ou `WOULD BLOCK`, avec un impact dérivé du graphe et les preuves à l'appui. **Il est consultatif :** il ne bloque pas un merge et ne modifie pas l'état du graphe. La paternité est déclarée, non vérifiée de manière indépendante.

## Utiliser Kin avec ou sans Git

Kin dispose de ses propres commits, branches, merges, diffs et historique, y compris dans des dépôts sans Git en dessous. Les dépôts Git existants peuvent être importés, et les workflows pris en charge peuvent exporter un nouveau dépôt Git.

[Parcours du contrôle de version natif](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#version-control-without-git) · [Interopérabilité Git et limites d'export](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#how-kin-relates-to-git)

## Limites de la version bêta

**La couverture est incomplète.** Les langages pris en charge sont analysés en entités et relations ; les autres fichiers restent disponibles en tant que contenu et historique. Un résultat vide ne prouve pas l'absence d'appelants ou de dépendances. Continuez d'utiliser votre compilateur, vos tests et votre revue. Voir [prise en charge des langages](https://github.com/firelock-ai/kin/blob/main/docs/language-support.md).

**La compatibilité varie.** Les archives de version n'incluent pas la projection de système de fichiers obsolète `kin-vfs`, il n'y a donc pas de projection transparente sur laquelle s'appuyer. Consultez les [notes de plateforme](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#platform-and-maturity) pour savoir ce que chaque plateforme prend en charge.

**Sauvegardez l'état propre à Kin.** Les commits, branches, revues et specs que vous enregistrez avec Kin résident dans le store Kin du dépôt, pas dans Git. Supprimer le store et réimporter depuis Git ne les récupère pas, exécutez donc d'abord `kin backup create`. `kin store prune` ne supprime les stores que lorsque vous passez `--yes`, pour la même raison. Lisez les [notes d'import, de récupération et de mise à niveau](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#what-is-real-today-and-what-is-beta).

**Windows.** La prise en charge native de Windows x86_64 est précoce. L'admission de dépôt fonctionne : `kin init` importe un dépôt Git et publie l'autorité du graphe, et les requêtes de graphe, lexicales et adossées au daemon répondent nativement. La preuve d'installation de bout en bout exécute également la configuration de l'agent sur Windows natif et obtient des réponses adossées au graphe depuis le serveur MCP installé. La projection transparente du système de fichiers n'est pas livrée sur Windows, et les workflows de revue n'y sont pas encore testés, WSL2 reste donc le chemin recommandé pour l'expérience Kin complète.

## Pourquoi j'ai construit Kin

Je voyais sans cesse les agents de codage reconstituer des parties d'une base de code que nous avions déjà parcourues. Puis je faisais une version de ce travail moi-même pour relire leurs changements. J'ai commencé à me demander pourquoi une plus grande part de cette compréhension structurelle ne faisait pas partie du dépôt lui-même.

C'est ce que je construis avec Kin.

Troy

## En savoir plus et contribuer

[Référence CLI](https://github.com/firelock-ai/kin/blob/main/docs/cli-reference.md) · [Architecture et limites détaillées](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md) · [Contribuer](https://github.com/firelock-ai/kin/blob/main/CONTRIBUTING.md) · [Issues](https://github.com/kinlab-ai/kin/issues/new/choose) · [Sécurité](https://github.com/firelock-ai/kin/blob/main/SECURITY.md)

Kin et sa stack locale, y compris [kin-db](https://github.com/kinlab-ai/kin-db), sont sous [Apache-2.0](https://github.com/firelock-ai/kin/blob/main/LICENSE). [KinLab](https://kinlab.ai) est le produit hébergé propriétaire distinct. L'intégration au dépôt public est encore en développement.
Télécharger l’outil

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    906
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    725
  • 3

    looking-glass

    anonghosty/looking-glass

    Plateforme CSIRT qui ingère les rapports Shadowserver dans MongoDB et les rejoue sous forme de cartes interactives, d'analyses, de constats, d'avis et de tableaux de bord exécutifs.

    442
  • 4

    wifit3

    derv82/wifit3

    Wifite mais uniquement USB et multiplateforme.

    434
  • 5

    jumpserver

    jumpserver/jumpserver

    JumpServer est une plateforme open-source de Gestion des Accès Privilégiés (PAM) qui offre aux équipes DevOps et IT un accès sécurisé et à la demande aux terminaux SSH, RDP, Kubernetes, bases de données et RemoteApp via un navigateur web.

    412
  • 6

    SafeLine

    chaitin/safeline

    WAF auto-hébergé et proxy inverse qui filtre le trafic HTTP malveillant, bloque les injections SQL, les XSS et les attaques de robots, avec limitation de débit et chiffrement dynamique HTML/JS.

    360

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →