À 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.

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

**Kin est un dépôt de code natif-graphe pour les personnes et les agents IA.** 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 committez, branchez et fusionnez. Le code source exact est préservé octet par octet, et les 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 à des 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)

Une étoile aide d'autres personnes à trouver Kin, et les [Discussions](https://github.com/firelock-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 devez-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.

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

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

Pour Claude Code :

```
/plugin marketplace add firelock-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 ; voir [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 frais 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. Le crate `kin` qui s'y trouve est un projet sans rapport.

## Démarrage rapide

Commencez dans un clone frais et complet d'un projet que vous connaissez bien. `kin init` lit votre historique Git sans le modifier ni modifier vos fichiers suivis. Il ajoute un répertoire `.kin` et une ligne à `.git/info/exclude`. L'import couvre chaque commit atteint par vos branches et tags, donc le temps, la mémoire et le disque 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 avec les chiffres lorsqu'il peut déjà déterminer que la machine est à court. **Les clones superficiels, les sous-modules et Git LFS ne sont pas pris en charge**, et les hooks Git, un checkout sparse ou une fusion ou rebase inachevée arrêtent également l'import. `kin init` nomme la correction pour chacun, et un clone frais évite la plupart d'entre eux.

### 1. Installer

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

```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 en tant que commande séparée, car l'installation place `kin` dans
`~/.kin/bin` et ajoute ce répertoire à votre profil 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é sur Windows. L'entrée Windows sous [Limites de la bêta](#beta-limits)
indique ce qui fonctionne là-bas. Aucune build Windows ARM64 native 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 le dépannage, voir le [démarrage rapide 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 avez 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 prochaine commande à exécuter, une question `kin refs` sur une fonction dans 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 n'a pas de `&&`, donc sur Windows natif exécutez les mêmes commandes une à la
fois et arrêtez si l'une échoue :

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

`kin overview` montre les entités que Kin a importées. `kin status` montre 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 en direct du démon et sa couverture. Les modifications non commitées et non suivies ne font pas partie de l'historique Git importé ; `kin init` rapporte ce qu'il a laissé de côté.

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

Cherchez quelque chose que vous savez déjà être 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 au code 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 dit 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` montre ce qui est connecté. Sur Windows, connectez les outils IA
à l'intérieur de WSL2.

La recherche sémantique s'exécute sur un modèle local d'environ 523 Mo, et la configuration demande avant que quoi que ce soit
ne le télécharge. Si vous avez dit non, ou si `kin init` indique que l'index de recherche attend le modèle,
ceci le télécharge et construit l'index :

```sh
kin embed
```

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èles 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, le stockage et les requêtes locaux s'exécutent sur votre machine. L'installation et le téléchargement initial du modèle d'embedding nécessitent un accès réseau. Avant que les embeddings ne soient prêts, `kin locate` utilise des signaux lexicaux et de graphe et rapporte la couverture vectorielle manquante.

## Réviser un changement

Après avoir exécuté `kin init` sur la branche Git que vous souhaitez réviser, comparez des SHAs de commit explicites par rapport à `main` :

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

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

## Utilisez Kin avec ou sans Git

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

[Parcours de 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 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 qu'il n'y a pas d'appelants ou de dépendances. Continuez à 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 `kin-vfs` obsolète, donc il n'y a pas de projection transparente sur laquelle compter. Consultez les [notes de plateforme](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#platform-and-maturity) pour ce que chaque plateforme prend en charge.

**Sauvegardez l'état propre à Kin.** Les commits, branches, revues et spécifications que vous enregistrez avec Kin vivent dans `.kin`, pas dans Git. Supprimer `.kin` et réimporter depuis Git ne les récupère pas, donc exécutez d'abord `kin backup create`. 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 démon 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 flux de travail de revue n'y sont pas encore testés, donc WSL2 reste 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'un codebase que nous avions déjà parcouru. Ensuite, je faisais une version de ce travail moi-même pour réviser leurs changements. J'ai commencé à me demander pourquoi davantage 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/firelock-ai/kin/issues/new/choose) · [Sécurité](https://github.com/firelock-ai/kin/blob/main/SECURITY.md)

Kin et sa pile locale, y compris [kin-db](https://github.com/firelock-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 publique du dépôt est encore en développement.

kin

Populaires

À propos