Communitygithub.com

Code Style Enforcer

Analyse le code pour vérifier la cohérence stylistique et applique les conventions de formatage spécifiques au projet, au-delà de ce que les linters peuvent attraper. À utiliser lors de la revue de code, pour assurer la cohérence stylistique, ou lorsque l'utilisateur demande des améliorations de style.

Qu'est-ce que Code Style Enforcer ?

Cette compétence, **Code Style Enforcer**, permet à un agent IA de garantir que le code respecte les conventions stylistiques spécifiques d'un projet, en allant au-delà des vérifications automatisées des linters. Elle est utile pour maintenir une base de code cohérente, faciliter l'intégration de nouveaux développeurs et améliorer la lisibilité et la maintenabilité du code. Compatible avec de nombreux langages (JavaScript/TypeScript, Python, Ruby, Go, Java), elle s'appuie sur la détection de fichiers de configuration (`.eslintrc`, `pyproject.toml`, `.rubocop.yml`, etc.) et l'analyse des motifs de code existants pour identifier des incohérences de nommage, d'organisation, de commentaires, d'imports, de gestion d'erreurs et de types. La compétence génère des recommandations priorisées, suggère des outils automatisés (Prettier, Black) et propose la création d'un fichier `.editorconfig` pour standardiser le formatage. Elle suit une approche pragmatique, privilégiant la cohérence sur la perfection et l'amélioration incrémentale.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/aiskillstore/marketplace/crazydubya/code-style-enforcer

Demander à votre IA préférée

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

Documentation

Que fait Code Style Enforcer ?

Cette compétence garantit que le code respecte les conventions stylistiques et les motifs spécifiques au projet que les linters automatisés peuvent négliger.

Quand Utiliser Cette Compétence

  • L'utilisateur demande une revue ou des améliorations de style
  • Assurer la cohérence dans toute la base de code
  • Intégration de nouveau code ou de nouveaux contributeurs
  • Revue de code avant validation
  • L'utilisateur mentionne "style", "cohérence", "formatage" ou "conventions"

Instructions

1. Détecter les Guides de Style du Projet

Recherchez les fichiers de configuration de style :

JavaScript/TypeScript :

  • .eslintrc.* - Configuration ESLint
  • .prettierrc.* - Configuration Prettier
  • tsconfig.json - Options du compilateur TypeScript
  • .editorconfig - Configuration de l'éditeur

Python :

  • .pylintrc, pylint.cfg - Pylint
  • pyproject.toml - Configuration Black, isort
  • .flake8 - Configuration Flake8
  • setup.cfg - Configurations de divers outils

Ruby :

  • .rubocop.yml - Configuration RuboCop

Go :

  • go.fmt appliqué (standard)
  • .golangci.yml - GolangCI-Lint

Java :

  • checkstyle.xml - Checkstyle
  • .editorconfig

Général :

  • CONTRIBUTING.md - Directives de contribution
  • STYLE_GUIDE.md - Guide de style du projet
  • .editorconfig - Paramètres multi-éditeurs

Utilisez Glob pour trouver ces fichiers et Read pour comprendre les préférences de style du projet.

2. Analyser les Motifs de Code Existants

Échantillonnez le code existant pour comprendre les conventions implicites :

Organisation des fichiers :

  • Motifs de structure de répertoires
  • Conventions de nommage des fichiers (camelCase, kebab-case, snake_case)
  • Organisation des imports/exports

Structure du code :

  • Ordre des classes/fonctions
  • Placement des méthodes publiques vs privées
  • Emplacement des déclarations de constantes/variables

Formatage :

  • Indentation (espaces vs tabulations, taille)
  • Limites de longueur de ligne
  • Utilisation des lignes vides
  • Styles de commentaires

Nommage :

  • Nommage des variables (camelCase, snake_case)
  • Nommage des classes (PascalCase, capitalisation)
  • Nommage des constantes (UPPER_CASE, etc.)
  • Motifs de nommage des fichiers

Utilisez Grep pour trouver des motifs communs dans des fichiers similaires.

3. Au-Delà des Linters : Vérifier les Motifs

Concentrez-vous sur les problèmes de style que les outils automatisés négligent souvent :

Cohérence du Nommage :

  • Variables booléennes : préfixes is, has, should
  • Gestionnaires d'événements : motifs handle*, on*
  • Accesseurs/mutateurs : cohérence get*, set*
  • Nommage des collections : pluriel vs singulier
  • Acronymes : capitalisation cohérente

Organisation du Code :

  • Fonctions connexes regroupées
  • Structure de fichier cohérente entre les modules
  • Ordre logique (public avant privé, etc.)
  • Séparation des préoccupations

Commentaires et Documentation :

  • Complétude des JSDoc/docstrings
  • Cohérence du style de commentaire
  • Format TODO/FIXME
  • Commentaires en ligne vs blocs

Motifs d'Import/Export :

  • Ordre des imports (externes, internes, relatifs)
  • Exports nommés vs par défaut
  • Cohérence de la déstructuration
  • Motifs d'alias

Gestion des Erreurs :

  • Format cohérent des messages d'erreur
  • Utilisation des classes d'erreur
  • Motifs Try/catch
  • Format de journalisation

Utilisation des Types (TypeScript/langages typés) :

  • Types explicites vs inférés
  • Préférence interface vs type
  • Nommage générique (T, K, V vs descriptif)
  • Gestion de null/undefined

4. Identifier les Anti-Patterns Courants

Signalez les odeurs de code et les anti-patterns :

Nombres Magiques :

// Mauvais
if (status === 200) { }

// Bon
const HTTP_OK = 200;
if (status === HTTP_OK) { }

Vérifications Null Incohérentes :

// Incohérent
if (user === null) { }
if (!data) { }
if (typeof result === 'undefined') { }

// Cohérent
if (user === null) { }
if (data === null) { }
if (result === undefined) { }

Ternaires Imbriqués :

// Difficile à lire
const value = a ? b ? c : d : e;

// Mieux
let value;
if (a) {
  value = b ? c : d;
} else {
  value = e;
}

Listes de Paramètres Longues :

# Difficile à maintenir
def create_user(name, email, age, address, phone, ...):

# Mieux
def create_user(user_data: UserData):

5. Vérifier les Conventions Spécifiques au Projet

Recherchez les motifs uniques à ce projet :

  • Nommage personnalisé pour des domaines spécifiques (ex. "repo" vs "repository")
  • Bibliothèques préférées pour les tâches courantes
  • Motifs architecturaux (MVC, couche service, etc.)
  • Nommage et structure des fichiers de test
  • Motifs de configuration

Lisez CONTRIBUTING.md, README.md ou des documents similaires pour des directives explicites.

6. Générer des Recommandations de Style

Pour chaque problème, fournissez :

Code actuel :

function getData(id) {
  const d = fetch('/api/users/' + id);
  return d;
}

Problème :

  • Nommage incohérent (getData vs d'autres fonctions utilisant fetch*)
  • Nom de variable à une seule lettre (d)
  • Concaténation de chaînes au lieu de littéraux de gabarit

Recommandé :

function fetchUser(id) {
  const userData = fetch(`/api/users/${id}`);
  return userData;
}

7. Prioriser les Problèmes

Classez par impact :

Haute Priorité (Cohérence) :

  • Incohérences de nommage entre fonctions similaires
  • Indentation ou formatage mixte
  • Gestion des erreurs incohérente

Priorité Moyenne (Lisibilité) :

  • Nombres/chaînes magiques
  • Noms de variables peu clairs
  • Documentation manquante

Faible Priorité (Agréable à avoir) :

  • Formatage des commentaires
  • Ordre des imports
  • Lignes vides supplémentaires

8. Suggérer des Outils Automatisés

Recommandez des outils pour appliquer les styles :

JavaScript/TypeScript :

npm install --save-dev prettier eslint
npx prettier --write .
npx eslint --fix .

Python :

pip install black isort flake8
black .
isort .

Go :

go fmt ./...
golangci-lint run

Ruby :

gem install rubocop
rubocop -a

9. Créer ou Mettre à Jour EditorConfig

Suggérez .editorconfig s'il est manquant :

root = true

[*]
charset = utf-8
end_of_line = lf
insert_final_newline = true
trim_trailing_whitespace = true

[*.{js,ts,jsx,tsx}]
indent_style = space
indent_size = 2

[*.py]
indent_style = space
indent_size = 4

[*.go]
indent_style = tab

10. Liste de Vérification pour la Revue de Style

Lors de la revue de code pour le style :

  • Le nommage suit les conventions du projet
  • L'indentation et le formatage sont cohérents
  • Les imports sont organisés correctement
  • Commentaires là où nécessaire, pas excessifs
  • Pas de nombres ou chaînes magiques
  • La gestion des erreurs est cohérente
  • L'organisation des fichiers correspond à la structure du projet
  • Pas d'odeurs de code évidentes
  • Les annotations de type sont cohérentes (si applicable)
  • Les tests suivent les conventions de test

Meilleures Pratiques

  1. Cohérence avant la perfection : Suivez les motifs existants même s'ils ne sont pas idéaux
  2. Documenter les décisions : Ajoutez des guides de style pour les cas ambigus
  3. Automatiser quand c'est possible : Utilisez Prettier, Black, gofmt, etc.
  4. Soyez pragmatique : Ne refactorisez pas du code fonctionnel juste pour le style
  5. Accord d'équipe : Alignez-vous sur les styles qui comptent
  6. Amélioration incrémentale : Corrigez les styles dans les fichiers touchés, pas tous à la fois
  7. Lisibilité d'abord : Le style est au service de la lisibilité, pas l'inverse

Conflits de Style Courants

Tabulations vs Espaces

  • Vérifiez .editorconfig ou les fichiers existants
  • En cas de doute, utilisez la majorité du projet

Style de Guillemets (Simples vs Doubles)

  • JavaScript : Simples (') courantes
  • Python : Les deux, soyez cohérent
  • Go : Toujours doubles (")
  • Suivez la config du linter si présente

Points-Virgules (JavaScript)

  • Vérifiez la majorité du code existant
  • Si mélangés, suggérez Prettier pour appliquer

Longueur de Ligne

  • Limites courantes : 80, 100, 120 caractères
  • Vérifiez la config du linter ou .editorconfig

Ordre des Imports

  • Généralement : bibliothèque standard, externe, interne, relatif
  • Utilisez des outils automatisés (isort, organize imports)

Fichiers d'Appui

  • reference/style-guides.md : Liens vers les guides de style populaires
  • examples/before-after.md : Exemples de code montrant les améliorations

Individual skills in this repo

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

ComeOnOliver/skillshub

Create stunning, animation-rich HTML presentations from scratch or by converting PowerPoint files. Use when the user wants to build a presentation, convert a PPT/PPTX to web, or create slides for a talk/pitch. Helps non-designers discover their aesthetic through visual exploration rather than abstract choices.

ComeOnOliver/skillshub

Next.js 16+ 和 Turbopack — 增量打包、文件系统缓存、开发速度,以及何时使用 Turbopack 与 webpack。

ComeOnOliver/skillshub

SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

ComeOnOliver/skillshub

See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio, video), and create real time alerts for events from live streams or desktop capture.

ComeOnOliver/skillshub

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

ComeOnOliver/skillshub

Next.js 15 애플리케이션을 위한 프론트엔드 개발 가이드라인. React 19, TypeScript, Shadcn/ui, Tailwind CSS를 사용한 모던 패턴. Server Components, Client Components, App Router, 파일 구조, Shadcn/ui 컴포넌트, 성능 최적화, TypeScript 모범 사례 포함. 컴포넌트, 페이지, 기능 생성, 데이터 페칭, 스타일링, 라우팅, 프론트엔드 코드 작업 시 사용.

ComeOnOliver/skillshub

Provides Tamagui patterns for config v4, compiler optimization, styled context, and cross-platform styling. Must use when working with Tamagui projects (tamagui.config.ts, @tamagui imports).

ComeOnOliver/skillshub

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

ComeOnOliver/skillshub

Create high-converting, visually distinctive landing pages. Use when building marketing pages, product launches, SaaS homepages, or any single-page conversion-focused website. Guides section-by-section composition with anti-AI-slop principles.

ComeOnOliver/skillshub

Auto-loaded context for Portfolio Buddy 2 development. Use for ANY task involving: React 19 development, TypeScript, portfolio analysis features, metrics calculations, trading strategy comparison, or working with the Portfolio Buddy 2 codebase. Contains tech stack, known issues, and architectural constraints.

ComeOnOliver/skillshub

Next.js development tooling via MCP. Inspect routes, components, build info, and debug Next.js apps. Use when working on Next.js applications, debugging routing, or inspecting app structure. NOT for general React or non-Next.js projects.

ComeOnOliver/skillshub

Implement UI using Shadcn MCP (atoms/theme) and 21st.dev MCP (complex sections). Use when adding buttons, layouts, or generating landing pages.

ComeOnOliver/skillshub

A conceptual skill for building an API client in Next.js that handles JWT tokens

ComeOnOliver/skillshub

Best practices and patterns for Next.js App Router, Server Actions, and Routing in this project.

ComeOnOliver/skillshub

The Design System, Theme, and UX rules for the Physical AI Hub.

ComeOnOliver/skillshub

Comprehensive frontend development skill for building modern, performant web applications using ReactJS, NextJS, TypeScript, Tailwind CSS. Includes component scaffolding, performance optimization, bundle analysis, and UI best practices. Use when developing frontend features, optimizing performance, implementing UI/UX designs, managing state, or reviewing frontend code.

ComeOnOliver/skillshub

This document captures learnings from fixing keyboard navigation issues when floating components (Select, DropdownMenu, Popover) have CSS open/close animations.

ComeOnOliver/skillshub

Build Next.js 16 applications with correct patterns and distinctive design. Use when creating pages, layouts, dynamic routes, upgrading from Next.js 15, or implementing proxy.ts. Covers breaking changes (async params/searchParams, Turbopack, cacheComponents) and frontend aesthetics. NOT when building non-React or backend-only applications.

ComeOnOliver/skillshub

Comprehensive Framer Motion animation library for React. Covers motion components, variants, gestures, page transitions, and scroll animations. Use when adding animations to React/Next.js applications.

ComeOnOliver/skillshub

Build interfaces that resonate, not just render. This skill enforces bold, intentional

Skills associés