<h3 align="center">Eine neue Grundlage für Code.</h3>

**Kin ist ein graph-natives Code-Repository für Menschen und KI-Agenten.** Es speichert Quellcode, aufgezeichnete Code-Beziehungen und versionierte Historie als Repository-Zustand. Der Graph ist das Repository-Modell, kein Suchindex, der neben einem anderen Repository gepflegt wird.

Funktionen, Typen und die Beziehungen zwischen ihnen sind Daten, die du committen, branchen und mergen kannst. Der exakte Quellcode bleibt Byte für Byte erhalten, und Dateisystem-Projektionen sorgen dafür, dass unterstützte Tools weiterhin mit gewöhnlichen Dateien arbeiten können.

**Öffentliche Beta.** Probiere Kin an einem echten Projekt aus, das du gut kennst. Rechne mit rauen Kanten.

[Quickstart](#quickstart) · [Dokumentation](https://github.com/firelock-ai/kin/blob/main/docs/quickstart.md) · [Browser-Demo](https://kinlab.ai/demo)

Ein Stern hilft anderen, Kin zu finden, und in den [Discussions](https://github.com/firelock-ai/kin/discussions) kannst du eine Frage dazu einbringen.

## Sieh, was zusammenhängt

Bevor du eine geteilte Funktion änderst: Was solltest du sonst noch prüfen? Mit Kin kannst du ihre aufgezeichneten Aufrufer nachschlagen und verwandten Code erkunden. Die CLI und der MCP-Server fragen denselben Graphen ab, sodass du und dein Agent mit derselben Aufzeichnung arbeiten.

*Aufgezeichnet auf einem vorbereiteten ripgrep-Graphen bei `e89fff89ac9af12e8d4ce9d5fd07beb408ca730f`. Die rohen Lauf-Artefakte sind nicht öffentlich. Dies veranschaulicht einen Workflow, keinen Performance-Benchmark.*

## Nutze es aus Claude Code, Codex oder Cursor

Für Claude Code:

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

Für [Codex](https://github.com/firelock-ai/kin/blob/main/plugins/kin-codex/README.md#install) füge den Marketplace hinzu und installiere das Plugin, oder lass `kin setup --intent agent` den MCP-Server für dich in `~/.codex/config.toml` schreiben.

Für Cursor füge den MCP-Server manuell hinzu; siehe [plugins/kin-cursor](https://github.com/firelock-ai/kin/blob/main/plugins/kin-cursor/README.md#install) für das genaue Snippet.

Führe nach der Installation `kin init .` in einem frischen Clone eines Projekts aus, das du gut kennst; der `kin-setup`-Skill führt dich durch den Rest.

Kin ist nicht auf crates.io veröffentlicht. Das `kin`-Crate dort ist ein unabhängiges Projekt.

## Quickstart

Beginne in einem frischen, vollständigen Clone eines Projekts, das du gut kennst. `kin init` liest deine Git-Historie, ohne sie oder deine getrackten Dateien zu verändern. Es fügt ein `.kin`-Verzeichnis und eine Zeile zu `.git/info/exclude` hinzu. Der Import umfasst jeden Commit, den deine Branches und Tags erreichen, sodass Zeit, Speicher und Festplattenplatz mit der Historie wachsen statt mit der Größe des Checkouts. Bevor er startet, prüft `kin init` Speicher und freien Festplattenplatz und bricht mit den Zahlen ab, wenn bereits erkennbar ist, dass die Maschine knapp ist. **Shallow Clones, Submodule und Git LFS werden nicht unterstützt**, und Git-Hooks, ein Sparse Checkout oder ein unvollendeter Merge oder Rebase stoppen den Import ebenfalls. `kin init` nennt für jedes Problem die Lösung, und ein frischer Clone vermeidet die meisten davon.

### 1. Installation

Unter macOS, Linux und WSL2 installiert ein einziger Befehl Kin und verbindet die KI-Coding-Tools, die er findet. Er benötigt Node.js 20 oder neuer:

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

Auf einer Maschine ohne Node führe stattdessen den Installer aus. `get.kinlab.ai` und `get.kinlab.dev` liefern dasselbe Skript aus:

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

Lade in beiden Fällen deine Shell als separaten Befehl neu, denn die Installation legt `kin` in `~/.kin/bin` ab und fügt dieses Verzeichnis für neue Sitzungen zu deinem Shell-Profil hinzu:

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

Unter nativem Windows x64 installierst du aus PowerShell mit `irm https://get.kinlab.dev/install.ps1 | iex`. Das installiert die `kin` CLI und verbindet keine KI-Coding-Tools, denn WSL2 bleibt unter Windows der empfohlene Weg. Der Windows-Eintrag unter [Beta-Grenzen](#beta-grenzen) sagt, was dort funktioniert. Es wird kein natives Windows-ARM64-Build veröffentlicht. Führe auf einer ARM64-Maschine diese Zeile aus x64-PowerShell aus, um das x86_64-Build unter Emulation zu installieren, oder verwende WSL2. Der Installer fügt `kin` zu deinem Benutzer-PATH hinzu, also öffne vor dem nächsten Schritt ein neues PowerShell-Fenster anstelle von `exec "$SHELL" -l`.

Für andere Installer oder zur Fehlerbehebung siehe den [vollständigen Quickstart](https://github.com/firelock-ai/kin/blob/main/docs/quickstart.md#1-install).

### 2. Repository initialisieren

Klone an der neuen Eingabeaufforderung ein Repository mit Kin:

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

Oder initialisiere eines, das du bereits hast, und ersetze den Pfad unten:

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

Beide enden mit dem nächsten auszuführenden Befehl, einer `kin refs`-Frage zu einer Funktion in diesem Repository. Sie verbinden außerdem Codex CLI und Grok CLI damit, wenn du das im Setup erlaubt hast, denn diese Clients führen einen Eintrag, der ein Repository benennt.

Windows PowerShell 5.1 kennt kein `&&`, führe unter nativem Windows also dieselben Befehle einzeln aus und brich ab, wenn einer fehlschlägt:

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

`kin overview` zeigt die Entitäten, die Kin importiert hat. `kin status` zeigt, was aufgenommen wurde und wie der Zustand des Arbeitsverzeichnisses dazu steht. `kin graph status` meldet den Live-Abfragegraphen und die Abdeckung des Daemons. Nicht committete und nicht getrackte Änderungen sind nicht Teil der importierten Git-Historie; `kin init` meldet, was es ausgelassen hat.

### 3. Stelle eine Frage, die du überprüfen kannst

Suche nach etwas, von dem du bereits weißt, dass es im Code ist:

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

Ersetze `ExactEntityName` unten durch ein Symbol aus dem Ergebnis:

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

`refs` liefert aufgezeichnete Referenzen, `trace` bezieht nahen Kontext ein, und `impact` erkundet mögliche Auswirkungen durch den Graphen. Prüfe die Ergebnisse gegen den Quellcode.

### 4. Deine KI-Coding-Tools und semantische Suche

`kin setup` hat bereits gefragt, bevor es die gefundenen KI-Coding-Tools verbunden hat, und sie verbunden, wenn du ja gesagt hast. Es gibt keinen separaten Verknüpfungsschritt. Nachdem du ein weiteres Tool installiert hast, führe `kin setup` erneut aus, und `kin setup status` zeigt, was verbunden ist. Verbinde KI-Tools unter Windows innerhalb von WSL2.

Die semantische Suche läuft auf einem lokalen Modell von etwa 523 MB, und das Setup fragt nach, bevor etwas heruntergeladen wird. Wenn du nein gesagt hast, oder `kin init` meldet, dass der Suchindex auf das Modell wartet, lädt dies es herunter und baut den Index auf:

```sh
kin embed
```

Kin unterstützt Claude Code, Codex, Cursor, Gemini und andere MCP-Clients. Verwende `kin setup --intent editor` für VS Code. Kin enthält außerdem `kin agent run` für lokale oder gehostete OpenAI-kompatible Modell-Endpunkte.

[Client-Konfiguration](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#works-with-your-agent) · [MCP-Tools](https://github.com/firelock-ai/kin/blob/main/docs/mcp-tools.md) · [Integrierter Agent](https://github.com/firelock-ai/kin/blob/main/docs/cli-reference.md#kin-agent)

Lokale Importe, Speicherung und Abfragen laufen auf deiner Maschine. Installation und der anfängliche Download des Embedding-Modells benötigen Netzwerkzugriff. Bevor Embeddings bereit sind, verwendet `kin locate` lexikalische und Graph-Signale und meldet die fehlende Vektor-Abdeckung.

## Eine Änderung überprüfen

Nachdem du `kin init` auf dem Git-Branch ausgeführt hast, den du überprüfen möchtest, vergleiche explizite Commit-SHAs gegen `main`:

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

Der Bericht liefert `PASS`, `NEEDS ATTENTION` oder `WOULD BLOCK`, mit graph-abgeleiteten Auswirkungen und unterstützenden Belegen. **Er ist beratend:** Er blockiert keinen Merge und ändert keinen Graph-Zustand. Die Urheberschaft wird angegeben, nicht unabhängig verifiziert.

## Nutze Kin mit oder ohne Git

Kin hat eigene Commits, Branches, Merges, Diffs und Historie, auch in Repositories ohne Git darunter. Bestehende Git-Repositories können importiert werden, und unterstützte Workflows können ein neues Git-Repository exportieren.

[Walkthrough zur nativen Versionskontrolle](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#version-control-without-git) · [Git-Interoperabilität und Export-Grenzen](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#how-kin-relates-to-git)

## Beta-Grenzen

**Die Abdeckung ist unvollständig.** Unterstützte Sprachen werden in Entitäten und Beziehungen geparst; andere Dateien bleiben als Inhalt und Historie verfügbar. Ein leeres Ergebnis beweist nicht, dass es keine Aufrufer oder Abhängigkeiten gibt. Verwende weiterhin deinen Compiler, deine Tests und dein Review. Siehe [Sprachunterstützung](https://github.com/firelock-ai/kin/blob/main/docs/language-support.md).

**Die Kompatibilität variiert.** Release-Archive enthalten nicht die veraltete `kin-vfs`-Dateisystem-Projektion, es gibt also keine transparente Projektion, auf die man sich verlassen könnte. Prüfe die [Plattformhinweise](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#platform-and-maturity) für das, was jede Plattform unterstützt.

**Sichere Kin-spezifischen Zustand.** Commits, Branches, Reviews und Specs, die du mit Kin aufzeichnest, liegen in `.kin`, nicht in Git. `.kin` zu löschen und aus Git neu zu importieren stellt sie nicht wieder her, führe also zuerst `kin backup create` aus. Lies die [Hinweise zu Import, Wiederherstellung und Upgrade](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#what-is-real-today-and-what-is-beta).

**Windows.** Die native Windows-x86_64-Unterstützung ist früh. Die Repository-Aufnahme funktioniert: `kin init` importiert ein Git-Repository und veröffentlicht die Graph-Autorität, und Graph-, lexikalische und daemon-gestützte Abfragen antworten nativ. Der End-to-End-Installationsnachweis führt außerdem das Agent-Setup unter nativem Windows aus und erhält graph-gestützte Antworten vom installierten MCP-Server. Die transparente Dateisystem-Projektion wird unter Windows nicht ausgeliefert, und Review-Workflows sind dort noch nicht getestet, daher bleibt WSL2 der empfohlene Weg für das vollständige Kin-Erlebnis.

## Warum ich Kin gebaut habe

Ich habe immer wieder gesehen, wie Coding-Agenten Teile einer Codebasis zusammensetzten, die wir bereits durchgearbeitet hatten. Dann machte ich selbst eine Version dieser Arbeit, um ihre Änderungen zu überprüfen. Ich begann mich zu fragen, warum mehr von diesem strukturellen Verständnis nicht Teil des Repositorys selbst war.

Das ist es, was ich mit Kin baue.

Troy

## Mehr erfahren und beitragen

[CLI-Referenz](https://github.com/firelock-ai/kin/blob/main/docs/cli-reference.md) · [Architektur und detaillierte Grenzen](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md) · [Mitwirken](https://github.com/firelock-ai/kin/blob/main/CONTRIBUTING.md) · [Issues](https://github.com/firelock-ai/kin/issues/new/choose) · [Sicherheit](https://github.com/firelock-ai/kin/blob/main/SECURITY.md)

Kin und sein lokaler Stack, einschließlich [kin-db](https://github.com/firelock-ai/kin-db), stehen unter [Apache-2.0](https://github.com/firelock-ai/kin/blob/main/LICENSE). [KinLab](https://kinlab.ai) ist das separate proprietäre gehostete Produkt. Das Onboarding für öffentliche Repositories ist noch in Entwicklung.

kin

Beliebteste