repo-scan

Was macht repo-scan?

Jedes Ökosystem hat seinen eigenen Paketmanager, aber kein Tool schaut sich C++, Android, iOS und Web an, um Ihnen zu sagen: Wie viel Code gehört tatsächlich Ihnen, was ist Drittanbieter-Code und was ist Ballast?

Wann verwenden

• Übernahme einer großen Legacy-Codebasis und Bedarf einer strukturellen Übersicht
• Vor größeren Refactorings – identifizieren, was Kernbestandteil ist, was doppelt vorhanden ist, was tot ist
• Prüfung von Drittanbieter-Abhängigkeiten, die direkt im Quellcode eingebettet sind (nicht in Paketmanagern deklariert)
• Vorbereitung von Architekturentscheidungen für die Reorganisation eines 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 nicht freigeben: %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 'Wiederherstellung nach Verschiebungskonflikt fehlgeschlagen; bereitgestellte Daten verbleiben unter %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" vor der Freigabe der Installation.
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 unter %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 'Ersatz 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 'Ersatz 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 Agent-Skill installieren.

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

Kernfunktionen

Funktion	Beschreibung
Plattformübergreifender Scan	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 gekennzeichnet
Bibliothekserkennung	50+ bekannte Bibliotheken (FFmpeg, Boost, OpenSSL…) mit Versionserkennung
Vierstufige Bewertungen	Kernbestandteil / Extrahieren und Zusammenführen / Neuerstellen / Einstellen
HTML-Berichte	Interaktive Dark-Theme-Seiten mit Drill-Down-Navigation
Monorepo-Unterstützung	Hierarchischer Scan mit Zusammenfassung + Unterprojektberichten

Analysetiefe-Stufen

Stufe	Gelesene Dateien	Anwendungsfall
fast	1-2 pro Modul	Schnelles Inventar großer 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 Merge

Funktionsweise

1. Klassifizieren der Repo-Oberfläche: Dateien auflisten, dann jede als Projektcode, eingebetteten Drittanbieter-Code oder Build-Artefakt kennzeichnen.
2. Erkennen eingebetteter Bibliotheken: Verzeichnisnamen, Header, Lizenzdateien und Versionsmarkierungen überprüfen, um gebündelte Abhängigkeiten und wahrscheinliche Versionen zu identifizieren.
3. Bewerten jedes Moduls: Dateien nach Modul oder Subsystem gruppieren, dann eine der vier Bewertungen basierend auf Eigentumsverhältnissen, Duplizierung und Wartungskosten zuweisen.
4. Hervorheben struktureller Risiken: Auf Ballast-Artefakte, duplizierte Wrapper, veralteten Vendor-Code und Module hinweisen, die extrahiert, neu erstellt oder eingestellt werden sollten.
5. Erstellen des Berichts: Eine kurze Zusammenfassung sowie 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 (Vintage 2015) noch in der Produktion gefunden
• Denselben SDK-Wrapper dreimal dupliziert entdeckt
• 636 MB an eingecheckten Debug/ipch/obj-Build-Artefakten identifiziert
• Klassifiziert: 3 MB Projektcode gegenüber 596 MB Drittanbieter-Code

Best Practices

• Beginnen Sie mit standard-Tiefe für erste Audits
• Verwenden Sie fast für Monorepos mit 100+ Modulen, um ein schnelles Inventar zu erhalten
• Führen Sie deep inkrementell auf Modulen aus, die für ein Refactoring markiert wurden
• Überprüfen Sie die modulübergreifende Analyse auf Duplikatserkennung in Unterprojekten

Links

• GitHub Repository