repo-scan

Que fait repo-scan ?

Chaque écosystème a son propre gestionnaire de dépendances, mais aucun outil ne parcourt C++, Android, iOS et le Web pour vous dire : combien de code vous appartient réellement, ce qui provient de tiers, et ce qui est du poids mort.

Quand l'utiliser

• Reprendre une large base de code existante et avoir besoin d'un aperçu structurel
• Avant une refonte majeure — identifier ce qui est central, ce qui est dupliqué, ce qui est mort
• Auditer les dépendances tierces embarquées directement dans le code source (non déclarées dans les gestionnaires de paquets)
• Préparer des enregistrements de décision d'architecture pour la réorganisation d'un monorepo

Installation

# Cloner d'abord pour que le commit épinglé puisse être révisé avant l'installation
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 'Impossible de libérer le verrou d'installation à %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 récupération d'échec de déplacement a échoué ; les données intermédiaires restent à %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"

# Révisez "$REPO_SCAN_TMP/source" avant d'approuver l'installation.
printf 'Tapez install pour remplacer %s après avoir révisé la source épinglée : ' \
  "$REPO_SCAN_INSTALL_DIR" >&2
read -r REPO_SCAN_CONFIRM
if [ "$REPO_SCAN_CONFIRM" != install ]; then
  printf 'Installation annulée.\n' >&2
  exit 1
fi
if ! mkdir -- "$REPO_SCAN_LOCK" 2>/dev/null; then
  printf 'Une autre installation de repo-scan détient le verrou à %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 'Le remplacement a échoué et la cible a été recréée ; l'installation précédente est conservée à %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 'Le remplacement et la restauration ont échoué ; l'installation précédente est conservée à %s\n' \
        "$REPO_SCAN_BACKUP" >&2
    fi
  fi
  exit 1
fi

Révisez la source avant d'installer toute compétence d'agent.

L'installation n'effectue que l'amorçage. Rechargez votre environnement d'agent, puis invoquez à nouveau repo-scan. Ce pointeur ECC installe la compétence externe mais ne lance pas d'analyse lui-même.

Capacités principales

Capacité	Description
Analyse multi-stack	C/C++, Java/Android, iOS (OC/Swift), Web (TS/JS/Vue) en un seul passage
Classification des fichiers	Chaque fichier étiqueté comme code projet, tiers ou artefact de build
Détection des bibliothèques	50+ bibliothèques connues (FFmpeg, Boost, OpenSSL…) avec extraction de version
Verdicts à quatre niveaux	Actif Cœur / Extraire & Fusionner / Reconstruire / Déprécier
Rapports HTML	Pages interactives en thème sombre avec navigation hiérarchique
Support monorepo	Analyse hiérarchique avec rapports de résumé + sous-projets

Niveaux de profondeur d'analyse

Niveau	Fichiers lus	Cas d'usage
fast	1-2 par module	Inventaire rapide de grands répertoires
standard	2-5 par module	Audit par défaut avec vérifications complètes des dépendances et de l'architecture
deep	5-10 par module	Ajoute la sécurité des threads, la gestion de la mémoire, la cohérence des API
full	Tous les fichiers	Revue exhaustive avant fusion

Comment ça fonctionne

1. Classer la surface du dépôt : énumérer les fichiers, puis étiqueter chacun comme code projet, code tiers embarqué, ou artefact de build.
2. Détecter les bibliothèques embarquées : inspecter les noms de répertoires, en-têtes, fichiers de licence et marqueurs de version pour identifier les dépendances fournies et leurs versions probables.
3. Noter chaque module : regrouper les fichiers par module ou sous-système, puis attribuer un des quatre verdicts basé sur la propriété, la duplication et le coût de maintenance.
4. Mettre en évidence les risques structurels : signaler les artefacts de poids mort, les wrappers dupliqués, le code tiers obsolète, et les modules à extraire, reconstruire ou déprécier.
5. Produire le rapport : retourner un résumé concis ainsi que la sortie HTML interactive avec navigation par module pour que l'audit puisse être examiné de manière asynchrone.

Exemples

Sur un monorepo C++ de 50 000 fichiers :

• A trouvé FFmpeg 2.x (datant de 2015) encore en production
• A découvert le même wrapper SDK dupliqué 3 fois
• A identifié 636 Mo d'artefacts de build engagés (Debug/ipch/obj)
• Classifié : 3 Mo de code projet contre 596 Mo de code tiers

Bonnes pratiques

• Commencez par la profondeur standard pour les premiers audits
• Utilisez fast pour les monorepos avec 100+ modules afin d'obtenir un inventaire rapide
• Exécutez deep de manière incrémentielle sur les modules signalés pour refonte
• Révisez l'analyse inter-modules pour la détection de doublons entre sous-projets

Liens

• Dépôt GitHub