repo-scan

Was macht repo-scan?

Jedes Ökosystem hat seinen eigenen Dependency-Manager, aber kein Tool blickt über C++, Android, iOS und Web hinweg und sagt dir: Wie viel Code gehört tatsächlich dir, was ist Drittanbieter-Code und was ist Ballast.

Wann verwenden

• Übernahme einer großen Legacy-Codebasis und Notwendigkeit eines strukturellen Überblicks
• Vor einer großen Refaktorisierung – identifizieren, was Kern ist, was doppelt ist, was tot ist
• Prüfung von Drittanbieter-Abhängigkeiten, die direkt im Quellcode eingebettet sind (nicht in Paketmanagern deklariert)
• Vorbereitung von Architekturentscheidungsdokumentationen für die Neuorganisation von Monorepos

Installation

# Zuerst klonen, damit der gepinnte Commit vor der Installation überprüft werden kann
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 'Konnte Installationssperre bei %s nicht freigeben\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 'Wiederherstellung nach Verschiebungskonflikt fehlgeschlagen; bereitgestellte Daten verbleiben bei %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"

# Überprüfen Sie "$REPO_SCAN_TMP/source", bevor Sie die Installation genehmigen.
printf 'Geben Sie install ein, um %s nach Überprüfung des gepinnten Quellcodes zu ersetzen: ' \
  "$REPO_SCAN_INSTALL_DIR" >&2
read -r REPO_SCAN_CONFIRM
if [ "$REPO_SCAN_CONFIRM" != install ]; then
  printf 'Installation abgebrochen.\n' >&2
  exit 1
fi
if ! mkdir -- "$REPO_SCAN_LOCK" 2>/dev/null; then
  printf 'Eine andere repo-scan-Installation hält die Sperre bei %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 'Ersetzung fehlgeschlagen und Ziel wurde neu erstellt; vorherige Installation unter %s erhalten\n' \
        "$REPO_SCAN_BACKUP" >&2
    elif ! move_repo_scan_dir "$REPO_SCAN_BACKUP" "$REPO_SCAN_INSTALL_DIR"; then
      REPO_SCAN_KEEP_TMP=1
      printf 'Ersetzung und Rollback fehlgeschlagen; vorherige Installation unter %s erhalten\n' \
        "$REPO_SCAN_BACKUP" >&2
    fi
  fi
  exit 1
fi

Überprüfen Sie den Quellcode, bevor Sie ein Agenten-Skill installieren.

Die Installation schließt nur den Bootstrap ab. Laden Sie Ihre Agenten-Umgebung neu und rufen Sie repo-scan erneut auf. Dieser ECC-Pointer installiert das externe Skill, führt aber selbst keinen Scan durch.

Kernfunktionen

Funktion	Beschreibung
Stackübergreifende Analyse	C/C++, Java/Android, iOS (OC/Swift), Web (TS/JS/Vue) in einem Durchlauf
Dateiklassifizierung	Jede Datei wird als Projektcode, Drittanbieter-Code oder Build-Artefakt getaggt
Bibliothekserkennung	50+ bekannte Bibliotheken (FFmpeg, Boost, OpenSSL…) mit Versionsextraktion
Vierstufige Bewertungen	Kern-Asset / Extrahieren & Zusammenführen / Neuerstellen / Einstellen
HTML-Berichte	Interaktive Dunkelthema-Seiten mit Drill-Down-Navigation
Monorepo-Unterstützung	Hierarchisches Scannen mit Zusammenfassung + Unterprojektberichten

Analyse-Tiefenstufen

Stufe	Gelesene Dateien	Anwendungsfall
fast	1-2 pro Modul	Schnelle Inventur riesiger Verzeichnisse
standard	2-5 pro Modul	Standard-Audit mit vollständigen Abhängigkeits- und Architekturprüfungen
deep	5-10 pro Modul	Fügt Thread-Sicherheit, Speicherverwaltung, API-Konsistenz hinzu
full	Alle Dateien	Umfassende Überprüfung vor dem Zusammenführen

Funktionsweise

1. Oberfläche des Repos klassifizieren: Dateien aufzählen, dann jede als eigenen Code, eingebetteten Drittanbieter-Code oder Build-Artefakt taggen.
2. Eingebettete Bibliotheken erkennen: Verzeichnisnamen, Header, Lizenzdateien und Versionsmarkierungen untersuchen, um gebündelte Abhängigkeiten und wahrscheinliche Versionen zu identifizieren.
3. Jedes Modul bewerten: Dateien nach Modul oder Subsystem gruppieren, dann basierend auf Eigentümerschaft, Duplizierung und Wartungskosten eine der vier Bewertungen zuweisen.
4. Strukturelle Risiken hervorheben: Ballast-Artefakte, duplizierte Wrapper, veralteten vendored Code und Module, die extrahiert, neu erstellt oder eingestellt werden sollten, benennen.
5. Den Bericht erstellen: Eine prägnante Zusammenfassung plus die interaktive HTML-Ausgabe mit Drill-Down pro Modul zurückgeben, damit das Audit asynchron überprüft werden kann.

Beispiele

In einem C++-Monorepo mit 50.000 Dateien:

• FFmpeg 2.x (Jahrgang 2015) noch in Produktion gefunden
• Denselben SDK-Wrapper dreifach dupliziert entdeckt
• 636 MB an committeden Debug/ipch/obj-Build-Artefakten identifiziert
• Klassifiziert: 3 MB Projektcode vs. 596 MB Drittanbieter-Code

Best Practices

• Beginnen Sie bei Erst-Audits mit der Tiefe standard
• Verwenden Sie fast für Monorepos mit 100+ Modulen, um eine schnelle Inventur zu erhalten
• Führen Sie deep inkrementell auf Modulen aus, die für die Refaktorisierung markiert wurden
• Überprüfen Sie die modulübergreifende Analyse auf Duplikaterkennung in Unterprojekten

Links

• GitHub-Repository