repo-scan

O que repo-scan faz?

Cada ecossistema tem seu próprio gerenciador de dependências, mas nenhuma ferramenta analisa C++, Android, iOS e Web para te 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 legada e precisar de uma visão estrutural
• Antes de uma grande refatoração — identificar o que é central, o que está duplicado, o que está morto
• Auditando dependências de terceiros embutidas diretamente no código (não declaradas em gerenciadores de pacotes)
• Preparando 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 'Could not release installation lock at %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 'Move conflict recovery failed; staged data remains at %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 'Type install to replace %s after reviewing the pinned source: ' \
  "$REPO_SCAN_INSTALL_DIR" >&2
read -r REPO_SCAN_CONFIRM
if [ "$REPO_SCAN_CONFIRM" != install ]; then
  printf 'Installation cancelled.\n' >&2
  exit 1
fi
if ! mkdir -- "$REPO_SCAN_LOCK" 2>/dev/null; then
  printf 'Another repo-scan installation holds the lock at %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 'Replacement failed and target was recreated; previous installation preserved at %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 'Replacement and rollback failed; previous installation preserved at %s\n' \
        "$REPO_SCAN_BACKUP" >&2
    fi
  fi
  exit 1
fi

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

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

Capacidades Principais

Capacidade	Descrição
Varredura multiplataforma	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
Vereditos em quatro níveis	Ativo Principal / Extrair e Mesclar / Reconstruir / Depreciar
Relatórios HTML	Páginas interativas com tema escuro e navegação detalhada
Suporte a monorepo	Varredura hierárquica com relatórios resumidos e por subprojeto

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 + arquitetura
deep	5-10 por módulo	Adiciona segurança de thread, gerenciamento de memória, consistência de API
full	Todos os arquivos	Revisão abrangente pré-merge

Como Funciona

1. Classifique a superfície do repositório: enumere arquivos, depois marque cada um como código do projeto, código de terceiros embutido ou artefato de build.
2. Detecte bibliotecas embutidas: inspecione nomes de diretórios, cabeçalhos, arquivos de licença e marcadores de versão para identificar dependências empacotadas e versões prováveis.
3. Pontue cada módulo: agrupe arquivos por módulo ou subsistema e atribua um dos quatro vereditos com base em propriedade, duplicação e custo de manutenção.
4. Destaque riscos estruturais: aponte artefatos de peso morto, wrappers duplicados, código vendado desatualizado e módulos que devem ser extraídos, reconstruídos ou depreciados.
5. Produza o relatório: retorne 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 (vintage 2015) ainda em produção
• Descobriu o mesmo wrapper de SDK duplicado 3 vezes
• Identificou 636 MB de artefatos de build Debug/ipch/obj commitados
• Classificou: 3 MB de código do projeto contra 596 MB de terceiros

Melhores Práticas

• Comece com profundidade standard para auditorias iniciais
• Use fast para monorepos com 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