Maison

Skill

Sécurité

repo-scan

affaan-m/ECC

Analyse les référentiels de code source en C++, Android, iOS et Web afin de classer les fichiers, de détecter les bibliothèques tierces intégrées et de générer des évaluations exploitables à quatre niveaux par module, accompagnées de rapports HTML interactifs.

...Développer tout

Heure mise à jour 1 octobre 2026

# ios # monorepo # cpp # android # web # code audit # dependency detection # third party libraries

repo-scan

Chaque écosystème dispose de son propre gestionnaire de dépendances, mais aucun outil ne prend en compte à la fois le C++, Android, iOS et le Web pour vous indiquer : quelle part du code vous appartient réellement, quelle part provient de tiers et quelle part constitue un poids mort.

Quand l'utiliser

Lorsque vous reprenez une base de code héritée volumineuse et que vous avez besoin d'une vue d’ensemble de sa structure
Avant une refactorisation majeure — pour identifier ce qui est essentiel, ce qui est en double et ce qui est obsolète
Auditer les dépendances tierces intégrées directement dans le code source (non déclarées dans les gestionnaires de paquets)
Préparation des documents de décision architecturale pour la réorganisation d’un monorepo

Installation

# Fetch only the pinned commit for reproducibility
mkdir -p ~/.claude/skills/repo-scan
git init repo-scan
cd repo-scan
git remote add origin https://github.com/haibindev/repo-scan.git
git fetch --depth 1 origin 2742664
git checkout --detach FETCH_HEAD
cp -r . ~/.claude/skills/repo-scan

Vérifiez le code source avant d’installer toute compétence d’agent.

Fonctionnalités principales

Fonctionnalité	Description
Analyse multi-plateforme	C/C++, Java/Android, iOS (OC/Swift), Web (TS/JS/Vue) en un seul passage
Classification des fichiers	Chaque fichier est identifié comme code de projet, composant tiers ou artefact de compilation
Détection des bibliothèques	Plus de 50 bibliothèques connues (FFmpeg, Boost, OpenSSL…) avec extraction de la version
Quatre niveaux de verdict	Ressource essentielle / Extraire et fusionner / Reconstruire / Obsolète
Rapports HTML	Pages interactives au thème sombre avec navigation par exploration en profondeur
Prise en charge des monorepos	Analyse hiérarchique avec rapports récapitulatifs et rapports sur les sous-projets

Niveaux de profondeur d’analyse

Niveau	Fichiers lus	Cas d'utilisation
`fast`	1 à 2 par module	Inventaire rapide de répertoires volumineux
`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	Ajout de la sécurité des threads, de la gestion de la mémoire et de la cohérence de l’API
`full`	Tous les fichiers	Révision complète avant la fusion

Fonctionnement

Classification de la surface du dépôt : énumération des fichiers, puis marquage de chacun d’entre eux comme code de projet, code tiers intégré ou artefact de compilation.
Détecter les bibliothèques intégrées : inspecter les noms de répertoires, les en-têtes, les fichiers de licence et les indicateurs de version pour identifier les dépendances incluses et les versions probables.
Évaluer chaque module : regrouper les fichiers par module ou sous-système, puis attribuer l’un des quatre verdicts en fonction de la propriété, des doublons et du coût de maintenance.
Mettre en évidence les risques structurels : signaler les artefacts inutiles, les wrappers dupliqués, le code tiers obsolète et les modules qui devraient être extraits, reconstruits ou dépréciés.
Générer le rapport : fournir un résumé concis ainsi qu’une sortie HTML interactive avec une exploration détaillée par module afin que l’audit puisse être examiné de manière asynchrone.

Exemples

Sur un monorepo C++ de 50 000 fichiers :

Détection de FFmpeg 2.x (version de 2015) toujours en production
Découverte d’un même wrapper SDK dupliqué 3 fois
Identification de 636 Mo d’artefacts de compilation Debug/ipch/obj validés
Classification : 3 Mo de code de projet contre 596 Mo de code tiers

Bonnes pratiques

Commencer par standard une analyse approfondie pour les premiers audits
Utilisez fast pour les monorepos comportant plus de 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 détecter les doublons entre les sous-projets

Liens

Dépôt GitHub

Voir sur GitHub

---
name: repo-scan
description: Scans source code repositories across C++, Android, iOS, and Web to classify files, detect embedded third-party libraries, and produce actionable four-level verdicts per module with interactive HTML reports.
---

# repo-scan

> Every ecosystem has its own dependency manager, but no tool looks across C++, Android, iOS, and Web to tell you: how much code is actually yours, what's third-party, and what's dead weight.

## When to Use

- Taking over a large legacy codebase and need a structural overview
- Before major refactoring — identify what's core, what's duplicate, what's dead
- Auditing third-party dependencies embedded directly in source (not declared in package managers)
- Preparing architecture decision records for monorepo reorganization

## Installation

```bash
# Fetch only the pinned commit for reproducibility
mkdir -p ~/.claude/skills/repo-scan
git init repo-scan
cd repo-scan
git remote add origin https://github.com/haibindev/repo-scan.git
git fetch --depth 1 origin 2742664
git checkout --detach FETCH_HEAD
cp -r . ~/.claude/skills/repo-scan
```

> Review the source before installing any agent skill.

## Core Capabilities

| Capability | Description |
|---|---|
| **Cross-stack scanning** | C/C++, Java/Android, iOS (OC/Swift), Web (TS/JS/Vue) in one pass |
| **File classification** | Every file tagged as project code, third-party, or build artifact |
| **Library detection** | 50+ known libraries (FFmpeg, Boost, OpenSSL…) with version extraction |
| **Four-level verdicts** | Core Asset / Extract & Merge / Rebuild / Deprecate |
| **HTML reports** | Interactive dark-theme pages with drill-down navigation |
| **Monorepo support** | Hierarchical scanning with summary + sub-project reports |

## Analysis Depth Levels

| Level | Files Read | Use Case |
|---|---|---|
| `fast` | 1-2 per module | Quick inventory of huge directories |
| `standard` | 2-5 per module | Default audit with full dependency + architecture checks |
| `deep` | 5-10 per module | Adds thread safety, memory management, API consistency |
| `full` | All files | Pre-merge comprehensive review |

## How It Works

1. **Classify the repo surface**: enumerate files, then tag each as project code, embedded third-party code, or build artifact.
2. **Detect embedded libraries**: inspect directory names, headers, license files, and version markers to identify bundled dependencies and likely versions.
3. **Score each module**: group files by module or subsystem, then assign one of the four verdicts based on ownership, duplication, and maintenance cost.
4. **Highlight structural risks**: call out dead-weight artifacts, duplicated wrappers, outdated vendored code, and modules that should be extracted, rebuilt, or deprecated.
5. **Produce the report**: return a concise summary plus the interactive HTML output with per-module drill-down so the audit can be reviewed asynchronously.

## Examples

On a 50,000-file C++ monorepo:
- Found FFmpeg 2.x (2015 vintage) still in production
- Discovered the same SDK wrapper duplicated 3 times
- Identified 636 MB of committed Debug/ipch/obj build artifacts
- Classified: 3 MB project code vs 596 MB third-party

## Best Practices

- Start with `standard` depth for first-time audits
- Use `fast` for monorepos with 100+ modules to get a quick inventory
- Run `deep` incrementally on modules flagged for refactoring
- Review the cross-module analysis for duplicate detection across sub-projects

## Links

- [GitHub Repository](https://github.com/haibindev/repo-scan)