repo-scan

O que repo-scan faz?

Cada ecossistema tem seu próprio gerenciador de dependências, mas nenhuma ferramenta olha através de C++, Android, iOS e Web para lhe dizer: quanto código é realmente seu, o que é de terceiros e o que é peso morto.

Quando Usar

• Ao assumir uma grande base de código legado e precisar de uma visão estrutural
• Antes de uma grande refatoração — identificar o que é central, o que é duplicado, o que está morto
• Ao auditar dependências de terceiros embutidas diretamente no código-fonte (não declaradas em gerenciadores de pacotes)
• Ao preparar registros de decisão de arquitetura para reorganização de monorepo

Instalação

# Clone primeiro para que o commit fixo possa ser revisado antes da instalação
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 'Não foi possível liberar o bloqueio de instalação em %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 'Falha na recuperação de conflito de movimentação; dados temporários permanecem em %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 aprovar a instalação.
printf 'Digite install para substituir %s após revisar o código-fonte fixo: ' \
  "$REPO_SCAN_INSTALL_DIR" >&2
read -r REPO_SCAN_CONFIRM
if [ "$REPO_SCAN_CONFIRM" != install ]; then
  printf 'Instalação cancelada.\n' >&2
  exit 1
fi
if ! mkdir -- "$REPO_SCAN_LOCK" 2>/dev/null; then
  printf 'Outra instalação do repo-scan detém o bloqueio em %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 'Falha na substituição e o destino foi recriado; instalação anterior preservada em %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 'Falha na substituição e na reversão; instalação anterior preservada em %s\n' \
        "$REPO_SCAN_BACKUP" >&2
    fi
  fi
  exit 1
fi

Revise o código-fonte antes de instalar qualquer habilidade de agente.

A instalação conclui apenas o bootstrap. Recarregue seu ambiente de agente e então invoque repo-scan novamente. Este ponteiro ECC instala a habilidade externa, mas não executa uma varredura em si.

Capacidades Principais

Capacidade	Descrição
Varredura entre stacks	C/C++, Java/Android, iOS (OC/Swift), Web (TS/JS/Vue) em uma única passada
Classificação de arquivos	Cada arquivo marcado como código do projeto, de terceiros ou artefato de build
Detecção de bibliotecas	Mais de 50 bibliotecas conhecidas (FFmpeg, Boost, OpenSSL…) com extração de versão
Pareceres em quatro níveis	Ativo Central / Extrair e Mesclar / Reconstruir / Descontinuar
Relatórios HTML	Páginas interativas com tema escuro e navegação por detalhamento
Suporte a monorepo	Varredura hierárquica com relatórios de resumo + subprojetos

Níveis de Profundidade de Análise

Nível	Arquivos Lidos	Caso de Uso
fast	1-2 por módulo	Inventário rápido de diretórios enormes
standard	2-5 por módulo	Auditoria padrão com verificações completas de dependências e arquitetura
deep	5-10 por módulo	Adiciona segurança de threads, gerenciamento de memória, consistência de API
full	Todos os arquivos	Revisão abrangente antes de mesclagem

Como Funciona

1. Classificar a superfície do repositório: enumerar arquivos e marcar cada um como código do projeto, código de terceiros embutido ou artefato de build.
2. Detectar bibliotecas embutidas: inspecionar nomes de diretórios, cabeçalhos, arquivos de licença e marcadores de versão para identificar dependências agrupadas e versões prováveis.
3. Pontuar cada módulo: agrupar arquivos por módulo ou subsistema e atribuir um dos quatro pareceres com base em propriedade, duplicação e custo de manutenção.
4. Destacar riscos estruturais: apontar artefatos de peso morto, wrappers duplicados, código herdado desatualizado e módulos que devem ser extraídos, reconstruídos ou descontinuados.
5. Produzir o relatório: retornar um resumo conciso mais a saída HTML interativa com detalhamento por módulo para que a auditoria possa ser revisada de forma assíncrona.

Exemplos

Em um monorepo C++ com 50.000 arquivos:

• Encontrou FFmpeg 2.x (2015) ainda em produção
• Descobriu o mesmo wrapper de SDK duplicado 3 vezes
• Identificou 636 MB de artefatos de build comprometidos (Debug/ipch/obj)
• Classificou: 3 MB de código do projeto vs 596 MB de terceiros

Melhores Práticas

• Comece com profundidade standard para auditorias iniciais
• Use fast para monorepos com mais de 100 módulos para obter um inventário rápido
• Execute deep incrementalmente em módulos sinalizados para refatoração
• Revise a análise entre módulos para detecção de duplicatas entre subprojetos

Links

• Repositório GitHub