/analyze-dependencies

Dependency Analysis

Analyse les dépendances de votre projet et vérifie la santé architecturale.

Utilisation

/dependency-analysis [options]

Options

• --visual : Afficher visuellement les dépendances
• --circular : Détecter uniquement les dépendances circulaires
• --depth <number> : Spécifier la profondeur d'analyse (défaut : 3)
• --focus <path> : Se concentrer sur un module/répertoire spécifique

Exemples de base

# Analyser les dépendances pour tout le projet
/dependency-analysis

# Détecter les dépendances circulaires
/dependency-analysis --circular

# Analyse détaillée d'un module spécifique
/dependency-analysis --focus src/core --depth 5

Ce qui est analysé

1. Matrice de dépendances

Montre comment les modules se connectent les uns aux autres :

• Dépendances directes
• Dépendances indirectes
• Profondeur des dépendances
• Fan-in/fan-out

2. Violations architecturales

• Violations de couches (quand les couches inférieures dépendent des supérieures)
• Dépendances circulaires
• Couplage excessif (trop de connexions)
• Modules orphelins

3. Vérification de Clean Architecture

• La couche domaine est-elle indépendante ?
• L'infrastructure est-elle correctement séparée ?
• Les dépendances de cas d'usage s'écoulent-elles correctement ?
• Les interfaces sont-elles utilisées correctement ?

Exemple de sortie

Rapport d'analyse de dépendances
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📊 Vue d'ensemble des métriques
├─ Modules totaux : 42
├─ Dépendances moyennes : 3,2
├─ Profondeur maximale de dépendances : 5
└─ Dépendances circulaires : 2 détectées

⚠️  Violations architecturales
├─ [HAUTE] src/domain/user.js → src/infra/database.js
│  └─ La couche domaine dépend directement de la couche infrastructure
├─ [MOY] src/api/auth.js ⟲ src/services/user.js
│  └─ Dépendance circulaire détectée
└─ [BASSE] src/utils/helper.js → 12 modules
   └─ Fan-out excessif

✅ Actions recommandées
1. Introduire l'interface UserRepository
2. Repenser les responsabilités du service d'authentification
3. Diviser les fonctions d'aide par fonctionnalité

📈 Graphique de dépendances
[Diagramme de dépendances visuelles affiché en art ASCII]

Exemples d'utilisation avancée

# Vérifications automatiques CI/CD
/dependency-analysis --circular --fail-on-violation

# Vérifier contre les règles d'architecture
/dependency-analysis --rules .architecture-rules.yml

# Voir comment les dépendances ont changé
/dependency-analysis --compare HEAD~10

Exemple de fichier de configuration (.dependency-analysis.yml)

rules:
  - name: "Indépendance du domaine"
    source: "src/domain/**"
    forbidden: ["src/infra/**", "src/api/**"]

  - name: "Dépendances couche API"
    source: "src/api/**"
    allowed: ["src/domain/**", "src/application/**"]
    forbidden: ["src/infra/**"]

thresholds:
  max_dependencies: 8
  max_depth: 4
  coupling_threshold: 0.7

ignore:
  - "**/test/**"
  - "**/mocks/**"

Outils que nous utilisons

• madge : Montre visuellement les dépendances JavaScript/TypeScript
• dep-cruiser : Vérifie les règles de dépendances
• nx : Gère les dépendances de monorepo
• plato : Analyse la complexité et les dépendances ensemble

Collaboration avec Claude

# Vérifier les dépendances avec package.json
cat package.json
/analyze-dependencies
"Find dependency issues in this project"

# Plongée profonde dans un module spécifique
ls -la src/core/
/analyze-dependencies --focus src/core
"Check the core module's dependencies in detail"

# Comparer conception vs réalité
cat docs/architecture.md
/analyze-dependencies --visual
"Does our implementation match the architecture docs?"

Notes

• Exécuter depuis : Répertoire racine du projet
• Soyez patient : Les gros projets prennent du temps à analyser
• Agissez rapidement : Corrigez les dépendances circulaires dès que vous les trouvez

Bonnes pratiques

1. Vérifier hebdomadairement : Gardez un œil sur la santé des dépendances
2. Écrire les règles : Mettre les règles d'architecture dans les fichiers de configuration
3. Petites étapes : Corriger les choses progressivement, pas tout d'un coup
4. Suivre les tendances : Observer comment la complexité évolue dans le temps