Anchor MCP

Anchor es memoria local de repositorios y organizaciones para agentes de codificación de IA. Indexa el historial de PRs de GitHub, el código actual, pruebas, regresiones, arquitectura e impacto entre repositorios de forma local, y luego expone contexto conciso con citas a través de flujos de trabajo MCP y CLI. Prioriza lo local. Acceso de solo lectura a GitHub. Sin telemetría en CLI. Sin SaaS. Sin llamadas remotas a LLM.

GitHub
1
Prueba este MCPPatrocinado

Documentación

Anchor

npm version npm downloads license: MIT website GitHub Repo stars

Memoria local de repositorio y organización para agentes de codificación con IA.

Anchor es una herramienta de memoria local-first compatible con MCP que indexa el historial de PRs de GitHub, código local, pruebas, regresiones, patrones de arquitectura, reglas de equipo e impacto entre repositorios, para que los agentes de codificación con IA puedan hacer cambios de código más seguros con contexto respaldado por evidencia.

npx @pratik7368patil/anchor demo

Anchor social preview

Por qué los desarrolladores usan Anchor

  • Contexto MCP antes de editar: anchor_get_context ofrece a Cursor, Claude Code, Codex, VS Code, Antigravity y clientes MCP genéricos memoria concisa, clasificada y citada del repositorio y la organización antes de cambios no triviales.
  • Historial de PRs de GitHub como evidencia: cuerpos de PRs fusionados, comentarios de revisión, comentarios de issues, commits, etiquetas y regresiones se convierten en contexto local buscable.
  • Indexación local del código base: archivos actuales, símbolos, imports, pruebas, patrones de arquitectura y comandos de prueba se indexan en SQLite.
  • Memoria organizacional para agentes de IA: repositorios en lista blanca pueden clonarse localmente y vincularse mediante imports, paquetes, consumidores de API, esquemas y regresiones.
  • Sin SaaS, sin telemetría de CLI: los índices permanecen en tu máquina, el acceso a GitHub es de solo lectura y Anchor no llama a APIs de LLM remotas.

Qué hace diferente a Anchor

Anchor complementa las herramientas de búsqueda de código y las herramientas solo de grafo combinando el por qué cambió el código con el qué existe ahora. Devuelve citas de PRs, confianza, frescura, filtrado en modo estricto, pruebas relevantes, memoria de regresiones e impacto entre repositorios, en lugar de volcar contexto amplio en el prompt.

Por qué importa la memoria de repositorio y organización

La memoria del repositorio ayuda a un agente a entender el código que está editando: decisiones de PRs fusionados, restricciones de revisión, símbolos actuales, pruebas, patrones de arquitectura y regresiones conocidas. La memoria organizacional ayuda a un agente a entender el radio de impacto alrededor de ese repositorio: consumidores de API, paquetes compartidos, contratos de esquema, pruebas downstream y regresiones entre repositorios de repositorios explícitamente en lista blanca.

Esa combinación es la diferencia entre "cambia este archivo" y "cambia este archivo sin romper los contratos de los que depende el resto de la organización".

Cómo se compara Anchor

  • Anchor vs búsqueda de código: la búsqueda de código encuentra texto coincidente; Anchor añade historial de PRs, confianza, frescura, memoria de regresiones, pruebas y evidencia citada.
  • Anchor vs herramientas solo de grafo: los grafos muestran relaciones; Anchor empareja las relaciones con por qué importan y las expone mediante MCP para agentes.
  • Anchor vs MCPs de memoria genéricos: la memoria genérica almacena notas; Anchor construye memoria determinista de repositorio y organización a partir del historial de GitHub, código actual, pruebas, arquitectura e impacto entre repositorios.

Por qué los agentes de codificación con IA lo necesitan

Los agentes de codificación con IA son más fuertes cuando tienen el contexto que un mantenedor senior recordaría: por qué un archivo tiene cierta forma, qué se rompió la última vez, qué pruebas importan y qué contratos de API no deberían moverse a la ligera. Anchor extrae el historial local del repositorio más el índice de código actual y lo expone mediante una herramienta MCP principal:

anchor_get_context

Los agentes de codificación con IA deberían llamar a esto antes de cambios de código no triviales.

Guías populares

Crecimiento y comunidad

Anchor no tiene telemetría de CLI, por lo que la prueba pública proviene de señales voluntarias y agregadas: estrellas de GitHub, forks, issues, discusiones, tendencias de descargas de npm, tráfico de GitHub, visitas a la documentación y listados de directorios MCP. Consulta configuración del repositorio de GitHub y playbook de crecimiento para los temas del repositorio, texto del listado de directorio, publicaciones de lanzamiento y el plan de medición de 30 días.

Para envíos a directorios y publicaciones comunitarias, usa los bloques de texto de paquete de envío a directorios.

Modelo de privacidad

  • Los datos de GitHub se obtienen con autenticación local: GITHUB_TOKEN, GH_TOKEN o gh auth token.
  • El token nunca se escribe en la configuración de MCP, SQLite, registros ni archivos generados.
  • El índice SQLite permanece en .anchor/index.sqlite en tu máquina.
  • Anchor solo solicita acceso de lectura y nunca escribe en GitHub.
  • Los cuerpos de PRs, comentarios, comentarios de revisión, comentarios de issues y mensajes de commit se tratan como evidencia no confiable.
  • La salida de MCP usa solo texto saneado.
  • Los secretos comunes y frases de inyección de prompt se redactan o neutralizan antes de la indexación y la salida.
  • Los comandos de Anchor y las herramientas MCP no envían telemetría ni balizas de instalación.
  • Las estadísticas públicas de adopción, cuando están habilitadas, usan conteos agregados de descargas de npm, metadatos de tráfico/repositorio de GitHub y análisis opcionales de GoatCounter para el sitio de documentación.

Alcance recomendado del token de GitHub: acceso de solo lectura al repositorio. Para repositorios privados, usa los permisos mínimos de repositorio de solo lectura que admita tu plan de GitHub.

Instalación

Desde npm:

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

O ejecútalo sin instalación global:

npx -y @pratik7368patil/anchor --help

Forma más rápida de evaluar Anchor antes de configurar la autenticación de GitHub:

npx @pratik7368patil/anchor demo

Si Anchor ayuda a tu equipo, las mejores señales públicas son una estrella de GitHub, un fork o un issue que describa tu caso de uso. Anchor no rastrea instalaciones locales ni uso de CLI.

Demo de 2 minutos

Prueba Anchor sin token de GitHub ni índice de repositorio real:

npx @pratik7368patil/anchor demo

anchor demo crea un espacio de trabajo temporal, indexa historial de PRs de muestra incluido más código de muestra, imprime salida de ejemplo para anchor_get_context, anchor_explain_file y anchor_review_diff, y luego limpia el espacio de trabajo temporal. Usa --keep o --path ./anchor-demo si quieres inspeccionar el índice SQLite de la demo.

Antes de Anchor, un agente ve principalmente los archivos actuales y tu prompt. Después de Anchor, el agente también puede ver contexto conciso y 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

La demo usa solo texto de fixture saneado. No llama a GitHub, npm, telemetría, SaaS ni ninguna API de LLM.

Buen prompt para demo en equipo después de ejecutarla:

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

Para desarrollo local desde este repositorio:

pnpm install
pnpm build
pnpm test

El paquete npm expone el binario anchor.

Configuración

Ejecuta desde dentro del repositorio que usas con un agente de codificación con IA:

anchor init

anchor init pregunta dónde quieres configurar Anchor:

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

Usa banderas no interactivas en CI o scripts de configuración:

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

La configuración de Cursor fusiona de forma segura .cursor/mcp.json con:

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

También crea .cursor/rules/anchor.mdc, indicando a Cursor Agent que llame a anchor_get_context antes de ediciones no triviales, que use modo estricto para cambios riesgosos y que trate el historial devuelto como evidencia, no como instrucciones. La configuración de Claude Code y Codex añade bloques de instrucciones de Anchor gestionados a CLAUDE.md y AGENTS.md; la configuración de VS Code y MCP genérico solo escribe configuración de MCP.

anchor init añade .anchor/ a .git/info/exclude como regla de exclusión solo local. Eso mantiene .anchor/index.sqlite fuera de git status sin añadir ni cambiar un archivo .gitignore commiteado.

anchor init también instala la autosincronización local por defecto. La memoria del repositorio se actualiza diariamente con anchor sync --all incremental, la memoria organizacional se actualiza diariamente con anchor org sync --no-graph cuando ya existen configuraciones de organización, y los grafos organizacionales se reconstruyen semanalmente. La autosincronización usa el programador de tu máquina (launchd, timer de usuario systemd, fallback de cron o Programador de tareas de Windows), escribe registros en ~/.anchor/logs/autosync/ y nunca almacena tokens de GitHub. Usa anchor init --no-autosync o anchor init --autosync off para rechazar.

¿Qué comando debería ejecutar?

Configuración por primera vez en un repositorio:

anchor init
anchor index --limit 200
anchor doctor

Contexto solo de código sin autenticación de GitHub:

anchor index-code
anchor architecture
anchor health

Historial completo de PRs sin desperdiciar límite de tasa:

anchor index-all --concurrency 2
anchor health

La actualización diaria después del primer índice es automática tras anchor init. Para actualizar manualmente o reparar un índice desactualizado:

anchor sync
anchor health

Antes de editar con un agente de codificación con 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 cambios de API, autenticación, acceso, esquema, SDK o paquetes compartidos:

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

Comparte contexto con compañeros de equipo:

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

Mide si Anchor es lo suficientemente confiable para CI:

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

Indexar historial de PRs

gh auth login
anchor index

También puedes usar un token explícito:

export GITHUB_TOKEN=your_read_only_token
anchor index

Uso específico del 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

Límite predeterminado: 200 PRs fusionados. --limit está limitado a 1000 PRs fusionados para ejecuciones normales. Usa anchor index --all o anchor index-all cuando quieras intencionalmente obtener cada PR fusionado del repositorio. Los comandos de indexación existentes usan GitHub GraphQL primero para metadatos de PRs, comentarios, revisiones, commits, etiquetas y archivos modificados, y luego usan REST solo para enriquecer los parches de archivos de PRs para la extracción de contexto de diff. Anchor adapta el tamaño de página de GraphQL a partir de valores reales de rateLimit.cost y remaining, mantiene una reserva de seguridad antes de que se agote el presupuesto horario de GitHub, y guarda un punto de control de reanudación local cuando una ejecución de historial completo debería continuar después del reinicio. La indexación de historial completo sigue sujeta a los límites de tasa de GitHub, pero el procesamiento por lotes de GraphQL reduce enormemente el número de viajes de ida y vuelta en comparación con obtener cada endpoint de detalle de PR mediante REST. El enriquecimiento de parches usa paralelismo acotado. La concurrencia predeterminada es 5, y --concurrency está limitado a 10 para reducir la probabilidad de límites de tasa secundarios de GitHub.

Anchor también indexa el código base local por defecto después de la indexación de PRs. El descubrimiento de código usa git ls-files --cached --others --exclude-standard, por lo que incluye archivos rastreados más archivos no rastreados que no estén ignorados por git. Las rutas generadas/privadas como .anchor/, .cursor/, .codex/, .aws/, .ssh/, node_modules/, .nuxt/, .next/, dist/, build/, coverage/ y archivos tipo secreto como .env*, .npmrc, .netrc, *.pem, *.key y id_rsa siempre se omiten.

La indexación de código también actualiza la Memoria de Arquitectura: áreas de archivo deterministas, aristas de import, símbolos exportados, patrones de carpetas repetidos y convenciones de pruebas cercanas. Esto da a los agentes orientación sobre el código actual antes de añadir APIs, servicios, componentes, hooks, pruebas o refactors.

Usa anchor index-code para actualizar solo el índice del código base local sin autenticación de GitHub. Usa --no-code en comandos de indexación de PRs cuando solo quieras historial de PRs.

Después de la indexación, Anchor imprime conteos de resultados para decisiones de arquitectura, restricciones, contratos de API, notas de seguridad, regresiones, enlaces de pruebas, reglas de equipo y una puntuación de cobertura local. También sugiere un siguiente prompt para el agente.

La base de datos local se escribe en:

.anchor/index.sqlite

Guía de opciones de indexación

anchor index: Úsalo como el primer comando normal. Añade --repo owner/name cuando la detección remota de git no esté disponible, --limit 50 para una primera pasada rápida, --since YYYY-MM-DD para un relleno dirigido, --no-code para omitir la indexación de código, --force para reconstruir registros derivados locales y --concurrency 1-10 para ajustar el enriquecimiento suplementario de parches. Usa --all solo cuando quieras intencionalmente todos los PRs fusionados mediante el comando index.

anchor index-all: Úsalo para historial completo de PRs fusionados. Prefiere --concurrency 1 o --concurrency 2 en repositorios grandes. Usa --no-code si el índice de código ya está fresco, y vuelve a ejecutar el mismo comando después de un reinicio de GitHub si Anchor guardó un punto de control de reanudación. anchor index-code: Úsalo cuando no tengas autenticación de GitHub o solo necesites contexto del código actual. Actualiza fragmentos de código, enlaces de pruebas, comandos de prueba y Memoria de Arquitectura. Usa --force cuando anchor health reporte registros de código desactualizados o inconsistentes.

anchor sync: Úsalo después del primer índice. Es incremental y seguro de ejecutar repetidamente. Añade --all para ponerte al día desde un cursor antiguo, --since YYYY-MM-DD para sobrescribir el cursor, --no-code para sincronización solo de PRs, y --concurrency 1-10 para ajustar la presión de enriquecimiento de parches.

Anchor elige automáticamente la salida de progreso: progreso en vivo moderno en terminales interactivas, registros de línea simple en CI o shells no TTY, y sin progreso para salida JSON. Los comandos largos de org muestran el repositorio activo, la fase, los conteos, el tiempo transcurrido y la antigüedad de la última actualización en las búsquedas de GitHub, indexación de PRs en SQLite, indexación de código, indexación de arquitectura y creación de grafos.

Sincronización

Obtén incrementalmente los PRs actualizados desde la última sincronización:

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

anchor sync es seguro de ejecutar repetidamente. Usa --all para obtener cada PR fusionado actualizado desde el cursor de sincronización. Usa --force para reconstruir la base de datos local. La indexación del código base se actualiza por defecto a menos que se pase --no-code. La autosincronización programada de repositorios ejecuta la misma ruta incremental con --all --concurrency 2 y recurre a una actualización solo de código si la autenticación de GitHub no está disponible.

Memoria de Org

Anchor también puede construir una memoria de organización local y de lista permitida en múltiples repositorios. Esto es opcional y solo local: Anchor nunca escanea automáticamente todos los repositorios de la 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

Los datos de la org se almacenan en:

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

org.json es la lista permitida explícita. anchor org clone clona superficialmente los repositorios faltantes y actualiza los clones gestionados existentes. No ejecuta instalación, compilación, pruebas, creación de ramas, commits, pushes ni APIs de escritura de GitHub.

Comandos útiles 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

Guía de Opciones de Org

Usa --org my-org en cada comando de org para seleccionar el espacio de nombres local bajo ~/.anchor/orgs/<org>.

anchor org add-repo: Ejecuta sin <owner/name> para obtener los repositorios legibles de GitHub para --org y abrir un selector de selección múltiple con búsqueda. Escribe para filtrar, usa las flechas para moverte, espacio para seleccionar y enter para confirmar. Usa --search text para precargar el selector, --include-archived cuando quieras intencionalmente repositorios archivados, y --group backend|frontend|shared|infra|docs|unknown para aplicar un grupo a cada repositorio seleccionado. En scripts, CI o shells no TTY, pasa owner/name explícitamente. Usa --alias name solo con un repositorio explícito.

anchor org clone: Usa --repo owner/name para reintentar un repositorio de la lista permitida. Usa --concurrency 1-3 para controlar la presión local/red al clonar o actualizar múltiples repositorios. Anchor muestra automáticamente progreso en vivo en terminales interactivas y registros simples en CI.

anchor org index: Usa --repo owner/name para actualizar un repositorio, --code-only cuando la autenticación de GitHub no esté disponible o el historial de PRs ya esté actualizado, --prs-only cuando los clones ya estén actualizados, --no-graph cuando quieras omitir la reconstrucción final del grafo entre repositorios, y --force después de advertencias de índice desactualizado.

anchor org sync: Úsalo como el comando manual de actualización de org. La autosincronización lo ejecuta diariamente con --no-graph --concurrency 1 para cada org configurada, y luego ejecuta anchor org graph semanalmente. Añade --repo owner/name para un reintento enfocado, --since YYYY-MM-DD para una puesta al día dirigida de PRs, --concurrency 1-3 para listas permitidas grandes, --no-graph cuando quieras que el trabajo de clonación/indexación termine primero, y --force cuando el estado reporte datos de org desactualizados. Si una sincronización previa reciente ya terminó la indexación de PRs/código pero se interrumpió antes de completar el grafo, volver a ejecutar anchor org sync se reanuda desde la fase de grafo y omite búsquedas redundantes de PRs para los repositorios completados.

Mientras se ejecuta la sincronización/indexación/grafo, Anchor escribe un pequeño archivo local de heartbeat en ~/.anchor/orgs/<org>/sync-heartbeat.json. anchor org status --org my-org lo lee primero, para que pueda mostrar el comando activo, pid, repositorio, fase, tiempo transcurrido y antigüedad de la última actualización incluso si SQLite está temporalmente bloqueado por un escritor.

anchor org graph: Reconstruye aristas entre repositorios, contratos de API y consumidores de API desde la base de datos de org ya indexada sin clonar repositorios, buscar en GitHub ni reindexar código. Úsalo después de anchor org sync --no-graph, o cuando anchor org status muestre cero aristas entre repositorios/consumidores de API después de que termine la indexación. Añade --html para generar una página de grafo local independiente, --open para abrirla en tu navegador y --output path/to/graph.html para elegir la ruta del archivo.

Para organizaciones grandes, divide las fases costosas:

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: Usa --repo owner/name para identificar el repositorio que se está revisando, --diff-file change.diff en CI o revisión de diffs guardados, --strict para cambios de API/auth/acceso/paquetes compartidos, y --json para automatización. Añade --html para escribir un informe de impacto local independiente, --open para abrirlo en tu navegador y --output path/to/impact.html para elegir la ruta del archivo.

anchor org ci: Usa --strict para fallar ante anomalías bloqueantes/altas y --min-coverage 70 para imponer un umbral de cobertura de org. Añade --html para escribir un informe de CI local independiente, --open para abrirlo en tu navegador y --output path/to/ci.html para elegir la ruta del archivo.

anchor org map: Usa --format mermaid|json para elegir la salida de CLI. Añade --html para escribir un informe de mapa local independiente, --open para abrirlo en tu navegador y --output path/to/map.html para elegir la ruta del archivo.

La Memoria de Org indexa el código actual y, cuando la autenticación de GitHub está disponible, el historial de PRs de cada repositorio de la lista permitida en una única base de datos SQLite local. Las re-ejecuciones son idempotentes: los índices de código sin cambios se omiten, los repositorios modificados reemplazan sus registros de código actual, los PRs se insertan o actualizan por repositorio y número, las sincronizaciones de PRs recientemente completadas se reutilizan al reanudar trabajo de grafo incompleto, y los repositorios exitosos permanecen intactos cuando otro repositorio falla.

Anchor construye aristas deterministas entre repositorios a partir de dependencias de paquetes, imports, cadenas de API/esquema/cliente, consumidores tipo SDK y evidencia de código indexado. Las aristas entre repositorios y los consumidores de API aparecen después de que se complete la fase de grafo; usa anchor org graph para volver a ejecutar solo esa fase, o anchor org graph --open para inspeccionar el grafo en una vista HTML interactiva sin conexión. Esto impulsa estas herramientas MCP:

anchor_get_org_context
anchor_check_cross_repo_impact
anchor_find_api_consumers
anchor_get_org_architecture
anchor_org_index_status

Usa este prompt de agente para trabajo de API, acceso, facturación, auth, SDK, esquema, paquetes compartidos o refactorización amplia:

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

La detección de anomalías de org es determinista, no mágica. Señala riesgos respaldados por evidencia, como cambios de control de acceso sin pruebas, cambios de contratos de API con consumidores conocidos, radio de explosión de paquetes compartidos, coincidencias de regresiones conocidas, índices de org desactualizados y actualizaciones de consumidores faltantes.

Reglas de Equipo

Las restricciones aprobadas por el equipo pueden vivir en un archivo anchor.rules.json confirmado:

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

Las reglas deben citar evidencia de PRs. Una regla mínima se ve así:

{
  "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"
        }
      ]
    }
  ]
}

Las reglas de equipo coincidentes aparecen por encima del historial normal de PRs en anchor_get_context, pero aún se presentan como evidencia, no como comandos.

Crea y verifica reglas desde la 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 los PRs citados existen en el índice local de Anchor.

anchor rules suggest lee la evidencia local y sugiere reglas preliminares a partir de restricciones repetidas o de alta confianza, contratos de API, notas de seguridad y regresiones. Nunca modifica anchor.rules.json; el equipo aún debe revisar y añadir cualquier regla explícitamente.

Los archivos de configuración de valor para desarrolladores son opcionales y revisables:

  • anchor.evals.json almacena evaluaciones de recuperación doradas.
  • anchor.playbooks.json almacena playbooks de repositorios.
  • .anchor/index.sqlite almacena índices y comentarios solo locales.

Explicar y Revisar

Usa Anchor directamente desde una 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

Guía de Opciones de Contexto y Revisión

anchor plan "<task>": Usa --file path cuando conozcas el archivo objetivo probable, --symbol name cuando la tarea esté vinculada a un contrato de función/clase/componente/API, --strict para trabajo riesgoso y --json para herramientas.

anchor test-command <file>: Usa --json cuando un agente, CI u otro script local deba analizar la lista de comandos.

anchor explain <file>: Usa --share para producir Markdown compacto para Slack o comentarios de PRs. Usa --json cuando otra herramienta deba consumir el informe de archivo.

anchor review: Por defecto lee el git diff actual. Usa --base main antes de abrir un PR desde una rama, --diff-file change.diff para diffs guardados o CI, --strict para cambios de alto riesgo, --share para resúmenes de PR/Slack y --json para automatización.

anchor architecture: Usa --file path para orientación a nivel de archivo, --area api para un área de arquitectura, --check para el diff actual, --diff-file change.diff para diffs guardados, --map --format mermaid para documentación, --map --format json para herramientas, --write-doc solo cuando quieras intencionalmente ANCHOR_ARCHITECTURE.md, y --json para automatización.

anchor onboarding: Usa --file path para un informe breve de archivo específico, --area api para un informe breve de área y --json para automatización.

anchor plan "<task>" convierte la misma evidencia local en un plan de edición determinista: archivos objetivo, símbolos probables, pasos de implementación, riesgos, verificaciones exactas y evidencia de PRs/reglas/código.

anchor test-command <file> detecta el comando de prueba más específico que Anchor puede inferir de los scripts de paquetes, límites de workspace/paquetes, configuración de Vitest/Jest/Playwright y archivos de prueba relacionados.

anchor explain <file> resume lo que el archivo parece poseer, decisiones de PRs coincidentes, reglas de equipo, regresiones conocidas, pruebas relacionadas y símbolos importantes usando solo el índice local.

anchor review lee el git diff actual por defecto y agrupa los hallazgos respaldados por evidencia en bloqueadores, riesgos, restricciones históricas, preocupaciones de arquitectura, verificaciones de regresión y pruebas recomendadas exactas. Nunca aprueba ni rechaza código automáticamente.

anchor health se centra en la calidad del índice: historial parcial de PRs, índice de código desactualizado, reglas de equipo inválidas, última ejecución de indexación fallida, estado de autosincronización y el siguiente comando sugerido.

El modo --share imprime Markdown compacto para Slack o comentarios de PRs: resumen del archivo, restricciones clave, regresiones conocidas, pruebas probables y citas de PRs.

anchor prompts imprime prompts conscientes del objetivo para Cursor, Claude Code, Codex, VS Code, Antigravity o agentes genéricos.

anchor health y anchor_index_status incluyen una puntuación de cobertura local:

Anchor coverage: 72% (good)

La puntuación usa solo hechos locales: cobertura de PRs, frescura del índice de código, fragmentos de código, enlaces de pruebas, eventos de regresión, unidades de sabiduría, reglas de equipo y evidencia desactualizada.

Contexto de Pruebas y Regresiones

Anchor clasifica las pruebas con reglas deterministas como *.test.*, *.spec.*, __tests__, test/, tests/ y spec/. Vincula archivos fuente con pruebas probables por nombre base, directorio, imports e historial indexado.

La memoria de regresiones se extrae de títulos, cuerpos, comentarios, etiquetas y mensajes de commit de PRs usando frases como regression, revert, rollback, hotfix, incident, root cause, this broke y fixed by.

Memoria de Arquitectura

Anchor puede resumir la arquitectura actual del repositorio desde el í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

La Memoria de Arquitectura es determinista y respaldada por evidencia. Clasifica archivos en áreas como api, service, component, hook, route, store, test, schema, type, config y util, extrae aristas de imports y símbolos exportados, y detecta patrones de colocación repetidos. Almacena hechos de arquitectura saneados en SQLite, no texto fuente crudo.

Úsalo cuando un agente esté a punto de añadir una nueva integración, crear pruebas, mover código entre capas o refactorizar un área de funcionalidad. anchor architecture --check lee el diff de git actual por defecto y muestra patrones coincidentes de colocación/imports/pruebas. --write-doc es el único comando que escribe ANCHOR_ARCHITECTURE.md. anchor_get_context ahora puede incluir:

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

Los metadatos estructurados de MCP incluyen matchReasons, rankSignals, queryTerms, relevantTests, regressionEvents, reliabilityGate, rejectedHistory y indexHealth.

Flujos de trabajo de valor para desarrolladores

Anchor ahora cubre más partes del ciclo de desarrollo antes, durante y después de los cambios 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
  • La planificación de tareas combina historial de PR, evidencia de código, patrones de arquitectura, pruebas, regresiones y reglas en un pequeño plan de edición.
  • La guía de comandos de prueba ofrece a agentes y humanos comprobaciones exactas en lugar de consejos vagos como "ejecuta las pruebas".
  • Los mapas de arquitectura generan un gráfico determinista en Mermaid o JSON a partir de importaciones, áreas de archivos y enlaces de pruebas.
  • Las evaluaciones de recuperación permiten a un equipo fijar tareas de referencia a evidencia esperada de PR y detectar desviaciones en la clasificación.
  • El modo de vigilancia mantiene actualizados el código, la arquitectura, los enlaces de pruebas y los comandos de prueba mientras los desarrolladores trabajan.
  • anchor ci ejecuta validación de reglas, comprobaciones de evidencia, evaluaciones, comprobaciones de umbral de cobertura y comprobaciones de índice desactualizado para CI.
  • Los paquetes de incorporación resumen áreas del repositorio, archivos importantes, módulos de riesgo conocidos, convenciones de pruebas, manuales y indicaciones iniciales.
  • La retroalimentación local se almacena solo en SQLite y ajusta ligeramente la clasificación sin ocultar evidencia citada.
  • Los manuales de repositorio convierten evidencia repetida en resúmenes de trabajo revisados, como agregar integraciones de API, escribir pruebas de servicios o cambiar contratos de API.

Sugerencia de despliegue para el equipo:

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

Guía de opciones de fiabilidad

anchor eval add: Use --task, --file y --expect-pr para fijar una tarea realista a evidencia que debería mantener una clasificación alta.

anchor eval run: Use --json en CI o en scripts que necesiten detalles de aprobado/fallido.

anchor watch: Use --interval 30 para el desarrollo normal. Aumente el intervalo para repositorios muy grandes. Agregue --repo owner/name solo cuando la detección remota de git no esté disponible.

anchor ci: Use --strict cuando CI deba fallar de forma cerrada ante contexto débil/desactualizado y --min-coverage 70 cuando su equipo haya acordado un umbral de cobertura.

anchor rules suggest: Use --category api_contract para sugerencias enfocadas, --min-confidence strong para una adopción de bajo ruido y --json para herramientas.

anchor playbooks suggest: Use --json al revisar manuales en borrador a través de otra herramienta local.

Comprobación opcional de 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

Anchor no agrega este flujo de trabajo automáticamente. Los equipos deben optar por él después de acordar umbrales de cobertura y casos de evaluación.

Puerta de fiabilidad

Anchor está diseñado para reducir el contexto engañoso, no para pretender que el historial siempre es correcto. Durante anchor_get_context, Anchor contrasta la evidencia histórica de PR contra los archivos solicitados, símbolos, código actual indexado, reglas del equipo y patrones de arquitectura.

La puerta de fiabilidad:

  • acepta evidencia que no está desactualizada, cumple con el umbral de confianza solicitado y tiene una coincidencia directa de archivo, símbolo o evidencia repetida
  • marca coincidencias débiles, desactualizadas o de solo texto suelto en metadatos estructurados
  • falla de forma cerrada en modo estricto y devuelve No reliable historical evidence found. cuando nada califica
  • agrega líneas de advertencia cuando el contexto debe tratarse como una pista a verificar en lugar de una guía a seguir

Para cambios de alto riesgo, pida a su agente que llame a:

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

Los metadatos de MCP incluyen reliabilityGate y rejectedHistory, para que los agentes puedan inspeccionar por qué se confió o filtró la evidencia.

Búsqueda semántica local opcional

SQLite FTS sigue siendo el motor de recuperación predeterminado. El modo semántico opcional es solo local y está deshabilitado a menos que se solicite:

ANCHOR_SEMANTIC=local anchor serve

Si no hay un proveedor local de incrustaciones disponible, Anchor recurre a SQLite FTS sin fallar ni realizar llamadas de red.

Doctor

anchor doctor

Doctor verifica la detección de git, el análisis del remoto de GitHub, la presencia de tokens, la accesibilidad de la API de GitHub, la configuración del agente de IA seleccionado/detectado, la base de datos/esquema SQLite y el inicio de MCP. Las comprobaciones fallidas incluyen correcciones accionables.

Verificación del agente

Después de anchor init, reinicie o recargue su herramienta de IA seleccionada y verifique que el servidor MCP llamado anchor sea visible. Luego pregunte al agente:

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

Recetario de indicaciones 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 archivo:

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

Modo estricto:

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.

Planificar tarea:

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 prueba:

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

Arquitectura:

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

Impacto entre repositorios:

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.

Incorporación:

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

La entrada principal de la herramienta es:

{
  "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 cuando el agente solo deba recibir evidencia no desactualizada en o por encima de minConfidence con una señal directa de relevancia. Si nada califica, Anchor devuelve "No se encontró evidencia histórica confiable".

Herramientas secundarias:

  • anchor_search_history
  • anchor_index_status informa recuentos de PR/código, cobertura del historial, puntuación de cobertura, recuento de evidencia desactualizada, recuento de reglas del equipo y últimos tiempos de sincronización/índice.
  • 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 desarrollo

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

Automatización de lanzamientos

El repositorio incluye un flujo de trabajo de GitHub Actions que publica versiones de paquetes faltantes en npm después de que los cambios lleguen a main. Cuando cambia la versión del paquete, el mismo flujo de trabajo también crea un lanzamiento de GitHub llamado Anchor <version> con un registro de cambios generado a partir de los PR fusionados.

Secreto de repositorio requerido:

NPM_TOKEN

Flujo de lanzamiento:

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 un PR con el aumento de versión. Después de que el PR sea revisado y fusionado, GitHub Actions ejecuta las pruebas, compila los paquetes, publica cualquier versión de paquete que aún no esté en npm, crea la etiqueta v<version> y agrega el registro de cambios generado en GitHub Releases. Si el lanzamiento ya existe, el flujo de trabajo lo deja intacto para que las reejecuciones sean seguras.

Si el flujo de trabajo falla en npm whoami con E401 Unauthorized, actualice el secreto del repositorio de GitHub llamado NPM_TOKEN con un token de acceso/automatización de npm válido que pueda publicar los paquetes @pratik7368patil. Solo aumentar la versión no puede corregir un token de npm inválido.

Despliegue del sitio

El sitio de documentación se despliega en Netlify desde GitHub Actions cuando los cambios del sitio llegan a main.

Secretos de repositorio requeridos:

NETLIFY_AUTH_TOKEN
NETLIFY_SITE_ID

El flujo de trabajo compila el sitio Vite con:

pnpm site:build

Luego despliega apps/site/dist en el sitio de producción de Netlify configurado con la CLI de Netlify. El flujo de trabajo nunca almacena tokens de Netlify en el repositorio y deshabilita la telemetría de la CLI de Netlify en CI.

Si el despliegue falla porque faltan secretos, agréguelos en GitHub en Settings > Secrets and variables > Actions. NETLIFY_AUTH_TOKEN debe ser un token de acceso personal de Netlify. NETLIFY_SITE_ID es el ID de API del sitio de Netlify para anchor-mcp.netlify.app.

Analítica de adopción

Anchor rastrea la adopción sin agregar telemetría a la CLI ni al servidor MCP. El flujo de trabajo programado Collect adoption stats recopila señales públicas agregadas y las escribe en:

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

Secreto de repositorio requerido:

GH_TRAFFIC_TOKEN

Variable de repositorio recomendada:

VITE_GOATCOUNTER_CODE

GH_TRAFFIC_TOKEN se usa solo por GitHub Actions para leer el tráfico agregado del repositorio. VITE_GOATCOUNTER_CODE habilita la analítica GoatCounter respetuosa con la privacidad solo en el sitio de documentación. Las descargas de npm son recuentos direccionales de descargas de paquetes y pueden incluir CI, espejos, bots e instalaciones repetidas; los uniques de clonación/visitas de GitHub son señales de tráfico agregadas proporcionadas por la plataforma, no humanos únicos exactos.

El sitio de documentación también registra eventos agregados de GoatCounter para clics en CTA públicos y acciones de copiado, como copiar el comando de demostración o abrir GitHub. Estos eventos ocurren solo en el sitio web cuando GoatCounter está configurado, y se envían como solicitudes de navegador sin CORS con un respaldo de imagen para que el sitio no dependa de cargar un script de analítica de terceros. Los comandos de Anchor, las herramientas MCP, los índices locales, el uso de agentes, los nombres de repositorios, los nombres de archivos y las indicaciones nunca se envían.

Señales públicas útiles de tracción para observar en conjunto:

  • Tendencias de descargas de npm para demanda direccional de paquetes.
  • Clonadores y visitantes únicos de GitHub para interés aproximado del proyecto.
  • Estrellas, bifurcaciones, problemas y descargas de lanzamientos para participación de la comunidad.
  • Eventos de copiado/clic del sitio web para conversión de instalación a demostración.

Comandos locales:

pnpm stats:collect
pnpm stats:validate

Solución de problemas

Token faltante: Ejecute gh auth login, o exporte GITHUB_TOKEN/GH_TOKEN con un token de solo lectura, y luego vuelva a ejecutar anchor doctor.

Límite de tasa de GitHub: Anchor usa GraphQL de GitHub por defecto para la obtención por lotes del historial de PR y REST solo para el enriquecimiento de parches de PR. GraphQL tiene un presupuesto horario basado en puntos, cada conexión aún necesita paginación con valores de first/last de 1 a 100, y GitHub impone un número máximo posible de nodos por consulta. Anchor limita el tamaño de página de PR por debajo de ese límite de nodos anidados, detecta 403/429 de GitHub y respuestas de límite de tasa de GraphQL, espera retry-after o marcas de tiempo de reinicio, reduce el tamaño de página de GraphQL cuando una consulta es demasiado costosa y conserva datos útiles de GraphQL incluso cuando se omite el enriquecimiento opcional de parches REST. Anchor no recurrirá al rastreador REST más antiguo de detalles de PR cuando GraphQL esté limitado por tasa; si ve /pulls/{number}/reviews en los registros, actualice Anchor o verifique si hay un mensaje explícito de respaldo de GraphQL. Para index-all y sync --all, Anchor también guarda un punto de control local de reanudación de GraphQL antes de cruzar su reserva de seguridad; vuelva a ejecutar el mismo comando después del tiempo de reinicio de GitHub para continuar desde el cursor guardado. Para reducir la presión, use primero una ejecución más pequeña:

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

Use anchor index-all --concurrency 1 cuando desee la ejecución más segura de historial completo. Anchor indexa localmente, por lo que no necesita volver a obtener el historial sin cambios con frecuencia.

GraphQL devolvió HTML / Unexpected token '<': Esto significa que el punto final de GraphQL, un proxy o una capa de autenticación/SSO devolvió una página HTML en lugar de la respuesta JSON de GitHub. Anchor reintenta fallas transitorias de red/HTML de GraphQL antes de decidir si continuar, diferir o fallar claramente. Si persiste, verifique el estado de red/VPN/proxy/autenticación:

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

.cursor/mcp.json malformado: Corrija la sintaxis JSON y luego vuelva a ejecutar anchor init. Anchor fusiona de forma segura pero no adivinará a través de JSON inválido.

Índice vacío: Ejecute anchor index --repo owner/name --limit 200. Confirme que existen PR fusionados y que el token puede leerlos.

Servidor MCP no visible en Cursor: Vuelva a ejecutar anchor init, recargue Cursor y confirme que .cursor/mcp.json contiene la entrada del servidor anchor.

Si Cursor se abrió desde la aplicación de macOS y no puede encontrar el comando global anchor, actualice Anchor y vuelva a ejecutar anchor init:

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

Las versiones más nuevas de Anchor escriben la ruta resuelta del ejecutable en .cursor/mcp.json cuando es posible, lo que evita problemas de PATH en aplicaciones GUI.

Base de datos SQLite faltante: Ejecute anchor index. La ruta esperada es .anchor/index.sqlite.

Índice de Anchor visible en git: Ejecute anchor init nuevamente. Agrega .anchor/ a .git/info/exclude, que es solo local. Si .anchor/index.sqlite ya fue preparado o confirmado, ejecute git rm --cached .anchor/index.sqlite.

No se devolvió contexto relevante: Pruebe anchor sync y luego use anchor_search_history con una consulta más amplia, ruta de archivo o símbolo. Anchor solo devuelve evidencia encontrada en el índice local de PR.

Contexto de codebase faltante: Ejecute anchor index-code desde la raíz del repositorio. Confirme que anchor_index_status informa archivos de código y fragmentos de código distintos de cero.

Guía de arquitectura faltante: Ejecute anchor index-code desde la raíz del repositorio. Confirme que anchor_index_status informa patrones de arquitectura distintos de cero y luego pruebe anchor architecture --file path/to/file.ts.

Reglas del equipo inválidas: Ejecute anchor rules validate. Cada regla necesita un id, categoría, texto y al menos una referencia de evidencia de PR. Advertencia de salud del índice: Ejecuta anchor health para conocer el motivo y el siguiente comando sugerido. Las correcciones habituales son anchor index-code, anchor sync o anchor index-all.

Autosincronización no ejecutándose: Ejecuta anchor doctor y anchor health. Anchor informa si la autosincronización local está configurada, si existen archivos del programador y si la última ejecución programada falló. Los registros están en ~/.anchor/logs/autosync/. Vuelve a ejecutar anchor init para reinstalar los trabajos del programador, o desactívalo con anchor init --no-autosync.

Sin pruebas relacionadas: Ejecuta anchor index-code y confirma que los archivos de prueba no estén ignorados por git. Anchor solo vincula las pruebas que puede ver en archivos rastreados o no ignorados.

Repositorio de la organización no clonado: Ejecuta anchor org clone --org my-org --repo owner/name y luego anchor org status --org my-org.

Permiso de clonación denegado: Confirma que tu token de GitHub o credencial git local pueda leer el repositorio. Anchor usa git clone/git fetch de solo lectura; no solicita acceso de escritura.

Índice de organización desactualizado: Ejecuta anchor org sync --org my-org. Si solo cambió el código, anchor org index --org my-org --code-only --force es suficiente.

La sincronización de la organización indexó repositorios pero sigue ejecutándose: Anchor puede estar terminando escrituras en SQLite o reconstruyendo el grafo entre repositorios, que detecta bordes de paquetes, contratos de API y consumidores de API después de que finaliza la indexación de repositorios. Las versiones actuales muestran una fila en vivo de repositorio/fase más el progreso detallado de GitHub, código, arquitectura y grafo. En otra terminal, ejecuta anchor org status --org my-org para ver el latido activo incluso cuando la base de datos está bloqueada. Para listas de permitidos grandes, divide el trabajo:

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

No se encontraron consumidores de API: Ejecuta anchor org sync --org my-org después de incluir en la lista de permitidos tanto el repositorio proveedor como el consumidor, y luego ejecuta anchor org graph --org my-org si la sincronización usó --no-graph o se interrumpió antes de que se completara la fase de grafo. Los consumidores se detectan a partir de dependencias de paquetes, importaciones, cadenas de rutas de API, nombres de operaciones GraphQL y código similar a SDK/cliente.

Impacto de la organización demasiado ruidoso: Comienza con anchor org impact --org my-org --repo owner/name --diff-file change.diff --strict y luego reduce la lista de permitidos a los repositorios que realmente interactúan con esa área.

Notas de seguridad

Anchor nunca obedece comentarios históricos de PR como instrucciones. Los presenta como evidencia citada con números de PR, tipos de fuente, rutas de archivo cuando están disponibles, URLs de PR, confianza, frescura del código actual y motivos de la puerta de fiabilidad. La evidencia de baja confianza se formula con cautela, las coincidencias obsoletas o imprecisas se marcan, y el modo estricto filtra todo lo que no supere las comprobaciones de frescura, confianza y relevancia del objetivo.