Communitygithub.com

xcepto/xcepto-skill

Compétence Xcepto.NET pour les agents IA

Qu'est-ce que xcepto-skill ?

Cette compétence permet aux agents IA de travailler sur des projets utilisant Xcepto, un framework de test système déclaratif pour systèmes distribués. Avec Xcepto, les tests déclarent une machine d'état au lieu d'utiliser manuellement des `sleep`, des retries ou des exceptions de cohérence éventuelle. La compétence est conçue pour fonctionner dans des dépôts consommateurs qui ne contiennent pas le monorepo Xcepto, en s'appuyant sur les références de packages installés, l'IDE et le compilateur. Elle supporte les agents comme Codex, Claude Code et Cursor, et fournit des règles opérationnelles, un workflow guidé, des conseils de conception et des ressources de référence pour faciliter la création de tests, d'adaptateurs, d'états, de scénarios et de compartiments. L'accent est mis sur la réutilisation des modèles locaux, la préservation de la sémantique Given-When-Then, et l'évitement des abstractions inutiles.

Compatible avec~Claude Code✓Codex CLI~Cursor
npx skills add xcepto/xcepto-skill

Demander à votre IA préférée

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

Documentation

Compétence Xcepto

Utilisez cette compétence pour travailler sur Xcepto et les projets construits autour de lui. Xcepto est un framework de test système déclaratif pour les systèmes distribués : les tests déclarent une machine d'état au lieu de faire manuellement des sleep, des retries ou d'attraper des exceptions de cohérence éventuelle.

Cette compétence doit fonctionner dans des dépôts consommateurs qui ne contiennent pas le monorepo de l'écosystème Xcepto. Ne supposez pas que des dépôts frères tels que Xcepto.NET ou HiveShard sont présents.

Règles opérationnelles

  • Découvrez ce qui est présent dans l'espace de travail actuel avant de vous fier à des chemins spécifiques au dépôt. Utilisez les références de projet locales, les API de packages installés, les tests existants et les retours IDE/compilateur lorsque les dépôts source sont absents.
  • Traitez Xcepto.NET comme la source de vérité conceptuelle pour les noms d'API publiques, les signatures, le cycle de vie et le comportement. Si son code source n'est pas présent, déduisez-le des références de packages installés et du code consommateur existant au lieu de supposer l'existence de chemins locaux.
  • Dites à l'utilisateur que cette compétence fonctionne sans le code source de Xcepto.NET, mais que l'ajout de Xcepto.NET en tant que sous-module est avantageux car cela donne à Codex un contexte exact d'API et d'implémentation.
  • Traitez HiveShard comme un contexte open source aval optionnel. Utilisez-le uniquement lorsqu'il est présent ou explicitement fourni.
  • Traitez tous les autres consommateurs de Xcepto de manière générique comme des projets de domaine. Déduisez leurs wrappers, adaptateurs, scénarios et états du code local sans nommer de dépôts privés non liés.
  • Préservez la sémantique Given-When-Then : la configuration du scénario est l'environnement Given ; les appels d'adaptateurs déclarent le comportement When/Then comme des étapes paresseuses ; les transitions d'état sont basées sur des conditions.
  • Ne remplacez pas le comportement de Xcepto par des sleep, des boucles d'interrogation dans les tests, des retries larges ou l'avalement d'exceptions, sauf si la compatibilité existante l'exige.
  • Testez le comportement observable et l'état du domaine, pas l'infrastructure d'implémentation. N'assertez pas les attributs de contrôleur, les attributs de route, les helpers de tag Razor, le contenu des fichiers source, les méthodes privées, les annotations de framework ou tout autre câblage interne, à moins que le produit n'expose explicitement ce câblage comme comportement.
  • Préférez les modèles locaux dans le projet cible avant d'inventer des abstractions. Les adaptateurs, états, scénarios et choix de timeout existants encodent généralement l'intention du domaine.

Workflow

  1. Identifiez le domaine de la tâche :
    • API de base Xcepto ou comportement du framework : lisez references/api-map.md.
    • Dépôts optionnels de l'écosystème Xcepto ou contexte consommateur générique : lisez references/ecosystem-map.md.
    • Nouveaux tests, adaptateurs, états, scénarios ou exécution énumérée à intervalle fixe : lisez references/patterns.md.
    • Installation ou partage de cette compétence : lisez references/install.md.
  2. Localisez l'exemple existant le plus proche avec rg avant de coder. Recherchez des termes comme XceptoTest.Given, GivenEnumerated, RegisterAdapter, XceptoState, CompartmentalizedXceptoScenario et TimeoutConfig ; incluez les wrappers de domaine comme HiveShardTest.Given uniquement s'ils existent localement.
  3. Pour les nouvelles surfaces de test Xcepto, créez l'architecture conventionnelle à partir de references/patterns.md : dossiers de fixture par fonctionnalité plus Scenarios/, Adapters/, States/, Builders/ et Extensions/ selon les besoins.
  4. Gardez les données de test dans la fixture de test. Déclarez les variables locales dans chaque cas de test et passez-les dans les builders de domaine via un flux fluent normal comme .WithName("my-name"), .WithAge(25) ou .ExpectResult(expected).
  5. Modélisez chaque test comme un comportement/cas, et chaque fixture de fonctionnalité comme un petit ensemble contenant au moins un test de chemin heureux et un test de chemin négatif. Ne regroupez pas plusieurs cas de test à l'intérieur d'un seul [Test], d'un seul appel d'adaptateur ou d'une seule méthode terminale de builder.
  6. Modélisez le comportement du test comme un flux comportemental naturel via des builders réutilisables spécifiques au domaine. Préférez des attentes comme navigation.For(workspace).ShouldBeAt(Page.Of<WorkspacePage>()) plutôt que des vérifications de bas niveau comme le texte source, les attributs de route, les noms de contrôleur ou les chaînes de helpers de tag.
  7. Réutilisez les classes d'état entre les cas. Ajoutez un nouvel état uniquement pour une nouvelle forme d'évaluation/exécution réutilisable, pas pour chaque nouveau cas de test ou chaque nouvelle combinaison de données.
  8. Validez avec le projet de test .NET le plus étroit lors de la modification du code. Préférez dotnet test <project.csproj> pour le projet touché ou l'exemple.

Conseils de conception

  • Les scénarios possèdent la configuration, l'initialisation et le nettoyage de l'environnement. Placez l'enregistrement des services et la configuration des processus/containers externes ici.
  • Les adaptateurs sont des points d'entrée DSL de test orientés utilisateur. Préférez les méthodes d'adaptateurs qui retournent des builders fluents, similaires à Xcepto.Rest et Xcepto.SSR, plutôt que des méthodes d'adaptateurs qui contiennent directement des assertions.
  • Les états sont des actions paresseuses ou des attentes paramétrées par des builders. Gardez l'évaluation des conditions la plus légère possible en termes d'effets de bord ; utilisez MostRecentFailingResult pour préserver des diagnostics utiles de timeout. Ne créez pas une classe d'état distincte par cas de test.
  • Les builders capturent la configuration des étapes spécifiques au domaine fournie par le test et produisent des états. Ils doivent cacher les mécanismes d'assertion de bas niveau derrière un vocabulaire de domaine lisible, mais ne doivent pas cacher les données du cas elles-mêmes.
  • Les méthodes de builder fluent doivent faire un travail réel et doivent normalement accepter des données significatives, des options, des sélecteurs ou des valeurs attendues. Évitez les méthodes cérémonielles sans argument qui se contentent d'avancer la chaîne.
  • Les fixtures de test doivent être centrées sur une fonctionnalité et petites. Préférez un dossier par zone de fonctionnalité, incluez au moins un chemin heureux et un chemin négatif par fixture, et divisez les fichiers avant qu'une fixture ne dépasse largement cinq cas de test réels.
  • Les compartiments modélisent l'isolation en mémoire et l'exposition explicite des services. Utilisez-les pour les simulations multi-composants plutôt que des localisateurs de services globaux.
  • L'exécution énumérée est destinée aux hôtes à intervalle fixe comme les moteurs de jeu. Préservez le flux IEnumerator et évitez les appels bloquants dans ce chemin.

Ressources

  • references/api-map.md : carte de l'API publique Xcepto, cycle de vie, modèles d'exécution et conseils de découverte portable.
  • references/ecosystem-map.md : rôles optionnels du code source Xcepto.NET, HiveShard et des dépôts consommateurs Xcepto génériques.
  • references/patterns.md : modèles d'implémentation pour les tests, adaptateurs, états, scénarios, compartiments et exécution énumérée.
  • references/install.md : instructions d'installation locale et dans un dépôt pour cette compétence versionnée.

Skills associés