Anchor MCP

Anchor é um repositório local e memória de organização para agentes de codificação de IA. Ele indexa o histórico de PRs do GitHub, código atual, testes, regressões, arquitetura e impacto entre repositórios localmente, depois expõe contexto conciso com citações por meio de fluxos de trabalho MCP e CLI. Prioridade local. Acesso somente leitura ao GitHub. Sem telemetria de CLI. Sem SaaS. Sem chamadas remotas de LLM.

GitHub
1

Documentação

Anchor

npm version npm downloads license: MIT website GitHub Repo stars

Memória local de repositório e organização para agentes de codificação de IA.

Anchor é uma ferramenta de memória local-first, compatível com MCP, que indexa histórico de PRs do GitHub, código local, testes, regressões, padrões de arquitetura, regras de equipe e impacto entre repositórios, para que agentes de codificação de IA possam fazer alterações de código mais seguras com contexto baseado em evidências.

npx @pratik7368patil/anchor demo

Anchor social preview

Por que os desenvolvedores usam o Anchor

  • Contexto MCP antes de edições: anchor_get_context fornece ao Cursor, Claude Code, Codex, VS Code, Antigravity e clientes MCP genéricos memória concisa, classificada e citada de repositório e organização antes de alterações não triviais.
  • Histórico de PRs do GitHub como evidência: corpos de PRs mesclados, comentários de revisão, comentários de issues, commits, labels e regressões tornam-se contexto local pesquisável.
  • Indexação local do código: arquivos atuais, símbolos, imports, testes, padrões de arquitetura e comandos de teste são indexados no SQLite.
  • Memória organizacional para agentes de IA: repositórios na allowlist podem ser clonados localmente e vinculados por imports, pacotes, consumidores de API, schemas e regressões.
  • Sem SaaS, sem telemetria de CLI: os índices permanecem na sua máquina, o acesso ao GitHub é somente leitura e o Anchor não chama APIs LLM remotas.

O que torna o Anchor diferente

O Anchor complementa ferramentas de busca de código e ferramentas somente de grafo ao combinar o porquê do código ter mudado com o que existe no código agora. Ele retorna citações de PRs, confiança, atualidade, filtragem em modo estrito, testes relevantes, memória de regressões e impacto entre repositórios, em vez de despejar contexto amplo no prompt.

Por que memória de repositório + organização é importante

A memória de repositório ajuda um agente a entender o código que está editando: decisões de PRs mesclados, restrições de revisão, símbolos atuais, testes, padrões de arquitetura e regressões conhecidas. A memória organizacional ajuda um agente a entender o raio de impacto ao redor desse repositório: consumidores de API, pacotes compartilhados, contratos de schema, testes downstream e regressões entre repositórios vindos de repositórios explicitamente na allowlist.

Essa combinação é a diferença entre "altere este arquivo" e "altere este arquivo sem quebrar os contratos dos quais o restante da organização depende".

Como o Anchor se compara

  • Anchor vs. busca de código: a busca de código encontra texto correspondente; o Anchor adiciona histórico de PRs, confiança, atualidade, memória de regressões, testes e evidências citadas.
  • Anchor vs. ferramentas somente de grafo: grafos mostram relações; o Anchor associa relações ao porquê elas importam e as expõe via MCP para agentes.
  • Anchor vs. MCPs de memória genéricos: memória genérica armazena notas; o Anchor constrói memória determinística de repositório e organização a partir do histórico do GitHub, código atual, testes, arquitetura e impacto entre repositórios.

Por que agentes de codificação de IA precisam dele

Agentes de codificação de IA são mais fortes quando têm o contexto que um mantenedor sênior lembraria: por que um arquivo tem determinado formato, o que quebrou da última vez, quais testes importam e quais contratos de API não devem ser movidos casualmente. O Anchor extrai o histórico local do repositório além do índice de código atual e expõe tudo por meio de uma ferramenta MCP principal:

anchor_get_context

Agentes de codificação de IA devem chamar esta ferramenta antes de alterações de código não triviais.

Guias populares

Crescimento e comunidade

O Anchor não tem telemetria de CLI, então a prova pública vem de sinais voluntários e agregados: estrelas no GitHub, forks, issues, discussões, tendências de download no npm, tráfego do GitHub, visitas à documentação e listagens em diretórios MCP. Consulte configurações do repositório no GitHub e playbook de crescimento para ver os tópicos do repositório, o texto das listagens em diretórios, posts de lançamento e o plano de medição de 30 dias.

Para envios a diretórios e posts na comunidade, use os blocos de texto em pacote de envio para diretórios.

Modelo de privacidade

  • Os dados do GitHub são obtidos com autenticação local: GITHUB_TOKEN, GH_TOKEN ou gh auth token.
  • O token nunca é gravado na configuração do MCP, no SQLite, em logs ou em arquivos gerados.
  • O índice SQLite permanece em .anchor/index.sqlite na sua máquina.
  • O Anchor solicita apenas acesso de leitura e nunca grava no GitHub.
  • Corpos de PRs, comentários, comentários de revisão, comentários de issues e mensagens de commit são tratados como evidência não confiável.
  • A saída do MCP usa apenas texto sanitizado.
  • Segredos comuns e frases de injeção de prompt são redigidos ou neutralizados antes da indexação e da saída.
  • Os comandos e as ferramentas MCP do Anchor não enviam telemetria nem beacons de instalação.
  • Estatísticas públicas de adoção, quando habilitadas, usam contagens agregadas de downloads do npm, tráfego/metadados do repositório no GitHub e análises opcionais do GoatCounter no site da documentação.

Escopo recomendado do token do GitHub: acesso somente leitura ao repositório. Para repositórios privados, use as permissões mínimas de somente leitura que seu plano do GitHub suportar.

Instalação

Via npm:

npm install -g @pratik7368patil/anchor
anchor --help

Ou execute sem instalação global:

npx -y @pratik7368patil/anchor --help

A maneira mais rápida de avaliar o Anchor antes de configurar a autenticação do GitHub:

npx @pratik7368patil/anchor demo

Se o Anchor ajudar sua equipe, os melhores sinais públicos são uma estrela no GitHub, um fork ou uma issue descrevendo seu caso de uso. O Anchor não rastreia instalações locais nem uso de CLI.

Demonstração de 2 minutos

Experimente o Anchor sem token do GitHub ou índice de repositório real:

npx @pratik7368patil/anchor demo

anchor demo cria um workspace temporário, indexa um histórico de PRs de exemplo incluído no pacote mais código de exemplo, imprime saída de exemplo para anchor_get_context, anchor_explain_file e anchor_review_diff, e depois limpa o workspace temporário. Use --keep ou --path ./anchor-demo se quiser inspecionar o índice SQLite da demonstração.

Antes do Anchor, um agente vê principalmente os arquivos atuais e seu prompt. Depois do Anchor, o agente também pode ver contexto conciso e citado, como:

[constraint] Do not remove the AuthCache lazy constraint...
Evidence: PR #101, review_comment, src/auth/cache.ts
Confidence: strong
Current code check: current

A demonstração usa apenas texto de fixture sanitizado. Ela não chama GitHub, npm, telemetria, SaaS nem qualquer API de LLM.

Bom prompt para demonstração em equipe após a execução:

Before editing this file, call anchor_get_context and summarize relevant historical constraints, tests, and regressions.

Para desenvolvimento local a partir deste repositório:

pnpm install
pnpm build
pnpm test

O pacote npm expõe o binário anchor.

Configuração

Execute a partir do repositório que você usa com um agente de codificação de IA:

anchor init

anchor init pergunta onde você quer configurar o Anchor:

Where do you want to configure Anchor?
[ ] Cursor
[ ] Claude Code
[ ] Codex
[ ] VS Code
[ ] Antigravity
[ ] Generic MCP config

Use flags não interativas em CI ou scripts de configuração:

anchor init --target cursor
anchor init --target cursor,codex,claude-code
anchor init --all-targets
anchor init --target cursor --no-autosync

A configuração do Cursor mescla .cursor/mcp.json com segurança usando:

{
  "mcpServers": {
    "anchor": {
      "command": "anchor",
      "args": ["serve"]
    }
  }
}

Ela também cria .cursor/rules/anchor.mdc, instruindo o Cursor Agent a chamar anchor_get_context antes de edições não triviais, usar modo estrito para alterações arriscadas e tratar o histórico retornado como evidência, não como instruções. A configuração do Claude Code e do Codex adiciona blocos de instruções gerenciados do Anchor a CLAUDE.md e AGENTS.md; a configuração do VS Code e de MCP genérico grava apenas a configuração do MCP.

anchor init adiciona .anchor/ a .git/info/exclude como regra de exclusão local. Isso mantém .anchor/index.sqlite fora de git status sem adicionar ou alterar um arquivo .gitignore versionado.

anchor init também instala a autossincronização local por padrão. A memória de repositório é atualizada diariamente com anchor sync --all incremental; a memória organizacional é atualizada diariamente com anchor org sync --no-graph quando as configurações organizacionais já existem; e os grafos organizacionais são reconstruídos semanalmente. A autossincronização usa o agendador da sua máquina (launchd, temporizador do usuário systemd, fallback de cron ou Agendador de Tarefas do Windows), grava logs em ~/.anchor/logs/autosync/ e nunca armazena tokens do GitHub. Use anchor init --no-autosync ou anchor init --autosync off para desativar.

Qual comando devo executar?

Configuração inicial em um repositório:

anchor init
anchor index --limit 200
anchor doctor

Contexto somente de código sem autenticação do GitHub:

anchor index-code
anchor architecture
anchor health

Histórico completo de PRs sem desperdiçar limite de taxa:

anchor index-all --concurrency 2
anchor health

A atualização diária após o primeiro índice é automática depois do anchor init. Para atualizar manualmente ou reparar um índice desatualizado:

anchor sync
anchor health

Antes de editar com um agente de codificação de IA:

anchor plan "Add API integration" --file src/api/routes.ts
anchor test-command src/api/routes.ts
anchor explain src/api/routes.ts

Antes de alterações em API, autenticação, acesso, schema, SDK ou pacotes compartilhados:

anchor org sync --org my-org --no-graph
anchor org graph --org my-org --open
anchor org map --org my-org --open
anchor org impact --org my-org --repo my-org/backend-api --strict --open

Compartilhe contexto com colegas de equipe:

anchor explain src/api/routes.ts --share
anchor review --share

Meça se o Anchor é confiável o suficiente para CI:

anchor health
anchor eval run
anchor ci --strict --min-coverage 70

Indexar histórico de PRs

gh auth login
anchor index

Você também pode usar um token explícito:

export GITHUB_TOKEN=your_read_only_token
anchor index

Uso específico por comando:

# Fast first index. Best default for most repos.
anchor index --repo owner/name --limit 200

# Full history. Use lower concurrency for large repos or tight rate limits.
anchor index-all --repo owner/name --concurrency 2

# PR-only refresh. Use when code index is already fresh.
anchor index --repo owner/name --no-code

# Code-only refresh. No GitHub token required.
anchor index-code --repo owner/name

# Targeted backfill from a known date.
anchor index --repo owner/name --since 2026-01-01

# Rebuild local derived records after stale/corrupt health warnings.
anchor index --repo owner/name --force

Limite padrão: 200 PRs mesclados. --limit tem limite de 1000 PRs mesclados para execuções normais. Use anchor index --all ou anchor index-all quando quiser intencionalmente buscar todos os PRs mesclados do repositório. Os comandos de indexação existentes usam GraphQL do GitHub primeiro para metadados de PRs, comentários, revisões, commits, labels e arquivos alterados; depois usam REST apenas para enriquecer os patches de arquivos dos PRs para extração de contexto de diff. O Anchor adapta o tamanho de página do GraphQL a partir dos valores reais de rateLimit.cost e remaining, mantém uma reserva de segurança antes do orçamento horário do GitHub se esgotar e salva um checkpoint local de retomada quando uma execução de histórico completo deve continuar após o reset. A indexação de histórico completo ainda está sujeita aos limites de taxa do GitHub, mas o agrupamento do GraphQL reduz muito o número de idas e voltas em comparação com buscar cada endpoint de detalhes de PR via REST. O enriquecimento de patches usa paralelismo limitado. A concorrência padrão é 5, e --concurrency tem limite de 10 para reduzir a chance de limites secundários de taxa do GitHub.

O Anchor também indexa a base de código local por padrão após a indexação de PRs. A descoberta de código usa git ls-files --cached --others --exclude-standard, portanto inclui arquivos rastreados e arquivos não rastreados que não são ignorados pelo git. Caminhos gerados/privados como .anchor/, .cursor/, .codex/, .aws/, .ssh/, node_modules/, .nuxt/, .next/, dist/, build/, coverage/ e arquivos semelhantes a segredos como .env*, .npmrc, .netrc, *.pem, *.key e id_rsa são sempre ignorados.

A indexação de código também atualiza a Memória de Arquitetura: áreas de arquivos determinísticas, arestas de import, símbolos exportados, padrões repetidos de pastas e convenções de testes próximas. Isso dá aos agentes orientação sobre o código atual antes de adicionar APIs, serviços, componentes, hooks, testes ou refatorações.

Use anchor index-code para atualizar apenas o índice local da base de código sem autenticação do GitHub. Use --no-code nos comandos de indexação de PRs quando quiser apenas o histórico de PRs.

Após a indexação, o Anchor imprime contagens de resultados para decisões de arquitetura, restrições, contratos de API, notas de segurança, regressões, links de testes, regras de equipe e uma pontuação local de cobertura. Ele também sugere um próximo prompt para o agente.

O banco de dados local é gravado em:

.anchor/index.sqlite

Guia de opções de indexação

anchor index: Use este como o primeiro comando normal. Adicione --repo owner/name quando a detecção de remote do git não estiver disponível, --limit 50 para uma primeira passagem rápida, --since YYYY-MM-DD para um backfill direcionado, --no-code para pular a indexação de código, --force para reconstruir registros derivados locais e --concurrency 1-10 para ajustar o enriquecimento complementar de patches. Use --all apenas quando quiser intencionalmente todos os PRs mesclados por meio do comando index.

anchor index-all: Use este para histórico completo de PRs mesclados. Prefira --concurrency 1 ou --concurrency 2 em repositórios grandes. Use --no-code se o índice de código já estiver atualizado e execute novamente o mesmo comando após um reset do GitHub se o Anchor tiver salvo um checkpoint de retomada. anchor index-code: Use isto quando você não tiver autenticação do GitHub ou precisar apenas do contexto do código atual. Ele atualiza os trechos de código, links de teste, comandos de teste e a Memória de Arquitetura. Use --force quando o anchor health relatar registros de código desatualizados ou inconsistentes.

anchor sync: Use isto após o primeiro índice. É incremental e seguro para executar repetidamente. Adicione --all para atualizar a partir de um cursor antigo, --since YYYY-MM-DD para substituir o cursor, --no-code para sincronização somente de PRs e --concurrency 1-10 para ajustar a pressão de enriquecimento de patches.

O Anchor escolhe automaticamente a saída de progresso: progresso ao vivo moderno em terminais interativos, logs de linha simples em CI ou shells não-TTY e nenhum progresso para saída JSON. Comandos longos de org mostram o repositório ativo, a fase, as contagens, o tempo decorrido e a idade da última atualização nas buscas do GitHub, na indexação de PRs no SQLite, na indexação de código, na indexação de arquitetura e na criação de grafos.

Sync

Busca incrementalmente PRs atualizados desde a última sincronização:

anchor sync
anchor sync --repo owner/name
anchor sync --all --concurrency 6
anchor sync --no-code

anchor sync é seguro para executar repetidamente. Use --all para buscar todos os PRs mesclados atualizados desde o cursor de sincronização. Use --force para reconstruir o banco de dados local. A indexação do código-base é atualizada por padrão, a menos que --no-code seja passado. A autosync agendada de repositórios executa o mesmo caminho incremental com --all --concurrency 2 e volta para atualização somente de código se a autenticação do GitHub não estiver disponível.

Org Memory

O Anchor também pode construir uma memória local de organização, com allowlist, em vários repositórios. Isso é opcional e somente local: o Anchor nunca examina automaticamente todos os repositórios da org.

anchor org init --org my-org
anchor org add-repo --org my-org
anchor org add-repo --org my-org --search api
anchor org add-repo my-org/backend-api --org my-org --group backend
anchor org sync --org my-org
anchor org status --org my-org

Os dados da org são armazenados em:

~/.anchor/orgs/<org>/
  org.json
  org.sqlite
  repos/

org.json é a allowlist explícita. anchor org clone faz clone superficial dos repositórios ausentes e atualiza os clones gerenciados existentes. Ele não executa install, build, testes, criação de branches, commits, pushes nem APIs de escrita do GitHub.

Comandos úteis de org:

anchor org list --org my-org
anchor org clone --org my-org --concurrency 3
anchor org index --org my-org --code-only
anchor org sync --org my-org --since 2026-01-01
anchor org sync --org my-org --no-graph --concurrency 2
anchor org graph --org my-org
anchor org graph --org my-org --open
anchor org map --org my-org --open
anchor org impact --org my-org --repo my-org/backend-api --strict --open
anchor org ci --org my-org --strict --min-coverage 70 --html

Guia de Opções de Org

Use --org my-org em todos os comandos de org para selecionar o namespace local sob ~/.anchor/orgs/<org>.

anchor org add-repo: Execute sem <owner/name> para buscar repositórios legíveis do GitHub para --org e abrir um seletor pesquisável de múltipla seleção. Digite para filtrar, use as setas para mover, espaço para selecionar e Enter para confirmar. Use --search text para pré-preencher o seletor, --include-archived quando quiser incluir intencionalmente repositórios arquivados e --group backend|frontend|shared|infra|docs|unknown para aplicar um grupo a cada repositório selecionado. Em scripts, CI ou shells não-TTY, passe owner/name explicitamente. Use --alias name somente com um repositório explícito.

anchor org clone: Use --repo owner/name para tentar novamente um repositório da allowlist. Use --concurrency 1-3 para controlar a pressão local/de rede ao clonar ou puxar vários repositórios. O Anchor mostra automaticamente progresso ao vivo em terminais interativos e logs simples em CI.

anchor org index: Use --repo owner/name para atualizar um repositório, --code-only quando a autenticação do GitHub não estiver disponível ou o histórico de PRs já estiver recente, --prs-only quando os clones já estiverem atualizados, --no-graph quando quiser pular a reconstrução final do grafo entre repositórios e --force após avisos de índice desatualizado.

anchor org sync: Use isto como o comando manual de atualização da org. A autosync o executa diariamente com --no-graph --concurrency 1 para cada org configurada e depois executa anchor org graph semanalmente. Adicione --repo owner/name para uma nova tentativa focada, --since YYYY-MM-DD para atualização direcionada de PRs, --concurrency 1-3 para allowlists grandes, --no-graph quando quiser que o trabalho de clone/indexação termine primeiro e --force quando o status relatar dados de org desatualizados. Se uma sincronização anterior recente já tiver concluído a indexação de PRs/código, mas tiver sido interrompida antes da conclusão do grafo, executar anchor org sync novamente retoma a partir da fase de grafo e evita buscas redundantes de PRs para repositórios concluídos.

Enquanto sync/indexação/grafo estão em execução, o Anchor grava um pequeno arquivo de heartbeat local em ~/.anchor/orgs/<org>/sync-heartbeat.json. anchor org status --org my-org lê esse arquivo primeiro, para que ainda possa mostrar o comando ativo, o pid, o repositório, a fase, o tempo decorrido e a idade da última atualização mesmo que o SQLite esteja temporariamente bloqueado por um escritor.

anchor org graph: Reconstrói arestas entre repositórios, contratos de API e consumidores de API a partir do banco de dados da org já indexado, sem clonar repositórios, buscar no GitHub ou reindexar código. Use após anchor org sync --no-graph ou quando anchor org status mostrar zero arestas entre repositórios/consumidores de API após a indexação terminar. Adicione --html para gerar uma página de grafo local autônoma, --open para abri-la no navegador e --output path/to/graph.html para escolher o caminho do arquivo.

Para organizações grandes, divida as fases custosas:

anchor org sync --org my-org --no-graph --concurrency 2
anchor org graph --org my-org --open
anchor org status --org my-org

anchor org impact: Use --repo owner/name para identificar o repositório em verificação, --diff-file change.diff em CI ou revisão de diffs salvos, --strict para mudanças de API/auth/access/pacotes compartilhados e --json para automação. Adicione --html para gravar um relatório de impacto local autônomo, --open para abri-lo no navegador e --output path/to/impact.html para escolher o caminho do arquivo.

anchor org ci: Use --strict para falhar em anomalias de bloqueio/alta prioridade e --min-coverage 70 para impor um limite de cobertura da org. Adicione --html para gravar um relatório de CI local autônomo, --open para abri-lo no navegador e --output path/to/ci.html para escolher o caminho do arquivo.

anchor org map: Use --format mermaid|json para escolher a saída da CLI. Adicione --html para gravar um relatório de mapa local autônomo, --open para abri-lo no navegador e --output path/to/map.html para escolher o caminho do arquivo.

A Org Memory indexa o código atual e, quando a autenticação do GitHub está disponível, o histórico de PRs de cada repositório da allowlist em um único banco de dados SQLite local. Execuções repetidas são idempotentes: indexações de código inalterado são ignoradas, repositórios alterados substituem seus registros de código atual, PRs são inseridos/atualizados por repositório e número, sincronizações de PRs recentemente concluídas são reutilizadas ao retomar trabalho de grafo inacabado e repositórios bem-sucedidos permanecem intactos quando outro repositório falha.

O Anchor constrói arestas determinísticas entre repositórios a partir de dependências de pacotes, imports, strings de API/schema/cliente, consumidores semelhantes a SDK e evidências de código indexado. Arestas entre repositórios e consumidores de API aparecem depois que a fase de grafo é concluída; use anchor org graph para executar novamente somente essa fase ou anchor org graph --open para inspecionar o grafo em uma visualização HTML interativa offline. Isso alimenta estas ferramentas MCP:

anchor_get_org_context
anchor_check_cross_repo_impact
anchor_find_api_consumers
anchor_get_org_architecture
anchor_org_index_status

Use este prompt de agente para trabalho de API, acesso, faturamento, auth, SDK, schema, pacotes compartilhados ou refatoração ampla:

Before changing this API/access logic, call anchor_check_cross_repo_impact.
Find affected repos, API consumers, regressions, and required tests.

A detecção de anomalias da org é determinística, não mágica. Ela sinaliza riscos baseados em evidências, como mudanças de controle de acesso sem testes, mudanças de contrato de API com consumidores conhecidos, raio de impacto de pacotes compartilhados, correspondências de regressões conhecidas, índices de org desatualizados e atualizações ausentes de consumidores.

Team Rules

Restrições aprovadas pela equipe podem viver em um arquivo anchor.rules.json versionado:

anchor rules init
anchor rules validate
anchor rules list
anchor rules suggest

As regras devem citar evidências de PRs. Uma regra mínima tem esta aparência:

{
  "version": 1,
  "rules": [
    {
      "id": "auth-cache-lazy",
      "category": "constraint",
      "text": "Keep `AuthCache` lazy because cold-start login regressed before.",
      "filePaths": ["src/auth/cache.ts"],
      "symbols": ["AuthCache"],
      "evidence": [
        {
          "prNumber": 101,
          "prUrl": "https://github.com/owner/repo/pull/101",
          "sourceType": "review_comment"
        }
      ]
    }
  ]
}

Regras correspondentes da equipe aparecem acima do histórico normal de PRs em anchor_get_context, mas ainda são apresentadas como evidência, não como comandos.

Crie e verifique regras a partir da CLI:

anchor rules add \
  --id auth-cache-lazy \
  --category constraint \
  --text "Keep AuthCache lazy because cold-start login regressed before." \
  --pr-number 101 \
  --pr-url https://github.com/owner/repo/pull/101 \
  --source-type review_comment \
  --file src/auth/cache.ts \
  --symbol AuthCache

anchor rules check-evidence

check-evidence confirma que os PRs citados existem no índice local do Anchor.

anchor rules suggest lê evidências locais e sugere rascunhos de regras a partir de restrições repetidas ou de alta confiança, contratos de API, notas de segurança e regressões. Ele nunca modifica anchor.rules.json; a equipe ainda precisa revisar e adicionar qualquer regra explicitamente.

Arquivos de configuração de valor para desenvolvedores são opcionais e revisáveis:

  • anchor.evals.json armazena evals de recuperação dourada (golden retrieval evals).
  • anchor.playbooks.json armazena playbooks de repositório.
  • .anchor/index.sqlite armazena índices e feedback somente locais.

Explain And Review

Use o Anchor diretamente de um terminal:

anchor plan "Add resource API integration" --file src/api/resource.ts --symbol createResource
anchor test-command src/api/resource.ts
anchor explain src/auth/cache.ts
anchor explain src/auth/cache.ts --share
anchor review
anchor review --base main
anchor review --diff-file change.diff --strict
anchor review --share
anchor health
anchor prompts

Guia de Opções de Contexto e Revisão

anchor plan "<task>": Use --file path quando você souber o provável arquivo alvo, --symbol name quando a tarefa estiver ligada a uma função/classe/componente/contrato de API, --strict para trabalho arriscado e --json para ferramentas.

anchor test-command <file>: Use --json quando um agente, CI ou outro script local precisar analisar a lista de comandos.

anchor explain <file>: Use --share para produzir Markdown compacto para Slack ou comentários de PR. Use --json quando outra ferramenta precisar consumir o briefing de arquivo.

anchor review: Por padrão, lê o git diff atual. Use --base main antes de abrir um PR a partir de um branch, --diff-file change.diff para diffs salvos ou CI, --strict para mudanças de alto risco, --share para resumos de PR/Slack e --json para automação.

anchor architecture: Use --file path para orientação em nível de arquivo, --area api para uma área de arquitetura, --check para o diff atual, --diff-file change.diff para diffs salvos, --map --format mermaid para documentação, --map --format json para ferramentas, --write-doc somente quando você quiser intencionalmente ANCHOR_ARCHITECTURE.md e --json para automação.

anchor onboarding: Use --file path para um briefing estreito de arquivo, --area api para um briefing de área e --json para automação.

anchor plan "<task>" transforma a mesma evidência local em um plano de edição determinístico: arquivos alvo, símbolos prováveis, etapas de implementação, riscos, verificações exatas e evidência de PR/regra/código.

anchor test-command <file> detecta o comando de teste mais específico que o Anchor consegue inferir a partir de scripts de pacote, limites de workspace/pacote, configuração de Vitest/Jest/Playwright e arquivos de teste relacionados.

anchor explain <file> resume o que o arquivo parece possuir, decisões de PR correspondentes, regras da equipe, regressões conhecidas, testes relacionados e símbolos importantes usando somente o índice local.

anchor review lê o git diff atual por padrão e agrupa descobertas baseadas em evidências em bloqueadores, riscos, restrições históricas, preocupações de arquitetura, verificações de regressão e testes recomendados exatos. Ele nunca aprova ou rejeita código automaticamente.

anchor health foca na qualidade do índice: histórico parcial de PRs, índice de código desatualizado, regras inválidas da equipe, última execução de indexação com falha, status da autosync e o próximo comando sugerido.

--share imprime Markdown compacto para Slack ou comentários de PR: resumo do arquivo, restrições principais, regressões conhecidas, testes prováveis e citações de PR.

anchor prompts imprime prompts cientes do alvo para Cursor, Claude Code, Codex, VS Code, Antigravity ou agentes genéricos.

anchor health e anchor_index_status incluem uma pontuação local de cobertura:

Anchor coverage: 72% (good)

A pontuação usa somente fatos locais: cobertura de PR, atualidade do índice de código, trechos de código, links de teste, eventos de regressão, unidades de conhecimento, regras da equipe e evidências desatualizadas.

Test-Aware And Regression Context

O Anchor classifica testes com regras determinísticas como *.test.*, *.spec.*, __tests__, test/, tests/ e spec/. Ele vincula arquivos de origem a testes prováveis por nome de arquivo base, diretório, imports e histórico indexado.

A memória de regressão é extraída de títulos, corpos, comentários, labels e mensagens de commit de PRs usando frases como regression, revert, rollback, hotfix, incident, root cause, this broke e fixed by.

Architecture Memory

O Anchor pode resumir a arquitetura atual do repositório a partir do índice de código local:

anchor architecture
anchor architecture --file src/auth/cache.ts
anchor architecture --area api
anchor architecture --map --format mermaid
anchor architecture --map --format json
anchor architecture --check
anchor architecture --diff-file change.diff --check
anchor architecture --write-doc
anchor architecture --json

A Memória de Arquitetura é determinística e baseada em evidências. Ela classifica arquivos em áreas como api, service, component, hook, route, store, test, schema, type, config e util, extrai arestas de import e símbolos exportados e detecta padrões repetidos de posicionamento. Ela armazena fatos de arquitetura sanitizados no SQLite, não o texto bruto da fonte.

Use quando um agente estiver prestes a adicionar uma nova integração, criar testes, mover código entre camadas ou refatorar uma área de funcionalidade. anchor architecture --check lê o diff atual do git por padrão e exibe padrões correspondentes de posicionamento/import/teste. --write-doc é o único comando que grava ANCHOR_ARCHITECTURE.md.

Fluxos de Trabalho de Valor para Desenvolvedores

O anchor_get_context agora pode incluir:

  • ## Team-approved rules
  • ## Must know
  • ## Codebase Evidence
  • ## Architecture Guidance
  • ## Relevant tests
  • ## Regression memory
  • ## Risks
  • ## Recommended checks

Os metadados estruturados do MCP incluem matchReasons, rankSignals, queryTerms, relevantTests, regressionEvents, reliabilityGate, rejectedHistory e indexHealth.

Fluxos de Trabalho de Valor para Desenvolvedores

O Anchor agora cobre mais partes do ciclo de desenvolvimento antes, durante e depois das mudanças de código:

anchor plan "Write tests for resource update" --file src/services/resource.ts --strict
anchor test-command src/services/resource.ts
anchor onboarding --area api
anchor eval init
anchor eval add --task "resource update contract" --file src/services/resource.ts --expect-pr 123
anchor eval run
anchor watch --interval 30
anchor ci --strict --min-coverage 70
anchor feedback record --result-id anchor-result-id --rating useful
anchor playbooks init
anchor playbooks suggest
anchor playbooks list
anchor playbooks get add-api-integration
  • O planejamento de tarefas combina histórico de PRs, evidências de código, padrões de arquitetura, testes, regressões e regras em um pequeno plano de edição.
  • As orientações de comandos de teste fornecem verificações exatas para agentes e humanos, em vez de conselhos vagos como "rode os testes".
  • Os mapas de arquitetura renderizam um gráfico determinístico em Mermaid ou JSON a partir de imports, áreas de arquivos e links de testes.
  • As avaliações de recuperação permitem que um time fixe tarefas douradas às evidências esperadas de PR e detecte desvios de ranqueamento.
  • O modo de observação mantém código, arquitetura, links de testes e comandos de teste atualizados enquanto os desenvolvedores trabalham.
  • anchor ci executa validações de regras, verificações de evidências, avaliações, checagens de limite de cobertura e verificações de índice desatualizado para CI.
  • Os pacotes de integração resumem áreas do repositório, arquivos importantes, módulos de risco conhecidos, convenções de teste, playbooks e prompts iniciais.
  • O feedback local é armazenado apenas em SQLite e ajusta levemente o ranqueamento sem ocultar evidências citadas.
  • Os playbooks de repositório transformam evidências repetidas em resumos de trabalho revisados, como adicionar integrações de API, escrever testes de serviço ou alterar contratos de API.

Sugestão de implantação para o time:

anchor demo
anchor init
anchor index --limit 200
anchor index-code
anchor health
anchor eval init
anchor rules suggest
anchor ci

Guia de Opções de Confiabilidade

anchor eval add: Use --task, --file e --expect-pr para fixar uma tarefa realista a evidências que devem manter um ranqueamento alto.

anchor eval run: Use --json em CI ou em scripts que precisam de detalhes de aprovação/reprovação.

anchor watch: Use --interval 30 para desenvolvimento normal. Aumente o intervalo para repositórios muito grandes. Adicione --repo owner/name apenas quando a detecção de repositório remoto via git não estiver disponível.

anchor ci: Use --strict quando o CI deve falhar de forma fechada com contexto fraco/desatualizado e --min-coverage 70 quando o time concordou com um limite de cobertura.

anchor rules suggest: Use --category api_contract para sugestões focadas, --min-confidence strong para adoção com baixo ruído e --json para ferramentas.

anchor playbooks suggest: Use --json ao revisar playbooks em rascunho por meio de outra ferramenta local.

Verificação opcional com GitHub Actions:

name: Anchor CI

on:
  pull_request:

jobs:
  anchor:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: pnpm/action-setup@v4
        with:
          version: 10.33.2
      - uses: actions/setup-node@v4
        with:
          node-version: 24
          cache: pnpm
      - run: pnpm install --frozen-lockfile
      - run: pnpm --filter @pratik7368patil/anchor build
      - run: pnpm --filter @pratik7368patil/anchor start -- index-code
      - run: pnpm --filter @pratik7368patil/anchor start -- ci --strict --min-coverage 70

O Anchor não adiciona esse workflow automaticamente. Os times devem optar por usá-lo após concordarem com limites de cobertura e casos de avaliação.

Portão de Confiabilidade

O Anchor foi projetado para reduzir contexto enganoso, não para fingir que o histórico está sempre correto. Durante anchor_get_context, o Anchor cruza evidências históricas de PRs com os arquivos solicitados, símbolos, código atual indexado, regras do time e padrões de arquitetura.

O portão de confiabilidade:

  • aceita evidências que não estão desatualizadas, atendem ao limite de confiança solicitado e têm correspondência direta de arquivo, símbolo ou evidência repetida
  • sinaliza correspondências fracas, desatualizadas ou apenas de texto solto nos metadados estruturados
  • falha de forma fechada em modo estrito e retorna No reliable historical evidence found. quando nada é qualificado
  • adiciona linhas de aviso quando o contexto deve ser tratado como uma pista a verificar, e não como orientação a seguir

Para mudanças de alto risco, peça ao seu agente para chamar:

{
  "task": "Refactor auth cache loading",
  "files": ["src/auth/cache.ts"],
  "symbols": ["AuthCache"],
  "strict": true,
  "minConfidence": "moderate"
}

Os metadados do MCP incluem reliabilityGate e rejectedHistory, para que os agentes possam inspecionar por que as evidências foram confiadas ou filtradas.

Busca Semântica Local Opcional

O SQLite FTS continua sendo o mecanismo de recuperação padrão. O modo semântico opcional é somente local e fica desabilitado, a menos que seja solicitado:

ANCHOR_SEMANTIC=local anchor serve

Se não houver um provedor de embeddings local disponível, o Anchor volta para o SQLite FTS sem falhar nem fazer chamadas de rede.

Doctor

anchor doctor

O Doctor verifica a detecção de git, o parse do repositório remoto no GitHub, a presença de tokens, a alcançabilidade da API do GitHub, a configuração do agente de IA selecionado/detectado, o banco de dados/esquema SQLite e a inicialização do MCP. As verificações que falham incluem correções acionáveis.

Verificação do Agente

Após anchor init, reinicie ou recarregue sua ferramenta de IA selecionada e verifique se o servidor MCP chamado anchor está visível. Então pergunte ao agente:

Before refactoring this file, call `anchor_get_context` and summarize relevant historical constraints.

Livro de Receitas de Prompts para Agentes

Antes de editar:

Before making this non-trivial code change, call `anchor_get_context` with the task, target files, relevant symbols, and current diff if available. Summarize the historical constraints before editing.

Explicar arquivo:

Before editing this file, call `anchor_explain_file` for the target file and summarize ownership, related PR decisions, regressions, and likely tests.

Modo estrito:

For this risky refactor, call `anchor_get_context` with `strict: true` and `minConfidence: "moderate"`. Only use non-stale evidence and cite PRs that affect the implementation.

Revisar diff:

After making the diff, call `anchor_review_diff` and list evidence-backed blockers, risks, historical constraints, regression checks, and recommended tests.

Planejar tarefa:

Before implementing this task, call `anchor_plan_task` with the task, target files, and likely symbols. Follow the evidence-backed plan and run the exact test commands it returns.

Comando de teste:

Before editing this file, call `anchor_get_test_commands` and use the most specific strong or moderate command after the change.

Arquitetura:

Before adding this API integration, call `anchor_get_architecture` for the `api` area and summarize existing placement, import, and test patterns.

Impacto cross-repo:

Before changing this access/API/shared-package logic, call `anchor_check_cross_repo_impact` and summarize affected repos, API consumers, regression memory, stale-index warnings, and required tests.

Integração:

Before working in this area, call `anchor_onboarding_pack` for the relevant file or architecture area and summarize important files, risks, tests, and playbooks.

A entrada principal da ferramenta é:

{
  "task": "Refactor auth cache loading",
  "files": ["src/auth/cache.ts"],
  "symbols": ["AuthCache"],
  "diff": "...optional current diff...",
  "currentCode": "...optional focused code...",
  "maxResults": 8,
  "strict": false,
  "minConfidence": "strong"
}

Use strict: true quando o agente deve receber apenas evidências não desatualizadas em ou acima de minConfidence com um sinal de relevância direta. Se nada for qualificado, o Anchor retorna "Nenhuma evidência histórica confiável encontrada."

Ferramentas secundárias:

  • anchor_search_history
  • anchor_index_status relata contagens de PR/código, cobertura de histórico, pontuação de cobertura, contagem de evidências desatualizadas, contagem de regras do time e últimos horários de sincronização/indexação.
  • anchor_explain_file
  • anchor_review_diff
  • anchor_get_architecture
  • anchor_check_architecture
  • anchor_plan_task
  • anchor_get_test_commands
  • anchor_get_architecture_map
  • anchor_onboarding_pack
  • anchor_get_playbook
  • anchor_get_org_context
  • anchor_check_cross_repo_impact
  • anchor_find_api_consumers
  • anchor_get_org_architecture
  • anchor_org_index_status

Comandos de Desenvolvimento

pnpm install
pnpm build
pnpm test
pnpm --filter @pratik7368patil/anchor start -- init
pnpm --filter @pratik7368patil/anchor start -- demo
pnpm --filter @pratik7368patil/anchor start -- prompts
pnpm --filter @pratik7368patil/anchor start -- index --repo owner/name --limit 10
pnpm --filter @pratik7368patil/anchor start -- plan "Add resource API" --file src/api/resource.ts
pnpm --filter @pratik7368patil/anchor start -- test-command src/api/resource.ts
pnpm --filter @pratik7368patil/anchor start -- explain src/auth/cache.ts
pnpm --filter @pratik7368patil/anchor start -- architecture
pnpm --filter @pratik7368patil/anchor start -- architecture --map --format mermaid
pnpm --filter @pratik7368patil/anchor start -- architecture --file src/auth/cache.ts
pnpm --filter @pratik7368patil/anchor start -- architecture --check --diff-file change.diff
pnpm --filter @pratik7368patil/anchor start -- review
pnpm --filter @pratik7368patil/anchor start -- health
pnpm --filter @pratik7368patil/anchor start -- onboarding --area api
pnpm --filter @pratik7368patil/anchor start -- eval init
pnpm --filter @pratik7368patil/anchor start -- eval run
pnpm --filter @pratik7368patil/anchor start -- ci
pnpm --filter @pratik7368patil/anchor start -- org init --org my-org
pnpm --filter @pratik7368patil/anchor start -- org add-repo --org my-org --search api
pnpm --filter @pratik7368patil/anchor start -- org add-repo my-org/backend-api --org my-org --group backend
pnpm --filter @pratik7368patil/anchor start -- org sync --org my-org
pnpm --filter @pratik7368patil/anchor start -- org graph --org my-org --html
pnpm --filter @pratik7368patil/anchor start -- org impact --org my-org --repo my-org/backend-api --diff-file change.diff
pnpm --filter @pratik7368patil/anchor start -- playbooks suggest
pnpm --filter @pratik7368patil/anchor start -- rules suggest
pnpm --filter @pratik7368patil/anchor start -- doctor
pnpm --filter @pratik7368patil/anchor start -- serve

Automação de Lançamento

O repositório inclui um workflow do GitHub Actions que publica no npm versões de pacotes ausentes após mudanças chegarem em main. Quando a versão do pacote mudar, o mesmo workflow também cria um GitHub Release chamado Anchor <version> com um changelog gerado a partir de PRs mesclados.

Segredo de repositório obrigatório:

NPM_TOKEN

Fluxo de lançamento:

npm --prefix packages/core version 0.1.15 --no-git-tag-version
npm --prefix packages/mcp-server version 0.1.15 --no-git-tag-version
npm --prefix packages/cli version 0.1.15 --no-git-tag-version

Abra um PR com o aumento de versão. Depois que o PR for revisado e mesclado, o GitHub Actions executa testes, compila os pacotes, publica qualquer versão de pacote que ainda não esteja no npm, cria a tag v<version> e adiciona o changelog gerado em GitHub Releases. Se o lançamento já existir, o workflow o deixa intacto para que reexecuções sejam seguras.

Se o workflow falhar em npm whoami com E401 Unauthorized, atualize o segredo do repositório GitHub chamado NPM_TOKEN com um token de automação/acesso npm válido que possa publicar os pacotes @pratik7368patil. Apenas aumentar a versão não corrige um token npm inválido.

Implantação do Site

O site de documentação é implantado no Netlify a partir do GitHub Actions quando mudanças no site chegam em main.

Segredos de repositório obrigatórios:

NETLIFY_AUTH_TOKEN
NETLIFY_SITE_ID

O workflow compila o site Vite com:

pnpm site:build

Em seguida, implanta apps/site/dist no site de produção do Netlify configurado usando o Netlify CLI. O workflow nunca armazena tokens do Netlify no repositório e desabilita a telemetria do Netlify CLI no CI.

Se a implantação falhar porque os segredos estão faltando, adicione-os no GitHub em Settings > Secrets and variables > Actions. NETLIFY_AUTH_TOKEN deve ser um token de acesso pessoal do Netlify. NETLIFY_SITE_ID é o ID da API do site Netlify para anchor-mcp.netlify.app.

Análise de Adoção

O Anchor acompanha a adoção sem adicionar telemetria ao CLI ou ao servidor MCP. O workflow agendado Collect adoption stats coleta sinais públicos agregados e os escreve em:

apps/site/public/stats/adoption.json
apps/site/public/stats/adoption-history.json

Segredo de repositório obrigatório:

GH_TRAFFIC_TOKEN

Variável de repositório recomendada:

VITE_GOATCOUNTER_CODE

GH_TRAFFIC_TOKEN é usado apenas pelo GitHub Actions para ler o tráfego agregado do repositório. VITE_GOATCOUNTER_CODE habilita análise GoatCounter amigável à privacidade somente no site de documentação. Os downloads do npm são contagens direcionais de downloads de pacotes e podem incluir CI, espelhos, bots e instalações repetidas; uniques do GitHub são sinais de tráfego agregados fornecidos pela plataforma, não humanos únicos exatos.

O site de documentação também registra eventos agregados do GoatCounter para cliques públicos em CTAs e ações de cópia, como copiar o comando de demonstração ou abrir o GitHub. Esses eventos ocorrem somente no site quando o GoatCounter está configurado e são enviados como solicitações de navegador sem CORS com um fallback de imagem para que o site não dependa de carregar um script de análise de terceiros. Comandos do Anchor, ferramentas MCP, índices locais, uso de agentes, nomes de repositórios, nomes de arquivos e prompts nunca são enviados.

Sinais públicos úteis de tração para observar juntos:

  • Tendências de downloads do npm para demanda direcional de pacotes.
  • Clonadores e visitantes únicos no GitHub para interesse aproximado no projeto.
  • Estrelas, forks, issues e downloads de releases para engajamento da comunidade.
  • Eventos de cópia/clique no site para conversão de instalação para demonstração.

Comandos locais:

pnpm stats:collect
pnpm stats:validate

Solução de Problemas

Token ausente: Execute gh auth login, ou exporte GITHUB_TOKEN/GH_TOKEN com um token somente leitura, e então execute novamente anchor doctor.

Limite de taxa do GitHub: O Anchor usa o GraphQL do GitHub por padrão para buscar histórico de PRs em lote e REST apenas para enriquecimento de patches de PR. O GraphQL tem um orçamento horário baseado em pontos, toda conexão ainda precisa de paginação com valores first/last de 1 a 100, e o GitHub impõe um número máximo possível de nós por consulta. O Anchor limita o tamanho da página de PR abaixo desse teto aninhado de nós, detecta respostas de limite de taxa do GitHub 403/429 e do GraphQL, espera por retry-after ou carimbos de redefinição, reduz o tamanho da página do GraphQL quando uma consulta é muito cara e mantém dados úteis do GraphQL mesmo quando o enriquecimento opcional de patches via REST é pulado. O Anchor não voltará ao antigo rastreador de detalhes de PR via REST quando o GraphQL estiver com limite de taxa; se você vir /pulls/{number}/reviews nos logs, atualize o Anchor ou verifique se há uma mensagem explícita de fallback do GraphQL. Para index-all e sync --all, o Anchor também salva um checkpoint local de retomada do GraphQL antes de cruzar sua reserva de segurança; execute novamente o mesmo comando após o horário de redefinição do GitHub para continuar a partir do cursor salvo. Para reduzir a pressão, use uma execução menor primeiro:

anchor index --limit 200 --concurrency 2
anchor sync --concurrency 2

Use anchor index-all --concurrency 1 quando quiser a execução mais segura de histórico completo. O Anchor indexa localmente, então você não precisa buscar novamente histórico inalterado com frequência.

GraphQL retornou HTML / Unexpected token '<': Isso significa que o endpoint GraphQL, um proxy ou uma camada de autenticação/SSO retornou uma página HTML em vez da resposta JSON do GitHub. O Anchor tenta novamente falhas transitórias de rede/HTML do GraphQL antes de decidir se continua, adia ou falha claramente. Se persistir, verifique o estado de rede/VPN/proxy/autenticação:

npm install -g @pratik7368patil/anchor@latest
gh auth status
anchor doctor

.cursor/mcp.json malformado: Corrija a sintaxe JSON e execute novamente anchor init. O Anchor mescla com segurança, mas não vai adivinhar através de JSON inválido.

Índice vazio: Execute anchor index --repo owner/name --limit 200. Confirme se existem PRs mesclados e se o token pode lê-los.

Servidor MCP não visível no Cursor: Execute novamente anchor init, recarregue o Cursor e confirme que .cursor/mcp.json contém a entrada do servidor anchor.

Se o Cursor foi aberto a partir do aplicativo macOS e não consegue encontrar o comando global anchor, atualize o Anchor e execute novamente anchor init:

npm install -g @pratik7368patil/anchor@latest
anchor init

Versões mais novas do Anchor gravam o caminho do executável resolvido em .cursor/mcp.json quando possível, o que evita problemas de PATH em aplicativos GUI.

Banco de dados SQLite ausente: Execute anchor index. O caminho esperado é .anchor/index.sqlite.

Índice do Anchor aparecendo no git: Execute anchor init novamente. Ele adiciona .anchor/ a .git/info/exclude, que é somente local. Se .anchor/index.sqlite já foi preparado ou commitado, execute git rm --cached .anchor/index.sqlite.

Nenhum contexto relevante retornado: Tente anchor sync, depois use anchor_search_history com uma consulta mais ampla, caminho de arquivo ou símbolo. O Anchor só retorna evidências encontradas no índice local de PRs.

Contexto do codebase ausente: Execute anchor index-code a partir da raiz do repositório. Confirme que anchor_index_status relata número diferente de zero de arquivos de código e blocos de código.

Orientação de arquitetura ausente: Execute anchor index-code a partir da raiz do repositório. Confirme que anchor_index_status relata número diferente de zero de padrões de arquitetura, e então tente anchor architecture --file path/to/file.ts.

Regras do time inválidas: Execute anchor rules validate. Cada regra precisa de um id, categoria, texto e pelo menos uma referência de evidência de PR. Aviso de saúde do índice: Execute anchor health para ver o motivo e o próximo comando sugerido. Correções comuns são anchor index-code, anchor sync ou anchor index-all.

Autosync não está em execução: Execute anchor doctor e anchor health. O Anchor informa se o autosync local está configurado, se os arquivos do agendador existem e se a última execução agendada falhou. Os logs estão em ~/.anchor/logs/autosync/. Execute novamente anchor init para reinstalar os jobs do agendador ou opte por sair com anchor init --no-autosync.

Nenhum teste relacionado: Execute anchor index-code e confirme que os arquivos de teste não são ignorados pelo git. O Anchor só vincula testes que consegue ver em arquivos rastreados ou não ignorados.

Repositório da org não clonado: Execute anchor org clone --org my-org --repo owner/name e depois anchor org status --org my-org.

Permissão de clone negada: Confirme que seu token do GitHub ou credencial git local pode ler o repositório. O Anchor usa git clone/git fetch somente leitura; ele não solicita acesso de escrita.

Índice da org desatualizado: Execute anchor org sync --org my-org. Se apenas o código mudou, anchor org index --org my-org --code-only --force é suficiente.

A sincronização da org indexou repositórios, mas ainda está em execução: O Anchor pode estar finalizando gravações do SQLite ou reconstruindo o grafo entre repositórios, que detecta arestas de pacotes, contratos de API e consumidores de API após a indexação dos repositórios terminar. As versões atuais mostram uma linha ao vivo de repositório/fase, além do progresso detalhado de GitHub, código, arquitetura e grafo. Em outro terminal, execute anchor org status --org my-org para ver o heartbeat ativo mesmo quando o banco de dados estiver bloqueado. Para allowlists grandes, divida o trabalho:

anchor org sync --org my-org --no-graph --concurrency 2
anchor org graph --org my-org --open

Nenhum consumidor de API encontrado: Execute anchor org sync --org my-org após incluir na allowlist os repositórios do provedor e do consumidor e, em seguida, execute anchor org graph --org my-org se a sincronização usou --no-graph ou foi interrompida antes da fase do grafo ser concluída. Os consumidores são detectados a partir de dependências de pacotes, imports, strings de rotas de API, nomes de operações GraphQL e código semelhante a SDK/cliente.

Impacto da org muito ruidoso: Comece com anchor org impact --org my-org --repo owner/name --diff-file change.diff --strict e depois reduza a allowlist para repositórios que realmente interagem com essa área.

Notas de Segurança

O Anchor nunca obedece a comentários históricos de PR como instruções. Ele os apresenta como evidências citadas com números de PR, tipos de fonte, caminhos de arquivo quando disponíveis, URLs de PR, confiança, atualidade do código atual e motivos de portão de confiabilidade. Evidências de baixa confiança são redigidas com cautela, correspondências desatualizadas ou vagas são sinalizadas e o modo estrito filtra qualquer coisa que não passe nas verificações de atualidade, confiança e relevância do alvo.