repo-scan

¿Qué hace repo-scan?

Cada ecosistema tiene su propio gestor de dependencias, pero ninguna herramienta analiza C++, Android, iOS y Web para decirte: cuánto código es realmente tuyo, qué es de terceros y qué es peso muerto.

Cuándo Usarlo

• Al asumir una base de código grande y heredada, necesitando una visión estructural general.
• Antes de una reestructuración mayor — identificar qué es núcleo, qué está duplicado, qué está obsoleto.
• Auditar dependencias de terceros incrustadas directamente en el código fuente (no declaradas en gestores de paquetes).
• Preparar registros de decisiones de arquitectura para la reorganización de un monorepositorio.

Instalación

# Clone primero para que el commit fijo pueda revisarse antes de la instalación
set -euo pipefail

REPO_SCAN_COMMIT=2742664ebcad1450c208eda0ae45d3c17fad5dd8
REPO_SCAN_INSTALL_DIR="${CLAUDE_CONFIG_DIR:-$HOME/.claude}/skills/repo-scan"
REPO_SCAN_INSTALL_PARENT="$(dirname "$REPO_SCAN_INSTALL_DIR")"
mkdir -p "$REPO_SCAN_INSTALL_PARENT"
REPO_SCAN_TMP="$(mktemp -d "$REPO_SCAN_INSTALL_PARENT/.repo-scan-install.XXXXXX")"
REPO_SCAN_TOKEN="${REPO_SCAN_TMP##*.}"
REPO_SCAN_STAGE="$REPO_SCAN_TMP/stage-$REPO_SCAN_TOKEN"
REPO_SCAN_BACKUP="$REPO_SCAN_TMP/backup-$REPO_SCAN_TOKEN"
REPO_SCAN_LOCK="$REPO_SCAN_INSTALL_PARENT/.repo-scan-install.lock"
REPO_SCAN_KEEP_TMP=0
REPO_SCAN_LOCK_HELD=0
REPO_SCAN_MV_HAS_NO_TARGET=0
cleanup_repo_scan_install() {
  if [ "$REPO_SCAN_KEEP_TMP" -eq 0 ]; then
    rm -rf -- "$REPO_SCAN_TMP"
  fi
  if [ "$REPO_SCAN_LOCK_HELD" -eq 1 ] && ! rmdir -- "$REPO_SCAN_LOCK"; then
    printf 'No se pudo liberar el bloqueo de instalación en %s\n' "$REPO_SCAN_LOCK" >&2
  fi
}
trap cleanup_repo_scan_install EXIT
mkdir "$REPO_SCAN_TMP/mv-probe-source"
if mv -T -- "$REPO_SCAN_TMP/mv-probe-source" \
  "$REPO_SCAN_TMP/mv-probe-destination" 2>/dev/null; then
  REPO_SCAN_MV_HAS_NO_TARGET=1
  rmdir "$REPO_SCAN_TMP/mv-probe-destination"
else
  rmdir "$REPO_SCAN_TMP/mv-probe-source"
fi
move_repo_scan_dir() {
  REPO_SCAN_MOVE_SOURCE=$1
  REPO_SCAN_MOVE_DESTINATION=$2
  REPO_SCAN_MOVE_NAME=${REPO_SCAN_MOVE_SOURCE##*/}
  if [ -e "$REPO_SCAN_MOVE_DESTINATION" ] || [ -L "$REPO_SCAN_MOVE_DESTINATION" ]; then
    return 1
  fi
  if [ "$REPO_SCAN_MV_HAS_NO_TARGET" -eq 1 ]; then
    mv -T -- "$REPO_SCAN_MOVE_SOURCE" "$REPO_SCAN_MOVE_DESTINATION"
    return
  fi
  if ! mv -- "$REPO_SCAN_MOVE_SOURCE" "$REPO_SCAN_MOVE_DESTINATION"; then
    return 1
  fi
  if [ -e "$REPO_SCAN_MOVE_DESTINATION/$REPO_SCAN_MOVE_NAME" ] || \
    [ -L "$REPO_SCAN_MOVE_DESTINATION/$REPO_SCAN_MOVE_NAME" ]; then
    if ! mv -- "$REPO_SCAN_MOVE_DESTINATION/$REPO_SCAN_MOVE_NAME" \
      "$REPO_SCAN_MOVE_SOURCE"; then
      REPO_SCAN_KEEP_TMP=1
      printf 'La recuperación de conflicto de movimiento falló; los datos preparados permanecen en %s\n' \
        "$REPO_SCAN_MOVE_DESTINATION/$REPO_SCAN_MOVE_NAME" >&2
    fi
    return 1
  fi
}

git clone --filter=blob:none --no-checkout \
  https://github.com/haibindev/repo-scan.git "$REPO_SCAN_TMP/source"
git -C "$REPO_SCAN_TMP/source" checkout --detach "$REPO_SCAN_COMMIT"
mkdir -p "$REPO_SCAN_STAGE"
git -C "$REPO_SCAN_TMP/source" archive "$REPO_SCAN_COMMIT" | \
  tar -xf - -C "$REPO_SCAN_STAGE"

# Revise "$REPO_SCAN_TMP/source" antes de aprobar la instalación.
printf 'Escriba install para reemplazar %s después de revisar el código fuente fijo: ' \
  "$REPO_SCAN_INSTALL_DIR" >&2
read -r REPO_SCAN_CONFIRM
if [ "$REPO_SCAN_CONFIRM" != install ]; then
  printf 'Instalación cancelada.\n' >&2
  exit 1
fi
if ! mkdir -- "$REPO_SCAN_LOCK" 2>/dev/null; then
  printf 'Otra instalación de repo-scan tiene el bloqueo en %s\n' \
    "$REPO_SCAN_LOCK" >&2
  exit 1
fi
REPO_SCAN_LOCK_HELD=1

if [ -e "$REPO_SCAN_INSTALL_DIR" ] || [ -L "$REPO_SCAN_INSTALL_DIR" ]; then
  move_repo_scan_dir "$REPO_SCAN_INSTALL_DIR" "$REPO_SCAN_BACKUP"
fi
if ! move_repo_scan_dir "$REPO_SCAN_STAGE" "$REPO_SCAN_INSTALL_DIR"; then
  if [ -e "$REPO_SCAN_BACKUP" ] || [ -L "$REPO_SCAN_BACKUP" ]; then
    if [ -e "$REPO_SCAN_INSTALL_DIR" ] || [ -L "$REPO_SCAN_INSTALL_DIR" ]; then
      REPO_SCAN_KEEP_TMP=1
      printf 'El reemplazo falló y el destino fue recreado; la instalación anterior se conserva en %s\n' \
        "$REPO_SCAN_BACKUP" >&2
    elif ! move_repo_scan_dir "$REPO_SCAN_BACKUP" "$REPO_SCAN_INSTALL_DIR"; then
      REPO_SCAN_KEEP_TMP=1
      printf 'El reemplazo y la reversión fallaron; la instalación anterior se conserva en %s\n' \
        "$REPO_SCAN_BACKUP" >&2
    fi
  fi
  exit 1
fi

Revise el código fuente antes de instalar cualquier habilidad de agente.

La instalación completa solo el arranque. Recargue su entorno de agente y luego invoque repo-scan nuevamente. Este puntero ECC instala la habilidad externa pero no ejecuta un análisis en sí.

Capacidades Principales

Capacidad	Descripción
Análisis entre pilas	C/C++, Java/Android, iOS (OC/Swift), Web (TS/JS/Vue) en una sola pasada
Clasificación de archivos	Cada archivo etiquetado como código propio, de terceros o artefacto de construcción
Detección de bibliotecas	Más de 50 bibliotecas conocidas (FFmpeg, Boost, OpenSSL…) con extracción de versiones
Veredictos de cuatro niveles	Activo Principal / Extraer y Fusionar / Reconstruir / Retirar
Informes HTML	Páginas interactivas con tema oscuro y navegación jerárquica
Soporte para monorepos	Análisis jerárquico con informes de resumen y subproyectos

Niveles de Profundidad de Análisis

Nivel	Archivos Leídos	Caso de Uso
fast	1-2 por módulo	Inventario rápido de directorios enormes
standard	2-5 por módulo	Auditoría predeterminada con verificaciones completas de dependencias y arquitectura
deep	5-10 por módulo	Agrega seguridad de hilos, gestión de memoria y consistencia de API
full	Todos los archivos	Revisión exhaustiva previa a la fusión

Cómo Funciona

1. Clasificar la superficie del repositorio: enumerar archivos y etiquetar cada uno como código propio, código de terceros incrustado o artefacto de construcción.
2. Detectar bibliotecas incrustadas: inspeccionar nombres de directorios, encabezados, archivos de licencia y marcadores de versión para identificar dependencias incluidas y sus versiones probables.
3. Puntuar cada módulo: agrupar archivos por módulo o subsistema, luego asignar uno de los cuatro veredictos basado en propiedad, duplicación y costo de mantenimiento.
4. Resaltar riesgos estructurales: señalar artefactos de peso muerto, envoltorios duplicados, código obsoleto de proveedores y módulos que deberían extraerse, reconstruirse o retirarse.
5. Producir el informe: devolver un resumen conciso más la salida HTML interactiva con desglose por módulo para que la auditoría pueda revisarse de forma asíncrona.

Ejemplos

En un monorepositorio C++ de 50.000 archivos:

• Encontró FFmpeg 2.x (versión 2015) todavía en producción
• Descubrió el mismo envoltorio de SDK duplicado 3 veces
• Identificó 636 MB de artefactos de construcción cometidos (Debug/ipch/obj)
• Clasificó: 3 MB de código propio frente a 596 MB de terceros

Mejores Prácticas

• Comience con profundidad standard para auditorías iniciales
• Use fast para monorepos con 100+ módulos para obtener un inventario rápido
• Ejecute deep incrementalmente en módulos marcados para refactorización
• Revise el análisis entre módulos para detección de duplicados en subproyectos

Enlaces

• Repositorio de GitHub