<h3 align="center">Uma nova base para código.</h3>

**Kin é um repositório de código nativo em grafo para pessoas e agentes de IA.** Ele armazena código-fonte, relacionamentos de código registrados e histórico versionado como estado do repositório. O grafo é o modelo do repositório, não um índice de busca mantido ao lado de outro repositório.

Funções, tipos e os relacionamentos entre eles são dados que você faz commit, branch e merge. O código-fonte exato é preservado byte a byte, e projeções de sistema de arquivos permitem que ferramentas compatíveis continuem funcionando com arquivos comuns.

**Beta público.** Experimente o Kin em um projeto real que você conhece bem. Espere arestas ásperas.

[Início rápido](#quickstart) · [Documentação](https://github.com/firelock-ai/kin/blob/main/docs/quickstart.md) · [Demonstração no navegador](https://kinlab.ai/demo)

Uma estrela ajuda outras pessoas a encontrarem o Kin, e as [Discussões](https://github.com/firelock-ai/kin/discussions) são o lugar para trazer uma dúvida sobre ele.

## Veja o que se conecta

Antes de alterar uma função compartilhada, o que mais você deveria inspecionar? O Kin permite consultar seus chamadores registrados e explorar código relacionado. A CLI e o servidor MCP consultam o mesmo grafo, então você e seu agente podem trabalhar a partir do mesmo registro.

*Registrado em um grafo preparado do ripgrep em `e89fff89ac9af12e8d4ce9d5fd07beb408ca730f`. Os artefatos brutos da execução não são públicos. Isto ilustra um fluxo de trabalho, não um benchmark de desempenho.*

## Use no Claude Code, Codex ou Cursor

Para o Claude Code:

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

Para o [Codex](https://github.com/firelock-ai/kin/blob/main/plugins/kin-codex/README.md#install), adicione o marketplace e instale o plugin, ou deixe `kin setup --intent agent` escrever o servidor MCP em `~/.codex/config.toml` para você.

Para o Cursor, adicione o servidor MCP manualmente; veja [plugins/kin-cursor](https://github.com/firelock-ai/kin/blob/main/plugins/kin-cursor/README.md#install) para o trecho exato.

Após instalar, execute `kin init .` em um clone novo de um projeto que você conhece bem; a skill `kin-setup` orienta você pelo resto.

O Kin não é publicado no crates.io. O crate `kin` lá é um projeto não relacionado.

## Início rápido

Comece em um clone novo e completo de um projeto que você conhece bem. `kin init` lê seu histórico Git sem alterá-lo nem aos seus arquivos rastreados. Ele adiciona um diretório `.kin` e uma linha em `.git/info/exclude`. A importação cobre todos os commits alcançados pelos seus branches e tags, então tempo, memória e disco crescem com o histórico, não com o tamanho do checkout. Antes de começar, `kin init` verifica memória e disco livre e para com os números quando já consegue perceber que a máquina está no limite. **Clones rasos, submódulos e Git LFS não são suportados**, e hooks do Git, um checkout esparso ou um merge ou rebase inacabado também interrompem a importação. `kin init` indica a correção para cada caso, e um clone novo evita a maioria deles.

### 1. Instalar

No macOS, Linux e WSL2, um comando instala o Kin e conecta as ferramentas de codificação com IA que
encontra. Ele precisa do Node.js 20 ou mais recente:

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

Em uma máquina sem Node, execute o instalador. `get.kinlab.ai` e `get.kinlab.dev`
servem o mesmo script:

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

De qualquer forma, recarregue seu shell como um comando separado, porque a instalação coloca `kin` em
`~/.kin/bin` e adiciona esse diretório ao seu perfil de shell para novas sessões:

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

No Windows x64 nativo, instale pelo PowerShell com `irm https://get.kinlab.dev/install.ps1 | iex`.
Ele instala a CLI `kin` e não conecta ferramentas de codificação com IA, porque o WSL2 continua sendo o
caminho recomendado no Windows. A entrada do Windows em [Limites do beta](#beta-limits)
diz o que funciona lá. Nenhuma build nativa para Windows ARM64 é publicada. Em uma máquina ARM64, execute
essa linha no PowerShell x64 para instalar a build x86_64 sob emulação, ou use o WSL2.
O instalador adiciona `kin` ao PATH do seu usuário, então abra uma nova janela do PowerShell no lugar de
`exec "$SHELL" -l` antes do próximo passo.

Para outros instaladores ou solução de problemas, veja o [início rápido completo](https://github.com/firelock-ai/kin/blob/main/docs/quickstart.md#1-install).

### 2. Inicializar o repositório

No novo prompt, clone um repositório com o Kin:

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

Ou inicialize um que você já tem, substituindo o caminho abaixo:

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

Ambos terminam com o próximo comando a executar, uma pergunta `kin refs` sobre uma função naquele
repositório. Eles também conectam o Codex CLI e o Grok CLI a ele quando você permitiu isso na configuração,
porque esses clientes mantêm uma entrada que nomeia um repositório.

O Windows PowerShell 5.1 não tem `&&`, então no Windows nativo execute os mesmos comandos um de cada
vez e pare se algum falhar:

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

`kin overview` mostra as entidades que o Kin importou. `kin status` mostra o que foi admitido e o estado da árvore de trabalho em relação a isso. `kin graph status` reporta o grafo de consulta ao vivo do daemon e a cobertura. Alterações não commitadas e não rastreadas não fazem parte do histórico Git importado; `kin init` reporta o que deixou de fora.

### 3. Faça uma pergunta que você possa verificar

Procure algo que você já sabe que está no código:

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

Substitua `ExactEntityName` abaixo por um símbolo do resultado:

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

`refs` retorna referências registradas, `trace` traz contexto próximo, e `impact` explora efeitos potenciais através do grafo. Confira os resultados com o código-fonte.

### 4. Suas ferramentas de codificação com IA e busca semântica

`kin setup` já perguntou antes de conectar as ferramentas de codificação com IA que encontrou, e as conectou
se você disse sim. Não há uma etapa separada de vinculação. Depois de instalar outra ferramenta, execute
`kin setup` novamente, e `kin setup status` mostra o que está conectado. No Windows, conecte as ferramentas de IA
dentro do WSL2.

A busca semântica roda em um modelo local de cerca de 523 MB, e a configuração pergunta antes que qualquer coisa
o baixe. Se você disse não, ou `kin init` diz que o índice de busca está aguardando o modelo,
isto o baixa e constrói o índice:

```sh
kin embed
```

O Kin suporta Claude Code, Codex, Cursor, Gemini e outros clientes MCP. Use `kin setup --intent editor` para o VS Code. O Kin também inclui `kin agent run` para endpoints de modelo compatíveis com OpenAI locais ou hospedados.

[Configuração do cliente](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#works-with-your-agent) · [Ferramentas MCP](https://github.com/firelock-ai/kin/blob/main/docs/mcp-tools.md) · [Agente integrado](https://github.com/firelock-ai/kin/blob/main/docs/cli-reference.md#kin-agent)

Importações, armazenamento e consultas locais rodam na sua máquina. A instalação e o download inicial do modelo de embeddings precisam de acesso à rede. Antes que os embeddings estejam prontos, `kin locate` usa sinais lexicais e de grafo e reporta a cobertura vetorial ausente.

## Revise uma mudança

Depois de executar `kin init` no branch Git que você quer revisar, compare SHAs de commit explícitos com `main`:

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

O relatório retorna `PASS`, `NEEDS ATTENTION` ou `WOULD BLOCK`, com impacto derivado do grafo e evidências de apoio. **Ele é consultivo:** não bloqueia um merge nem altera o estado do grafo. A autoria é declarada, não verificada de forma independente.

## Use o Kin com ou sem Git

O Kin tem seus próprios commits, branches, merges, diffs e histórico, inclusive em repositórios sem Git por baixo. Repositórios Git existentes podem ser importados, e fluxos de trabalho suportados podem exportar um novo repositório Git.

[Passo a passo do controle de versão nativo](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#version-control-without-git) · [Interoperabilidade com Git e limites de exportação](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#how-kin-relates-to-git)

## Limites do beta

**A cobertura é incompleta.** Linguagens suportadas são analisadas em entidades e relacionamentos; outros arquivos permanecem disponíveis como conteúdo e histórico. Um resultado vazio não prova que não há chamadores ou dependências. Continue usando seu compilador, testes e revisão. Veja [suporte a linguagens](https://github.com/firelock-ai/kin/blob/main/docs/language-support.md).

**A compatibilidade varia.** Os arquivos de release não incluem a projeção de sistema de arquivos `kin-vfs` obsoleta, então não há uma projeção transparente com que contar. Verifique as [notas de plataforma](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#platform-and-maturity) para saber o que cada plataforma suporta.

**Faça backup do estado exclusivo do Kin.** Commits, branches, revisões e specs que você registra com o Kin ficam em `.kin`, não no Git. Excluir `.kin` e reimportar do Git não os recupera, então execute `kin backup create` primeiro. Leia as [notas de importação, recuperação e atualização](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#what-is-real-today-and-what-is-beta).

**Windows.** O suporte nativo a Windows x86_64 é inicial. A admissão de repositório funciona: `kin init` importa um repositório Git e publica a autoridade do grafo, e consultas de grafo, lexicais e com suporte do daemon respondem nativamente. A prova de instalação ponta a ponta também executa a configuração do agente no Windows nativo e obtém respostas com base no grafo a partir do servidor MCP instalado. A projeção transparente de sistema de arquivos não é distribuída no Windows, e os fluxos de revisão ainda não foram testados lá, então o WSL2 continua sendo o caminho recomendado para a experiência completa do Kin.

## Por que construí o Kin

Eu ficava vendo agentes de codificação juntarem partes de uma base de código que já tínhamos trabalhado. Depois eu fazia uma versão desse trabalho por conta própria para revisar as mudanças deles. Comecei a me perguntar por que mais dessa compreensão estrutural não fazia parte do próprio repositório.

É isso que estou construindo com o Kin.

Troy

## Saiba mais e contribua

[Referência da CLI](https://github.com/firelock-ai/kin/blob/main/docs/cli-reference.md) · [Arquitetura e limites detalhados](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md) · [Contribuindo](https://github.com/firelock-ai/kin/blob/main/CONTRIBUTING.md) · [Issues](https://github.com/firelock-ai/kin/issues/new/choose) · [Segurança](https://github.com/firelock-ai/kin/blob/main/SECURITY.md)

O Kin e sua stack local, incluindo o [kin-db](https://github.com/firelock-ai/kin-db), são [Apache-2.0](https://github.com/firelock-ai/kin/blob/main/LICENSE). O [KinLab](https://kinlab.ai) é o produto hospedado proprietário separado. A integração de repositórios públicos ainda está em desenvolvimento.

kin

Mais Populares