Communitygithub.com

fswp-plugin-developer

Étape de construction de plugins pour le développeur Full-Stack WP. Normes internes et modèles de code pour de vrais plugins WordPress (pas d'extraits de shortcodes) – anatomie des dossiers, cycle de vie activation/désinstallation, types de publication personnalisés et tables, niveaux d'interface d'administration, sortie front-end sur l'Atomic Framework, REST et cron, i18n, distribution, et la pile d'administration React Tier 3 – ainsi qu'un script d'échafaudage. Également la structure de base pour les modules complémentaires. Invoqué par fswp-developer après un PRD approuvé ; consultez directement pour un modèle de construction de plugin spécifique.

Qu'est-ce que fswp-plugin-developer ?

Cette compétence, fswp-plugin-developer, est l'étape de construction de plugins pour le développeur Full-Stack WP. Elle est appelée après qu'un PRD a été approuvé par fswp-architect. Son objectif est de générer des plugins WordPress réels et structurés, et non de simples extraits de shortcode. Le skill définit huit couches de construction, de l'échafaudage initial (bootstrap, lifecycle) jusqu'à la distribution et l'internationalisation, en passant par la gestion des CPT, des tables, des routes REST, du cron, des blocs, de l'interface d'administration et de la sortie front-end. Ces couches sont appliquées selon un workflow strict, documenté dans un tableau Markdown, chaque étape faisant appel à des références internes et à des compétences spécialisées (ex: fswp-security-engineer, fswp-api-developer). Le skill impose des normes de code rigoureuses, notamment en matière de sécurité, de versions, et de documentation. Il s'appuie sur un script d'échafaudage (scaffold_plugin.py) et un ensemble de modèles (templates) qui sont instanciés avec des variables comme {{PREFIX}} ou {{plugin-slug}}. Il est conçu pour être utilisé sur n'importe quelle plateforme supportant des agents IA de développement (Claude Code, Cursor, Codex, etc.), car il ne dépend que de la ligne de commande et de Python. Le résultat livrable est un fichier .zip du plugin, avec readme.txt et un README.md décrivant les étapes manuelles restantes.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/syncwin/fswp-developer/tree/main/skills/fswp-plugin-developer

Demander à votre IA préférée

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

Documentation

Développeur de Plugin FSWP

Fondamental (toujours appliqué) : fswp-developer/references/lean-coding.md (écrivez moins, réutilisez d'abord), fswp-developer/references/coding-standards.md (normes de codage, documentation, i18n, accessibilité), et fswp-security-engineer (entrée, sortie, autorisation).

Exécute un PRD approuvé (fswp-architect). Le préfixe, la cible de distribution, la surface de fonctionnalités et le niveau JS sont déjà décidés ; ne demandez pas à nouveau. Pour chaque étape, chargez la compétence de domaine pour la procédure générale et la référence de cette compétence pour la profondeur des normes internes, les modèles et les règles plus strictes. Préséance : fswp-developer/references/precedence.md.

Pour les modifications d'un plugin existant, utilisez fswp-maintainer à la place ; il fait appel ici uniquement pour les modèles de structure.

Couches

1  BOOTSTRAP   plugin-slug.php, uninstall.php, includes/class-plugin.php (pas de logique métier)
2  LIFECYCLE   Activator / Deactivator (hook d'activation, dbDelta, vérification de mise à jour)
3  DOMAINE      CPTs, tables, routes REST, cron : uniquement ce que le PRD liste
4a ADMIN UI    wp-admin natif par défaut ; @wordpress/components pour un écran React ;
               React SPA + Tailwind + TanStack Query + Zustand uniquement pour une admin de type application
4b PUBLIC UI   Atomic Framework (fourni par l'utilisateur), vanilla JS par défaut, Alpine en option

L'interface d'administration n'utilise jamais les classes Atomic Framework ou Alpine. Ne créez jamais de classes de fonctionnalités inutilisées.

Flux de travail

ÉtapeActionRéférence interneCompétence de domaine
1 ÉchafaudageDéduire le slug, le préfixe, les noms de classe, le domaine de texte ; exécuter scripts/scaffold_plugin.py --help d'abord. Passer --plugin-uri et --author-uri uniquement s'ils sont réels (la ligne est supprimée sinon, jamais un domaine fictif). Exécuter fswp-qa-engineer/scripts/run_gate.sh <dir> <min-php> --fix juste après l'échafaudage : les modèles contiennent des marqueurs {{...}} que le formateur ne peut pas reformater en toute sécurité avant la substitution.architecture.mdaucun
2 Bootstrap + lifecycleBootstrap déclare l'en-tête, l'autoload, et transmet la main à la classe principalearchitecture.mdaucun
3 SécuritéLigne de base complète sur chaque fichier, quelle que soit la taille du pluginfswp-security-engineerfswp-security-engineer
4 DomaineCPTs, tables (dbDelta, versions de schéma), REST, crondata-cpt.md, rest-cron.mdfswp-api-developer ; fswp-performance-engineer si le PRD le nécessite
5 Blocs (si dans le PRD)Blocs personnalisés, motifs, interactivitéaucunfswp-block-developer
6 Admin UIAPI Settings, WP_List_Table, Dashicons ; escalader uniquement selon la liste de contrôleadmin-ui.md, modern-app-stack.mdaucun
7 Sortie publiqueDemander d'abord à l'utilisateur les fichiers actuels de l'Atomic Framework ; enqueue conditionnel à l'intérieur du callbackfrontend-output.mdaucun
8 i18n + distributionChaque chaîne PHP et JS ; readme ; licence ; versioningi18n-distribution.mdfswp-release-manager pour WordPress.org

Arrêtez-vous à la fin de l'étape 8 et passez à fswp-qa-engineer.

Structure des modules complémentaires

Lorsque fswp-maintainer s'exécute en mode add-on, il réutilise les étapes 1-3 et 8 ici. Les règles supplémentaires pour les add-ons (détection de l'hôte, Requires Plugins, ordre de chargement, absence gracieuse) se trouvent dans fswp-maintainer.

Normes (chaque construction, chaque itération)

references/standards.md régit la discipline de versioning/changelog, la décision de la pile technologique, les métadonnées requises du projet (n'inventez jamais une valeur manquante), la documentation par fonctionnalité dans docs/, la barre de qualité du code, et la discipline de code minimal (ordre décider-avant-d'écrire, corrections de cause racine, marqueurs shortcut:). Lisez-le avant la première construction et avant toute itération sur un plugin existant – ce n'est pas une étape de configuration unique.

Posture de sécurité

Jamais réduite pour les petits plugins : vérifications de capacité sur chaque action privilégiée, nonces sur chaque changement d'état, assainir l'entrée et échapper la sortie, $wpdb->prepare() sur chaque requête, un permission_callback réel sur chaque route REST, cycle de vie sûr, pas de secrets en clair. Règles complètes : fswp-security-engineer.

Niveau Alpine

Jamais déduit. Sélectionné uniquement par la liste de contrôle en 5 points dans references/frontend-output.md, et seulement après que l'utilisateur a explicitement confirmé avoir vu quel élément l'a déclenché et à quoi ressemble l'alternative vanilla.

Atomic Framework (fourni par l'utilisateur, pas regroupé)

C'est un produit maintenu séparément ; une copie regroupée dériverait. Chaque fois que la construction inclut frontend, demandez les fichiers actuels afw-tokens.css, afw-components.css, afw-foundation-logics.js (plus alpine.min.js, alpine-loader.js, alpine-components.js uniquement si le niveau Alpine a été confirmé). L'échafaudage les copie via --foundation-dir et s'arrête avec un rappel s'il est manquant.

Dépendances

Tout sauf l'Atomic Framework (niveau 2 @wordpress/*, pile niveau 3) est résolu à latest depuis son registre officiel au moment de l'échafaudage, puis épinglé : validez le fichier de verrouillage et enregistrez les versions résolues dans le README. Latest-at-scaffold plus un fichier de verrouillage validé satisfait la règle de source reproductible de WordPress.org. Exception : un plafond de compatibilité déclaré par l'utilisateur. Détails : references/modern-app-stack.md.

Livrable

Fichier {plugin-slug}.zip installable (dossier du plugin à la racine du zip) plus readme.txt et/ou README.md privé avec de vraies étapes d'installation, et un bref résumé : préfixe et décisions de fonctionnalités, étapes manuelles encore nécessaires (clés API, intervalle cron, paramètres initiaux). La sortie compilée est livrée avec sa source (references/modern-app-stack.md).

Inclus

  • scripts/scaffold_plugin.py : --features cpt,db,rest,cron,admin,frontend (n'importe quel sous-ensemble), --js-tier vanilla|alpine, --admin-tier native|react|app, --distribution wporg|private|both, --plugin-uri, --author-uri, --foundation-dir, --zip.
  • assets/templates/ : squelette de plugin avec les marqueurs {{PREFIX}}, {{Prefix}}, {{prefix}}, {{PLUGIN_NAME}}, {{plugin-slug}}.

Individual skills in this repo

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

fswp-api-developer

Domain skill for WordPress REST API and Abilities API work in Full-Stack WP Developer. Covers registering routes with schemas, argument validation and sanitization, permission callbacks, controller classes, exposing post types and meta, authentication (cookie nonce, application passwords), pagination and errors, and registering abilities with input and output schemas and safety annotations. Use for any custom endpoint or machine-readable capability in a plugin or theme.

fswp-architect

Planning stage of Full-Stack WP Developer. Classifies the work (new plugin, new theme, update to an existing plugin or theme, add-on for another product, or WordPress Core patch), triages existing code with a bundled detection script, asks one round of essential questions, does competitive research, and produces one reviewable PRD or change brief with a single approval gate. Also covers Migration mode and multi-session handoff docs. Invoked by fswp-developer before any code is written; consult directly for PRD, change-brief, or handoff-doc questions.

fswp-block-developer

Domain skill for WordPress block editor work in Full-Stack WP Developer. Covers building custom Gutenberg blocks (block.json, static and dynamic rendering, attributes, supports, InnerBlocks, variations, deprecations, block bindings), block patterns, and the Interactivity API (data-wp directives, stores, server-side state), with the @wordpress/scripts build workflow. Use for any custom block, pattern, or front-end interactivity in a plugin or theme.

fswp-core-contributor

WordPress Core contribution stage of Full-Stack WP Developer. Guides a contributor through finding or filing a Trac ticket, setting up the wordpress-develop checkout and test environment, writing a patch or GitHub pull request that follows Core coding standards, inline documentation, backward compatibility and tests, and preparing the ticket comment; also routes block-editor changes to the Gutenberg repository and security reports to the private process. Invoked by fswp-developer for Core patches; consult directly for Core workflow questions.

fswp-devops-engineer

Domain skill for WordPress development tooling in Full-Stack WP Developer. Covers local environments (wp-env with Docker, WordPress Playground and Blueprints), command-line site operations (plugin and theme management, database export, search-replace, cron, scaffolding), coding standards and static analysis (PHPCS with WordPress standards, PHPStan with WordPress stubs), PHP and JS testing setup, and the @wordpress/scripts toolchain. Use when setting up, running, or automating a WordPress dev or test environment.

fswp-maintainer

Change stage for existing WordPress code in Full-Stack WP Developer. Updates, fixes, refactors, and upgrades existing plugins and themes without breaking them, and builds add-ons for products you do not own (WooCommerce extensions, page-builder elements, extensions of other plugins) using hooks instead of edits to third-party files. Covers reading before changing, parity lists, deprecation, host compatibility, upgrade paths, and patch delivery. Invoked by fswp-developer after an approved change brief; consult directly for safe-change or add-on questions.

fswp-qa-engineer

Verification stage of Full-Stack WP Developer. Runs the mechanical gate for plugins and themes (house-rule scripts, PHP lint, PHPCS with WordPress standards, PHP compatibility, PHPStan with WordPress stubs), the manual checklist, PRD or change-brief scenario tests, and the pre-release check. Reports PASS, FAIL, or NOT RUN and never implies a skipped check passed. Invoked by fswp-developer after a build and again before delivery; consult directly to audit any plugin or theme folder.

fswp-reviewer

Independent review stage of Full-Stack WP Developer. Reviews a finished WordPress plugin, theme, add-on, or Core patch through a security lens (WordPress-specific vulnerabilities, REST and AJAX authorization with an API risk map, AI-generated-code risks), a quality lens (error handling, data and upgrade safety, performance, i18n, accessibility, comment accuracy, test gaps, class and type design, scope), and an optional lean lens for trimming over-engineering, reporting only high-confidence findings in a fixed format. Invoked by fswp-developer after the verify gate, normally through the fswp-code-reviewer agent; consult directly to review or optimize any WordPress code.

fswp-theme-developer

Theme build stage of Full-Stack WP Developer. Builds custom WordPress themes - block themes (theme.json, templates, template parts, patterns, style variations), classic themes (template hierarchy, functions.php, theme supports), hybrids, and child themes - with accessibility, escaping, and directory readiness built in, plus a scaffold script. Invoked by fswp-developer after an approved PRD for a new theme; consult directly for a specific theme pattern. For changes to an existing theme use fswp-maintainer.

Skills associés