<h3 align="center">Una nuova base per il codice.</h3>

**Kin è un repository di codice nativo a grafo per agenti AI e per le persone che costruiscono con loro.** Memorizza il codice sorgente, le relazioni tra codice registrate e la cronologia versionata come stato del repository. Il grafo è il modello del repository, non un indice di ricerca mantenuto accanto a un altro repository.

Funzioni, tipi e le relazioni tra essi sono dati che puoi committare, ramificare e unire. Il codice sorgente esatto è preservato byte per byte, e le proiezioni del filesystem permettono agli strumenti supportati di continuare a funzionare con file ordinari.

**Beta pubblica.** Prova Kin su un progetto reale che conosci bene. Aspettati qualche asperità.

[Avvio rapido](#quickstart) · [Documentazione](https://github.com/firelock-ai/kin/blob/main/docs/quickstart.md) · [Demo nel browser](https://kinlab.ai/demo)

Una stella aiuta altre persone a trovare Kin, e le [Discussioni](https://github.com/kinlab-ai/kin/discussions) sono il luogo dove porre domande al riguardo.

## Scopri cosa è connesso

Prima di modificare una funzione condivisa, cos'altro dovresti ispezionare? Kin ti permette di cercare i suoi chiamanti registrati ed esplorare il codice correlato. La CLI e il server MCP interrogano lo stesso grafo, così tu e il tuo agente potete lavorare dallo stesso registro.

*Registrato su un grafo ripgrep preparato a `e89fff89ac9af12e8d4ce9d5fd07beb408ca730f`. Gli artefatti grezzi dell'esecuzione non sono pubblici. Questo illustra un flusso di lavoro, non un benchmark di prestazioni.*

## Usalo da Claude Code, Codex o Cursor

Per Claude Code:

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

Per [Codex](https://github.com/firelock-ai/kin/blob/main/plugins/kin-codex/README.md#install), aggiungi il marketplace e installa il plugin, oppure lascia che `kin setup --intent agent` scriva il server MCP in `~/.codex/config.toml` per te.

Per Cursor, aggiungi il server MCP manualmente; consulta [plugins/kin-cursor](https://github.com/firelock-ai/kin/blob/main/plugins/kin-cursor/README.md#install) per lo snippet esatto.

Dopo l'installazione, esegui `kin init .` in un clone nuovo di un progetto che conosci bene; la skill `kin-setup` ti guida attraverso il resto.

Kin non è pubblicato su crates.io. Il crate `kin` presente lì è un progetto non correlato.

## Avvio rapido

Inizia in un clone nuovo e completo di un progetto che conosci bene. `kin init` legge la tua cronologia Git senza modificarla né modificare i tuoi file tracciati. Mantiene il suo archivio fuori dal tuo checkout, in `~/.kin/stores`, e non scrive nulla nel repository; `kin store path` stampa dove si trova l'archivio di un checkout. Per impostazione predefinita ammette prima il commit estratto, così le domande ricevono risposta non appena quell'albero è letto, e poi importa in background ogni commit raggiunto dai tuoi branch e tag, a bassa priorità; `kin init --history full` importa l'intera cronologia in anticipo, mentre `--history none` non la importa mai. L'importazione della cronologia richiede tempo, memoria e spazio su disco che crescono con la cronologia anziché con la dimensione del checkout. Prima di iniziare, `kin init` controlla la memoria e lo spazio libero su disco e si ferma mostrando i numeri quando può già stabilire che la macchina è a corto di risorse. **Un clone shallow ammette solo il suo commit estratto, e i submodule e Git LFS non sono supportati**, inoltre gli hook Git, uno sparse checkout o un merge o rebase incompleto bloccano anch'essi l'importazione. `kin init` indica la soluzione per ciascuno, e un clone nuovo evita la maggior parte di questi problemi.

### 1. Installazione

Su macOS, Linux e WSL2, un solo comando installa Kin e collega gli strumenti di coding AI che
trova. Richiede Node.js 20 o superiore:

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

Su una macchina senza Node, esegui invece l'installer. `get.kinlab.ai` e `get.kinlab.dev` servono lo stesso script:

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

In entrambi i casi, ricarica la shell come comando separato, perché l'installazione mette `kin` in
`~/.kin/bin` e aggiunge quella directory al profilo della shell per le nuove sessioni:

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

Su Windows x64 nativo, installa da PowerShell con `irm https://get.kinlab.dev/install.ps1 | iex`.
Installa la CLI `kin` e non collega gli strumenti di coding AI, perché WSL2 rimane il
percorso consigliato su Windows. La voce Windows sotto [Limiti della beta](#beta-limits)
indica cosa funziona lì. Non viene pubblicata alcuna build nativa per Windows ARM64. Su una macchina ARM64, esegui
quella riga da PowerShell x64 per installare la build x86_64 in emulazione, oppure usa WSL2.
L'installer aggiunge `kin` al PATH utente, quindi apri una nuova finestra di PowerShell al posto di
`exec "$SHELL" -l` prima del passaggio successivo.

Per altri installer o per la risoluzione dei problemi, consulta la [guida rapida completa](https://github.com/firelock-ai/kin/blob/main/docs/quickstart.md#1-install).

### 2. Inizializza il repository

Al nuovo prompt, clona un repository con Kin:

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

Oppure inizializzane uno che hai già, sostituendo il percorso seguente:

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

Entrambi terminano con il prossimo comando da eseguire, una domanda `kin refs` riguardante una funzione in quel repository. Collegano inoltre ad esso Codex CLI e Grok CLI quando lo hai consentito durante la configurazione, perché quei client mantengono una singola voce che nomina un repository.

Windows PowerShell 5.1 non dispone di `&&`, quindi su Windows nativo esegui gli stessi comandi uno alla volta e interrompi se uno fallisce:

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

`kin overview` mostra le entità importate da Kin. `kin status` mostra cosa è stato ammesso e lo stato dell'albero di lavoro rispetto ad esso. `kin graph status` riporta il grafo delle query live del daemon e la copertura. Le modifiche non committate e non tracciate non fanno parte della cronologia Git importata; `kin init` riporta ciò che ha escluso.

### 3. Fai una domanda verificabile

Cerca qualcosa che sai già essere nel codice:

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

Sostituisci `ExactEntityName` qui sotto con un simbolo dal risultato:

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

`refs` restituisce i riferimenti registrati, `trace` recupera il contesto circostante e `impact` esplora i potenziali effetti attraverso il grafo. Verifica i risultati rispetto alla fonte.

### 4. I tuoi strumenti di coding AI e la ricerca semantica

`kin setup` ha già chiesto prima di connettere gli strumenti di coding AI che ha trovato, e li ha connessi
se hai risposto sì. Non esiste un passaggio di collegamento separato. Dopo aver installato un altro strumento, esegui
di nuovo `kin setup`, e `kin setup status` mostra cosa è connesso. Su Windows, connetti gli strumenti
AI all'interno di WSL2.

`kin runtime status --json` verifica l'installazione condivisa della CLI e del daemon, inclusa
la loro esatta identità di origine. I comandi normali rifiutano le coppie non corrispondenti; le build
di sviluppo utilizzano uno stato isolato. Vedi [runtime installation](https://github.com/firelock-ai/kin/blob/main/docs/runtime-installation.md).

Il recupero tramite grafo e lessicale funziona senza un modello. Gli embedding e il reranking sono opzionali,
e i loro provider di modelli predefiniti sono impostati su `none`. Le build standard della CLI e del daemon includono il supporto
per modelli HTTP esterni. I modelli integrati richiedono una build con l'inferenza locale opzionale abilitata.

Per creare un indice di embedding utilizzando un endpoint compatibile con OpenAI che gestisci:

```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
```

Gli endpoint del modello ricevono il testo dell'entità selezionata necessario per la loro fase.
Le [impostazioni del modello](https://github.com/firelock-ai/kin/blob/main/docs/env-vars.md) descrivono i provider, le identità dei modelli e i nomi delle variabili d'ambiente per le credenziali.

Kin supporta Claude Code, Codex, Cursor, Gemini e altri client MCP. Usa `kin setup --intent editor` per VS Code. Kin include anche `kin agent run` per endpoint di modelli compatibili con OpenAI locali o ospitati.

[Configurazione del client](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#works-with-your-agent) · [Strumenti MCP](https://github.com/firelock-ai/kin/blob/main/docs/mcp-tools.md) · [Agente integrato](https://github.com/firelock-ai/kin/blob/main/docs/cli-reference.md#kin-agent)

Gli import locali, l'archiviazione e le query sul grafo vengono eseguiti sulla tua macchina. L'installazione di Kin richiede accesso alla rete; il percorso predefinito di recupero del grafo non richiede il download di alcun modello. Quando viene selezionato un provider di embedding, le query riportano la sua copertura vettoriale e eventuali lacune.

## Rivedere una modifica

Dopo aver eseguito `kin init` sul branch Git che vuoi rivedere, confronta gli SHA dei commit espliciti con `main`:

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

Il report restituisce `PASS`, `NEEDS ATTENTION` o `WOULD BLOCK`, con impatto derivato dal grafo e prove a supporto. **È consultivo:** non blocca un merge né modifica lo stato del grafo. La paternità è dichiarata, non verificata in modo indipendente.

## Usare Kin con o senza Git

Kin ha i propri commit, branch, merge, diff e cronologia, anche in repository senza Git sottostante. I repository Git esistenti possono essere importati, e i flussi di lavoro supportati possono esportare un nuovo repository Git.

[Guida al controllo di versione nativo](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#version-control-without-git) · [Interoperabilità con Git e limiti dell'esportazione](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#how-kin-relates-to-git)

## Limiti della beta

**La copertura è incompleta.** Le lingue supportate vengono analizzate in entità e relazioni; gli altri file restano disponibili come contenuto e cronologia. Un risultato vuoto non dimostra che non ci siano chiamanti o dipendenze. Continua a usare il tuo compilatore, i test e la revisione. Vedi [supporto delle lingue](https://github.com/firelock-ai/kin/blob/main/docs/language-support.md).

**La compatibilità varia.** Gli archivi di rilascio non includono la proiezione del filesystem deprecata `kin-vfs`, quindi non c'è una proiezione trasparente su cui fare affidamento. Consulta le [note sulla piattaforma](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#platform-and-maturity) per ciò che supporta ciascuna piattaforma.

**Esegui il backup dello stato esclusivo di Kin.** I commit, i branch, le revisioni e le specifiche che registri con Kin risiedono nell'archivio Kin del repository, non in Git. Eliminare l'archivio e reimportare da Git non li recupera, quindi esegui prima `kin backup create`. `kin store prune` elimina gli archivi solo quando passi `--yes`, per lo stesso motivo. Leggi le [note su importazione, recupero e aggiornamento](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#what-is-real-today-and-what-is-beta).

**Windows.** Il supporto nativo per Windows x86_64 è in fase iniziale. L'ammissione del repository funziona: `kin init` importa un repository Git e pubblica l'autorità del grafo, e le query sul grafo, lessicali e basate sul daemon rispondono in modo nativo. La prova di installazione end-to-end esegue anche la configurazione dell'agente su Windows nativo e ottiene risposte basate sul grafo dal server MCP installato. La proiezione trasparente del filesystem non è distribuita su Windows, e i flussi di lavoro di revisione non sono ancora testati lì, quindi WSL2 resta il percorso consigliato per l'esperienza completa di Kin.

## Perché ho creato Kin

Continuavo a vedere gli agenti di programmazione mettere insieme pezzi di una codebase che avevamo già analizzato. Poi facevo una versione di quel lavoro io stesso per rivedere le loro modifiche. Ho iniziato a chiedermi perché una parte maggiore di quella comprensione strutturale non facesse parte del repository stesso.

È questo che sto costruendo con Kin.

Troy

## Scopri di più e contribuisci

[Riferimento CLI](https://github.com/firelock-ai/kin/blob/main/docs/cli-reference.md) · [Architettura e limiti dettagliati](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md) · [Contribuire](https://github.com/firelock-ai/kin/blob/main/CONTRIBUTING.md) · [Issue](https://github.com/kinlab-ai/kin/issues/new/choose) · [Sicurezza](https://github.com/firelock-ai/kin/blob/main/SECURITY.md)

Kin e il suo stack locale, incluso [kin-db](https://github.com/kinlab-ai/kin-db), sono distribuiti con licenza [Apache-2.0](https://github.com/firelock-ai/kin/blob/main/LICENSE). [KinLab](https://kinlab.ai) è il prodotto ospitato proprietario separato. L'onboarding del repository pubblico è ancora in sviluppo.

kin

Più Popolari