repo-scan

Que fait repo-scan ?

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

Quand l'utiliser

• Lors de la reprise d'une grande base de code legacy et besoin d'un aperçu structurel
• Avant une refactorisation majeure — identifier ce qui est essentiel, ce qui est dupliqué, ce qui est mort
• Auditer les dépendances tierces intégrées directement dans le code source (non déclarées dans les gestionnaires de paquets)
• Préparer des enregistrements de décisions d'architecture pour la réorganisation d'un monorepo

Installation

# Clonez d'abord pour que le commit épinglé puisse être examiné 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 après conflit de déplacement a échoué ; les données préparées restent dans %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"

# Examinez "$REPO_SCAN_TMP/source" avant d'approuver l'installation.
printf 'Tapez install pour remplacer %s après avoir examiné 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 dans %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 le rollback ont échoué ; l'installation précédente est conservée dans %s\n' \
        "$REPO_SCAN_BACKUP" >&2
    fi
  fi
  exit 1
fi

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

L'installation ne fait que l'amorçage. Rechargez le harness de votre agent, puis invoquez à nouveau repo-scan. Ce pointeur ECC installe la compétence externe mais n'exécute pas d'analyse elle-même.

Capacités principales

Capacité	Description
Analyse multi-pile	C/C++, Java/Android, iOS (OC/Swift), Web (TS/JS/Vue) en un seul passage
Classification des fichiers	Chaque fichier étiqueté comme code projet, code tiers ou artefact de build
Détection de 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 descendante
Support Monorepo	Analyse hiérarchique avec résumé + rapports de sous-projets

Niveaux de profondeur d'analyse

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

Comment ça fonctionne

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

Exemples

Sur un monorepo C++ de 50 000 fichiers :

• Trouvé FFmpeg 2.x (millésime 2015) toujours en production
• Découvert le même wrapper SDK dupliqué 3 fois
• Identifié 636 Mo d'artefacts de build (Debug/ipch/obj) commités
• Classifié : 3 Mo de code projet contre 596 Mo de code tiers

Bonnes pratiques

• Commencez avec 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 refactorisation
• Examinez l'analyse inter-modules pour la détection de doublons entre sous-projets

Liens

• Dépôt GitHub