Communitygithub.com

majiayu000/claude-skill-registry

Outil pour analyser et visualiser les flux de code, générant des diagrammes ASCII clairs, des diagrammes de flux de données et des analyses tabulaires. Idéal pour le débogage de code existant, la conception de nouvelles fonctionnalités et la rédaction de documentation technique.

Qu'est-ce que claude-skill-registry ?

Ce skill est conçu pour aider les développeurs à visualiser les flux de code et les architectures logicielles de manière claire et concise, en utilisant des diagrammes ASCII, des tableaux et des annotations textuelles. Il s'applique à tout environnement de développement où la compréhension des chemins de code, des flux de données et des dépendances entre couches est cruciale. Le skill est agnostique du langage et peut être utilisé avec Claude Code, Cursor, Codex ou d'autres assistants IA. Il fonctionne en suivant une méthodologie structurée : analyse du besoin (comprendre le scénario), sélection d'un modèle adapté (schéma de flux complet, graphe d'appels simplifié, structure de base de données ou tableau d'analyse de classes de données), puis remplissage du modèle avec des diagrammes ASCII, des annotations et des extraits de code. L'utilisateur est guidé par une checklist pour garantir la complétude et éviter les pièges courants comme les descriptions textuelles pures. Le résultat final est un document visuel clair, prêt à être inclus dans la documentation technique ou partagé avec l'équipe.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/majiayu000/claude-skill-registry/tree/HEAD/skills/analysis/code-flow-viz-mmorit00-fund-portfolio-bot-2

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Norme de visualisation des flux de code

Ce Skill fournit un ensemble de modèles et de méthodes réutilisables pour analyser les flux de code et générer une documentation visuelle.

Principe fondamental : Expliquer clairement avec du texte et des diagrammes ASCII "d'où viennent les données, par quelles couches elles passent et où elles aboutissent".

Quand l'utiliser

Utilisez ce Skill dans les situations suivantes :

  • L'utilisateur demande "comment fonctionne telle fonctionnalité ?"
  • Une nouvelle fonctionnalité nécessite la conception de flux de données
  • Avant une refactorisation, pour analyser la logique existante
  • Rédaction de documentation technique ou d'architecture
  • Besoin de visualiser la chaîne d'appels lors d'une revue de code

Modèles principaux

1. Schéma de flux complet (comparaison multi-scénarios)

Idéal pour : analyser plusieurs scénarios d'utilisation d'une fonctionnalité (par exemple manuel vs automatique, succès vs échec)

┌─────────────────────────────────────────────────────────────────────┐
│                    Nom de la fonctionnalité (ex : cycle de vie      │
│                    de la gestion des limites)                       │
└─────────────────────────────────────────────────────────────────────┘

═══════════════════════════════════════════════════════════════════════
Scénario 1 : Nom du scénario (ex : requête automatique de l'état des limites)
═══════════════════════════════════════════════════════════════════════

  Commande utilisateur
     │
     ▼
┌─────────────────────────────────────────────────────────────────┐
│  uv run python -m src.cli.xxx ...                               │
└────────────────┬────────────────────────────────────────────────┘
                 │
                 ▼
        ┌────────────────┐
        │  Couche CLI     │   Appelle la fonction Flow
        │  _do_xxx()      │ ────────────────────┐
        └────────────────┘                      │
                                                ▼
                                   ┌──────────────────────────┐
                                   │  Couche Flow             │
                                   │  xxx_flow()              │
                                   └───────┬──────────────────┘
                                           │
                                           ▼
                              ┌─────────────────────────────┐
                              │  Couche Data                │
                              │  XxxRepo / XxxClient        │
                              └────────┬─────────────────────┘
                                       │
                                       ▼
                          ┌────────────────────────────┐
                          │  Système externe / Base    │
                          │  (SQLite / API / etc)      │
                          └──────────┬─────────────────┘
                                     │  Retour de données
                                     ▼
                    ┌──────────────────────────────────┐
                    │  Traitement des données          │
                    │  (analyse/transformation)        │
                    └─────────────┬────────────────────┘
                                  │
                                  ▼
                        ┌──────────────────────┐
                        │  Classe de données   │  ← Expliquer pourquoi
                        │  de retour           │    (résultat/élément/...)
                        │  (Result / Item / ..)│
                        └──────────┬───────────┘
                                   │
                                   ▼
                        ┌──────────────────────┐
                        │  Sortie formatée     │
                        │  par la couche CLI   │
                        └──────────────────────┘
                                   │
                                   ▼
    ╔══════════════════════════════════════════════════╗
    ║  Exemple de sortie terminal                      ║
    ║  (Encadré pour mettre en évidence le résultat    ║
    ║   visible par l'utilisateur final)               ║
    ╚══════════════════════════════════════════════════╝

═══════════════════════════════════════════════════════════════════════
Scénario 2 : Un autre scénario
═══════════════════════════════════════════════════════════════════════
(Répéter la structure ci-dessus, en mettant en évidence les différences)

2. Description de la structure des tables de base de données

Idéal pour : expliquer les tables de base de données liées à une fonctionnalité

CREATE TABLE nom_table (
    id INTEGER PRIMARY KEY AUTOINCREMENT,  -- ← Expliquer le rôle de la clé primaire
    champ1 TEXT NOT NULL,                   -- Expliquer la signification du champ
    champ2 TEXT,                            -- Signification métier de NULL
    ...
);

-- Index (expliquer pourquoi cet index est nécessaire)
CREATE INDEX idx_xxx ON nom_table(champ1, champ2);

Exemple de données :

idchamp1champ2champ3Description
42valeur1valeur2valeur3Signification métier de cet enregistrement
43............

Requêtes typiques :

-- Explication du scénario : quand a-t-on besoin de cette requête ?
SELECT * FROM nom_table 
WHERE condition1 = ? 
  AND (condition2 IS NULL OR condition2 >= ?);

3. Graphe d'appels par couches (version simplifiée)

Idéal pour : expliquer rapidement les relations d'appels entre fonctions

Couche CLI (_do_xxx)
    │
    └─> Couche Flow (xxx_flow)
            │
            ├─> Data/Repo (xxx_repo.get)
            │       │
            │       └─> SQLite (SELECT ...)
            │
            └─> Data/Client (xxx_client.fetch)
                    │
                    └─> API externe (HTTP GET ...)

4. Tableau d'analyse de conception des classes de données

Idéal pour : évaluer la nécessité des classes de données intermédiaires

Nom de classeNb champsUtilisationDécisionJustification
XxxResult6Agrégation multi-champs + affichage CLI✅ ConserverSatisfait le "principe de nécessité minimale"
XxxWrapper1Emballage d'un seul champ❌ SupprimerEmballage excessif, retourner directement le type primitif
XxxItem3Élément de liste détaillée✅ ConserverA une signification métier

Exemple de comparaison :

# ❌ Emballage excessif
@dataclass
class XxxResult:
    champ: SomeType  # Un seul champ

def xxx_flow() -> XxxResult:
    return XxxResult(champ=valeur)

# ✅ Après simplification
def xxx_flow() -> SomeType:  # Retour direct
    return valeur

5. Annotation des points clés métier

Idéal pour : mettre en évidence les règles métier et les décisions de conception

┌─────────────────────────────────────────────────────────────┐
│                    Points clés métier                       │
├──────────────────────┬──────────────────────────────────────┤
│   Pourquoi cette     │        Décision concrète            │
│   conception ?       │                                      │
├──────────────────────┼──────────────────────────────────────┤
│ • Précision données  │ Montant en Decimal, 2 décimales      │
│ • Idempotence        │ Contrainte d'unicité sur            │
│                      │ (fund_code, date)                    │
│ • Traçabilité        │ record_id comme identifiant global   │
└──────────────────────┴──────────────────────────────────────┘

Comment l'utiliser

Étape 1 : Définir l'objectif d'analyse

Répondez aux questions suivantes :

  1. De quelle fonctionnalité l'utilisateur souhaite-t-il comprendre le flux ?
  2. Combien de scénarios existe-t-il pour cette fonctionnalité ? (succès/échec, manuel/automatique, etc.)
  3. Quelles sont les couches impliquées ? (CLI → Flow → Data → DB/API)
  4. Quelles sont les classes de données clés et pourquoi sont-elles conçues ainsi ?

Étape 2 : Choisir le modèle approprié

  • Comparaison multi-scénarios → Modèle 1 (schéma de flux complet)
  • Processus unique → Modèle 3 (graphe d'appels par couches)
  • Conception de base de données → Modèle 2 (structure de table + exemples de données)
  • Évaluation des classes de données → Modèle 4 (tableau d'analyse)

Étape 3 : Remplir le contenu

Principes :

  • Utiliser des diagrammes ASCII plutôt que de longs textes
  • Utiliser des flèches (│ ▼ ┐ ┘ └ ├ ─) pour enchaîner les flux de données
  • Utiliser des bordures (┌ ┐ └ ┘ │ ─) pour séparer les couches
  • Utiliser des bordures doubles (╔ ╗ ╚ ╝ ║ ═) pour mettre en évidence les parties visibles par l'utilisateur
  • Ajouter des commentaires (← explication) aux nœuds clés

Norme d'utilisation des symboles :

SymboleUtilisationExemple
│ ▼Flux verticalDonnées du haut vers le bas
→ ←Explication horizontalerecord_id: int ← clé primaire DB
┌ ┐ └ ┘Bordure simpleEncadrer des blocs de code, commandes
╔ ╗ ╚ ╝Bordure doubleMettre en évidence la sortie terminal, résultats importants
═══Ligne de séparationSéparer différents scénarios

Étape 4 : Ajouter une analyse comparative

Avant vs Après (scénario de refactorisation) :

# Avant (version problématique)
...code...

# Problèmes :
# - Emballage excessif
# - Champs redondants
# - Augmentation de la charge cognitive

# Après (version améliorée)
...code...

# Améliorations :
# - Retour direct d'un type significatif
# - Réduction des couches intermédiaires
# - Diminution de la charge de maintenance

Exemples concrets

Exemple 1 : Processus de gestion des limites (version complète)

(Voir l'exemple du modèle 1 ci-dessus, en développant le processus complet pour 4 scénarios)

Exemple 2 : Évaluation des classes de données (module fund_restriction)

FonctionRetour avantRetour maintenantDécisionRaison
add_restrictionAddRestrictionResult (6 champs)Conserver✅La CLI doit afficher tous les champs
end_restrictionEndRestrictionResult (4 champs)bool❌Seul le succès/échec est nécessaire
check_trading_statusCheckStatusResult (2 champs)ParsedRestriction | None❌Simple emballage inutile

Liste de contrôle (Checklist)

Lors de la génération d'un document de visualisation de flux, assurez-vous d'inclure :

  • Aperçu général (objectif de la fonctionnalité, modules impliqués)
  • Énumération des scénarios (succès/échec, manuel/automatique, etc.)
  • Schéma de flux par couches (CLI → Flow → Data → Externe)
  • Structure des tables de base de données (si impliquée)
  • Exemples de données et requêtes (pour faciliter la compréhension)
  • Explication des classes de données clés (pourquoi conserver/simplifier)
  • Raisons de conception (pourquoi cette approche ?)
  • Points d'extension futurs (TODO ou interfaces réservées)

Anti-patrons (à ne pas faire)

❌ Description textuelle pure du processus

Il faut d'abord appeler la fonction _do_xxx de la couche CLI, ensuite _do_xxx appelle la fonction xxx_flow de la couche Flow,
puis xxx_flow appelle la méthode xxx_repo.get de la couche Data...

✅ Utiliser un diagramme ASCII

CLI (_do_xxx) → Flow (xxx_flow) → Data (xxx_repo.get) → SQLite

❌ Tableau sans accent mis sur l'essentiel

ChampType
idint
namestr

✅ Mettre en évidence la signification métier

ChampTypeDescriptionContrainte métier
idintClé primaireGénéré automatiquement, unique globalement
namestrNom du fondsNon vide, utilisé pour l'affichage

❌ Requête SQL sans explication du scénario

SELECT * FROM table WHERE id = ?;

✅ Avec scénario métier

-- Scénario : l'utilisateur consulte les détails d'une restriction
SELECT * FROM fund_restrictions WHERE id = ?;

-- Scénario : lors de l'analyse DCA, vérifier si un jour est soumis à une limite
SELECT * FROM fund_restrictions
WHERE fund_code = ? AND start_date <= ? AND (end_date IS NULL OR end_date >= ?);

Collaboration avec d'autres Skills

  • code-style : Suivre les normes de codification lors de l'affichage d'exemples de code
  • architecture : Les diagrammes de flux doivent respecter les contraintes d'architecture par couches
  • dev-workflow : Lire le code et la documentation pertinents avant d'analyser le flux

Résumé

Les valeurs clés de ce Skill sont :

  1. Modèles réutilisables : Réduire le temps de démarrage à zéro
  2. Style visuel unifié : Diagrammes ASCII + tableaux + bordures
  3. Perspective métier : Au-delà du flux de code, se concentrer sur le "pourquoi"
  4. Analyse comparative : Avant/après refactorisation, comparaison multi-scénarios
  5. Checklist : Garantir qu'aucune information clé n'est omise

Fréquence d'utilisation : Peut être utilisé chaque fois qu'il est nécessaire d'expliquer "comment fonctionne une fonctionnalité".

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

majiayu000/claude-skill-registry

Builds, edit or validate Agent Skill through conversational discovery. Use when the user requests to "Create an Agent", "Optimize an Agent" or "Edit an Agent".

majiayu000/claude-skill-registry

Edit existing BMAD agents while maintaining compliance

majiayu000/claude-skill-registry

Edit existing BMAD agents while maintaining compliance

majiayu000/claude-skill-registry

Edit existing BMAD modules while maintaining coherence

majiayu000/claude-skill-registry

Edit existing BMAD modules while maintaining coherence

majiayu000/claude-skill-registry

Analyzes current state and user query to answer BMad questions or recommend the next workflow or agent. Use when user says what should I do next, what do I do now, or asks a question about BMad

majiayu000/claude-skill-registry

Build AI agents with Google ADK Python (Agent Development Kit). Use for multi-agent systems, workflow agents (sequential/parallel/loop), Vertex AI deployment, tool integration, human-in-the-loop.

majiayu000/claude-skill-registry

Build AI agents with Google ADK Python (Agent Development Kit). Use for multi-agent systems, workflow agents (sequential/parallel/loop), Vertex AI deployment, tool integration, human-in-the-loop.

majiayu000/claude-skill-registry

Portfolio allocation and rebalancing optimizer. Manages asset allocation across stocks/cash/bonds, performs periodic rebalancing, and ensures diversification according to market regime and risk tolerance.

majiayu000/claude-skill-registry

Create a hilarious and ultra-realistic video of an anthropomorphic animal acting like a human vlogger in a real-world setting.

majiayu000/claude-skill-registry

Speech-to-text transcription and translation via OpenAI Audio API -- models, response formats, timestamps, prompting, streaming, chunking, and diarization

majiayu000/claude-skill-registry

BlockRun works with Claude Code and Google Antigravity.

majiayu000/claude-skill-registry

This skill should be used when the user asks about libraries, frameworks, API references, or needs code examples. Activates for setup questions, code generation involving libraries, or mentions of specific frameworks like React, Vue, Next.js, Prisma, Supabase, etc.

majiayu000/claude-skill-registry

小省导购员数字人带货版即梦视频提示词生成系统,基于四大智能体协同(提示词生成师、质量管控师、知识库运维师、跨环节适配师),按照"主体+运动+场景+(镜头语言+光影+氛围)"公式输出中英文双版提示词,适配5s短视频。确保人物一致性、视觉连贯性、情绪连贯性,支持知识库智能复用和跨工具适配(Suno音乐、AI绘画),为数字人带货视频提供高质量提示词生成服务。

majiayu000/claude-skill-registry

Upload and manage files using Google Gemini File API via scripts/. Use for uploading images, audio, video, PDFs, and other files for use with Gemini models. Supports file upload, status checking, and file management. Triggers on "upload file", "file API", "upload image", "upload PDF", "upload video", "file management".

majiayu000/claude-skill-registry

CRITICAL: Use for MolyKit AI chat toolkit. Triggers on: BotClient, OpenAI, SSE streaming, AI chat, molykit, PlatformSend, spawn(), ThreadToken, cross-platform async, Chat widget, Messages, PromptInput, Avatar, LLM

majiayu000/claude-skill-registry

AI and machine learning workflow covering LLM application development, RAG implementation, agent architecture, ML pipelines, and AI-powered features.

majiayu000/claude-skill-registry

Analyze images/audio/video with Gemini API (better vision than Claude). Generate images (Imagen 4), videos (Veo 3). Use for vision analysis, transcription, OCR, design extraction, multimodal AI.

majiayu000/claude-skill-registry

Analyze images/audio/video with Gemini API (better vision than Claude). Generate images (Imagen 4), videos (Veo 3). Use for vision analysis, transcription, OCR, design extraction, multimodal AI.

majiayu000/claude-skill-registry

Skill for discovering and researching autonomous AI agents, tools, and ecosystems using the AgentFolio directory.

Skills associés