antigravity-flow 1.0.0

package/dist/src/templates/en/po.md.ejs

@@ -0,0 +1,86 @@
+---
+description: Product Owner Workflow
+---
+
+1. **Backlog Management**:
+   - Maintain a prioritized product backlog.
+   - Refine backlog items with the team.
+   - Ensure items are sized and ready for sprint.
+   - Remove or archive stale items regularly.
+
+2. **User Stories** (INVEST Criteria):
+   - **I**ndependent: Minimize dependencies between stories.
+   - **N**egotiable: Leave room for discussion.
+   - **V**aluable: Deliver value to users or business.
+   - **E**stimable: Team can estimate effort.
+   - **S**mall: Fits within a sprint.
+   - **T**estable: Clear acceptance criteria.
+
+3. **Acceptance Criteria**:
+   - Define clear, testable acceptance criteria.
+   - Use Given/When/Then format when applicable.
+   - Include edge cases and error scenarios.
+   - Validate with stakeholders before development.
+
+4. **Definition of Ready (DoR)**:
+   - [ ] User story is clearly written
+   - [ ] Acceptance criteria are defined
+   - [ ] Dependencies are identified
+   - [ ] Story is estimated
+   - [ ] UI/UX designs are available (if needed)
+   - [ ] Technical feasibility is confirmed
+
+5. **Definition of Done (DoD)**:
+   - [ ] Code is written and reviewed
+   - [ ] Tests are passing
+   - [ ] Documentation is updated
+   - [ ] Feature is deployed to staging
+   - [ ] PO has validated acceptance criteria
+   - [ ] No critical bugs remain
+
+6. **Requirements Clarification**:
+   - Answer functional questions from the team.
+   - Provide context on business rules.
+   - Clarify edge cases and priorities.
+   - Be available during sprint for questions.
+
+7. **Sprint Ceremonies**:
+   - Participate in sprint planning.
+   - Lead sprint demos/reviews.
+   - Provide feedback on delivered features.
+   - Help resolve blockers affecting delivery.
+
+8. **Roadmap Alignment**:
+   - Align sprint goals with product roadmap.
+   - Communicate priorities to stakeholders.
+   - Adjust plans based on feedback and data.
+   - Balance new features vs. tech debt.
+
+9. **Impact Mapping**:
+   - Define goals: Why are we doing this?
+   - Identify actors: Who benefits?
+   - Define impacts: What behavior change do we want?
+   - Map deliverables: What can we build?
+
+10. **User Journey Mapping**:
+    - Document user personas and their goals.
+    - Map key user journeys end-to-end.
+    - Identify pain points and opportunities.
+    - Prioritize improvements based on impact.
+
+11. **Stakeholder Communication**:
+    - Provide regular status updates.
+    - Gather and incorporate feedback.
+    - Manage expectations on timelines.
+    - Escalate risks and blockers early.
+
+## User Story Template
+```
+As a [user type],
+I want to [action],
+So that [benefit].
+
+Acceptance Criteria:
+- Given [context], when [action], then [result]
+- ...
+```

package/dist/src/templates/en/project-context.md.ejs

@@ -0,0 +1,26 @@
+# Project Context
+
+## Project Vision
+<%= projectDescription %>
+
+## Technical Stack
+- **Stack**: <%= techStack %>
+-## 🏗️ Architecture
+**Pattern**: <%= architecture %>
+<% if (isMonorepo) { %>
+**Monorepo**: Yes
+**Apps**:
+<% apps.forEach(function(app) { %>
+- <%= app %>
+<% }); %>
+<% } else { %>
+**Monorepo**: No
+<% } %>
+
+## 🛠️ Build & Test
+ Commands
+- **Build**: `<%= buildCommand %>`
+- **Test**: `<%= testCommand %>`
+
+## Conventions
+Please refer to `.agent/rules/coding-standards.md` for detailed coding rules.

package/dist/src/templates/en/qa.md.ejs

@@ -0,0 +1,103 @@
+---
+description: QA & Testing Workflow
+---
+
+1. **Test Planning**:
+   - Review requirements, specs, and acceptance criteria.
+   - Identify test cases (nominal, edge cases, error handling).
+   - Create test matrices for complex features.
+   - Estimate testing effort and timelines.
+
+2. **Test Data Management**:
+   - Create reusable test fixtures and factories.
+   - Use realistic but anonymized data.
+   - Implement data seeding scripts for consistent test environments.
+   - Clean up test data after each test run.
+
+3. **Unit Testing**:
+   - Test individual functions and classes in isolation.
+   - Mock external dependencies (databases, APIs).
+   - Aim for high coverage on business logic.
+   - Use `<%= testCommand %>` to execute tests.
+
+4. **Integration Testing**:
+   - Test interactions between components.
+   - Use test containers for database tests.
+   - Verify API contracts and data flows.
+   - Test error handling and recovery.
+
+5. **E2E Testing**:
+   - Test complete user journeys.
+   - Use Playwright, Cypress, or similar for browser tests.
+   - Maintain stable selectors and test IDs.
+   - Run E2E tests in CI before deployment.
+
+6. **Mocking Strategies**:
+   - Use MSW (Mock Service Worker) for API mocking.
+   - Use test containers for database integration tests.
+   - Mock time-dependent functions for deterministic tests.
+   - Document mock behavior expectations.
+
+7. **Accessibility Testing (a11y)**:
+   - Verify keyboard navigation.
+   - Check screen reader compatibility.
+   - Validate color contrast ratios.
+   - Use automated tools (axe, WAVE, Lighthouse).
+
+8. **Performance Testing**:
+   - Establish performance baselines.
+   - Test response times under load.
+   - Monitor memory and CPU usage.
+   - Identify and fix N+1 queries.
+
+9. **Security Testing**:
+   - Test authentication and authorization flows.
+   - Verify input validation and sanitization.
+   - Check for OWASP Top 10 vulnerabilities.
+   - Test rate limiting and abuse prevention.
+
+10. **Visual Regression Testing**:
+    - Capture screenshots of UI components.
+    - Compare against baseline images.
+    - Review and approve intentional changes.
+    - Use tools like Percy, Chromatic, or Playwright.
+
+11. **Bug Reporting**:
+    - Document bugs clearly with reproduction steps.
+    - Include environment details and logs.
+    - Assign severity and priority.
+    - Create a fix or assign to a Developer.
+
+12. **Regression Testing**:
+    - Ensure new changes didn't break existing functionality.
+    - Run full test suite before releases.
+    - Prioritize critical path tests.
+
+13. **Sign-off**:
+    - Validate the feature matches requirements.
+    - Confirm all test cases pass.
+    - Update test documentation.
+    - Approve for release.
+
+## Coverage Targets
+| Type | Target |
+|------|--------|
+| Unit Tests | 80%+ |
+| Integration Tests | Critical paths |
+| E2E Tests | Happy paths |
+| a11y | WCAG 2.1 AA |
+
+## Quick Reference Commands
+```bash
+# Run all tests
+<%= testCommand %>
+
+# Run with coverage
+npm run test:cov
+
+# Run E2E tests
+npm run test:e2e
+
+# Run specific test
+npm test -- --grep "test name"
+```

package/dist/src/templates/en/rules.md.ejs

@@ -0,0 +1,30 @@
+---
+description: Agent Rules & Standards
+---
+
+# Agent Rules & Standards
+
+You are an expert software developer following **Clean Code** and **Clean Architecture** (Pragmatic SOLID) principles.
+You must STRICTLY adhere to the following rules when generating code.
+
+## 1. General Principles
+- **SOLID**: Respect the 5 principles (Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion).
+- **KISS** (Keep It Simple, Stupid): Avoid unnecessary complexity.
+- **DRY** (Don't Repeat Yourself): Refactor duplicated code.
+- **Boy Scout Rule**: Leave the code cleaner than you found it.
+
+## 2. Architecture & Structure
+- **Separation of Concerns**: Isolate business logic (Core/Domain) from infrastructure details (Adapters, Frameworks).
+- **Dependency Injection**: Use dependency injection (via constructor) for loose coupling.
+- **Interfaces**: Define clear interfaces for services and adapters (prefixed with `I`, e.g., `IUserService`).
+
+## 3. Code Quality
+- **Strong Typing**: Use TypeScript in strict mode (`strict: true`). Avoid `any`.
+- **Naming**: Variables and functions in `camelCase`, Classes and Types in `PascalCase`, Constants in `UPPER_CASE`. Use explicit English names.
+- **Tests**: Prioritize TDD (Test Driven Development). All new business code must be covered by unit tests.
+- **Comments**: Code should be self-documenting. Comment only the "Why", not the "How".
+
+## 4. Workflow
+1. **Plan**: Always propose an implementation plan before coding.
+2. **Implement**: Code step-by-step, verifying each increment.
+3. **Verify**: Review generated code to ensure it complies with these rules.

package/dist/src/templates/en/security.md.ejs

@@ -0,0 +1,55 @@
+---
+description: Security Engineering & Compliance Workflow
+---
+
+1. **Threat Modeling**:
+   - Conduct threat modeling exercises during design phases (STRIDE, DREAD).
+   - Identify potential attack vectors and vulnerabilities.
+   - Document security requirements and mitigations.
+   - Update threat models as architecture evolves.
+
+2. **Application Security (AppSec)**:
+   - Ensure secure coding practices (OWASP Top 10).
+   - Implement input validation and output encoding to prevent injection attacks.
+   - Enforce proper authentication and session management.
+   - Use secure cryptographic libraries and practices.
+
+3. **Infrastructure Security**:
+   - Harden servers and containers (CIS Benchmarks).
+   - Implement network segmentation and firewalls (WAF).
+   - Ensure encryption at rest and in transit (TLS/SSL).
+   - Manage IAM policies with least privilege principle.
+
+4. **Security Testing**:
+   - Integrate SAST (Static Application Security Testing) in CI pipelines.
+   - Integrate DAST (Dynamic Application Security Testing) for running apps.
+   - Conduct regular penetration testing and vulnerability assessments.
+   - Automate dependency scanning for known vulnerabilities (SCA).
+
+5. **Identity & Access Management (IAM)**:
+   - Implement Multi-Factor Authentication (MFA).
+   - Use centralized identity providers (IdP/SSO).
+   - Regularly review and rotate access keys and credentials.
+   - Audit access logs and permissions.
+
+6. **Incident Response**:
+   - Define an Incident Response Plan (IRP).
+   - Establish communication channels for security incidents.
+   - Conduct post-mortem analysis of security incidents.
+   - Automate containment and remediation where possible.
+
+7. **Compliance & Governance**:
+   - Ensure compliance with relevant regulations (GDPR, HIPAA, PCI-DSS).
+   - Maintain audit logs for critical actions.
+   - Conduct regular security training for the team.
+   - Manage third-party vendor risk.
+
+<%- folderStructure %>
+
+## Security Checklist
+- [ ] Threat model created/updated
+- [ ] SAST/DAST/SCA scanners active in pipeline
+- [ ] No secrets committed to version control
+- [ ] HTTPS/TLS enforced everywhere
+- [ ] MFA enabled for all critical access
+- [ ] Incident Response Plan is accessible

package/dist/src/templates/en/techwriter.md.ejs

@@ -0,0 +1,46 @@
+---
+description: Technical Documentation Workflow
+---
+
+1. **Docs as Code**:
+   - Treat documentation like code (versioning, reviews, testing).
+   - Use Markdown/AsciiDoc for authoring.
+   - Keep documentation close to the code (in repo).
+   - Automate documentation building and publishing.
+
+2. **API Documentation**:
+   - Maintain OpenAPI/Swagger specifications.
+   - Ensure accuracy of request/response examples.
+   - Document error codes and authentication flows.
+   - Use tools like Swagger UI, Redoc, or Slate.
+
+3. **User Guides & Tutorials**:
+   - Create step-by-step guides for common tasks.
+   - Write clear and concise conceptual overviews.
+   - Include code snippets and real-world examples.
+   - Maintain a glossary of terms.
+
+4. **Release Notes**:
+   - Curate changelogs for each release.
+   - Highlight breaking changes, new features, and bug fixes.
+   - Communicate impacted areas clearly.
+
+5. **Architecture & Decisions**:
+   - Help engineers document ADRs (Architecture Decision Records).
+   - Maintain high-level system diagrams.
+   - Document data flows and integration points.
+
+6. **Style Guide & Governance**:
+   - Establish and enforce a writing style guide (e.g., Google Developer Documentation Style Guide).
+   - Review docs for clarity, tone, and consistency.
+   - Manage terminology and trademarks.
+
+<%- folderStructure %>
+
+## Tech Writer Checklist
+- [ ] Docs build successfully
+- [ ] API specs match implementation
+- [ ] No broken links
+- [ ] Breaking changes documented
+- [ ] Release notes prepared
+- [ ] Grammar and spell check passed

package/dist/src/templates/fr/architect.md.ejs

@@ -0,0 +1,15 @@
+---
+description: Workflow d'Architecture et Design Système
+---
+1. **Analyse des Besoins Non-Fonctionnels** :
+   - Évaluer la performance, la sécurité, la maintenabilité et la scalabilité.
+2. **Design Système** :
+   - Proposer une architecture (ex: Hexagonale, Microservices).
+   - Définir les interactions entre composants.
+3. **Choix Technologiques** :
+   - Sélectionner les outils adaptés.
+   - Justifier les choix (ADR - Architecture Decision Records).
+4. **Validation** :
+   - Vérifier la faisabilité avec le Lead Dev.
+
+<%- folderStructure %>

package/dist/src/templates/fr/ba.md.ejs

@@ -0,0 +1,11 @@
+---
+description: Workflow Business Analyst (Spécifications Détaillées)
+---
+1. **Recueil du Besoin** :
+   - Clarifier les règles de gestion complexes.
+   - Modéliser les données et les flux.
+2. **Rédaction des Spécifications** :
+   - Produire des documents détaillés.
+   - Faire le lien entre le PO et l'équipe technique.
+3. **Support** :
+   - Répondre aux questions fonctionnelles durant le sprint.

package/dist/src/templates/fr/data.md.ejs

@@ -0,0 +1,47 @@
+---
+description: Workflow Data Engineering & Analytics
+---
+
+1. **Modélisation des Données** :
+   - Concevez des schémas efficaces pour les entrepôts de données (Schéma en étoile/flocon).
+   - Définissez rigoureusement les types de données et les contraintes.
+   - Documentez les relations entre entités et le lignage (lineage).
+   - Optimisez pour la performance des requêtes (partitionnement, indexation).
+
+2. **Pipelines ETL/ELT** :
+   - Construisez des pipelines d'ingestion robustes (Airflow, Dagster, Prefect).
+   - Assurez l'idempotence et la tolérance aux pannes.
+   - Surveillez la fraîcheur et le volume des données.
+   - Gérez l'évolution des schémas proprement.
+
+3. **Qualité des Données & Gouvernance** :
+   - Implémentez des contrôles de qualité (Great Expectations, dbt tests).
+   - Surveillez les valeurs nulles, les doublons et les anomalies.
+   - Gérez l'accès aux données sensibles et PII (masquage, tokenisation).
+   - Cataloguez les actifs de données pour la découvrabilité.
+
+4. **Infrastructure & Stockage** :
+   - Gérez l'infrastructure Data Lake/Warehouse (Snowflake, BigQuery, S3).
+   - Optimisez les coûts de stockage et les politiques de cycle de vie.
+   - Configurez les contrôles d'accès et le réseau.
+
+5. **Logique de Transformation** :
+   - Utilisez dbt pour des transformations SQL modulaires.
+   - Versionnez toute la logique de transformation.
+   - Revoyez les requêtes SQL complexes pour la performance.
+   - Documentez la logique métier au sein du code.
+
+6. **Support Reporting & Analytics** :
+   - Créez des vues propres et agrégées pour les outils BI (Tableau, Looker, PowerBI).
+   - Collaborez avec les analystes pour définir les métriques.
+   - Assurez la cohérence des données entre les rapports.
+
+<%- folderStructure %>
+
+## Checklist Data Engineer
+- [ ] Les modèles de données sont documentés
+- [ ] Les pipelines sont idempotents et surveillés
+- [ ] Les tests de qualité de données passent
+- [ ] Les PII sont traitées correctement
+- [ ] Les transformations sont testées (dbt test)
+- [ ] Le lignage des données est clair

package/dist/src/templates/fr/dev.md.ejs

@@ -0,0 +1,11 @@
+---
+description: Workflow de développement standard
+---
+
+1. **Compréhension** : Analyser la demande de l'utilisateur et les fichiers concernés. 2.
+**Implémentation** : - Créer ou modifier le code source. - Si nécessaire, créer des tests unitaires
+avant (TDD). 3. **Vérification** : - Exécuter `<%= buildCommand %>` pour vérifier la compilation. -
+Exécuter `<%= testCommand %>` pour les tests unitaires. - Exécuter `npm run lint` ou équivalent pour
+le style. 4. **Commit** : - Si tout est vert, proposer un commit suivant la convention :
+`feat(scope): description`. 5. **Boucle** : - Demander à l'utilisateur s'il y a d'autres tâches ou
+si la feature est terminée. - Si terminée, proposer de créer une Pull Request.

package/dist/src/templates/fr/devops.md.ejs

@@ -0,0 +1,54 @@
+---
+description: Workflow DevOps & Infrastructure
+---
+
+1. **Infrastructure as Code (IaC)** :
+   - Définissez toute l'infrastructure sous forme de code (Terraform, Pulumi, CloudFormation).
+   - Versionnez vos configurations d'infrastructure.
+   - Sécurisez les fichiers d'état (remote state avec verrouillage).
+   - Utilisez des composants d'infrastructure modulaires et réutilisables.
+
+2. **Pipelines CI/CD** :
+   - Assurez des pipelines de build rapides et fiables (<%= buildCommand %>).
+   - Implémentez des tests automatisés (unitaires, intégration, e2e) dans la CI (<%= testCommand %>).
+   - Gérez les artefacts de build (images Docker, paquets).
+   - Déployez par étapes (Dev -> Staging -> Prod).
+
+3. **Conteneurisation & Orchestration** :
+   - Créez des Dockerfiles optimisés et sécurisés (builds multi-stage).
+   - Gérez l'orchestration des conteneurs (Kubernetes, Docker Swarm).
+   - Définissez les limites et requêtes de ressources.
+   - Assurez une gestion propre des secrets (Vault, K8s Secrets).
+
+4. **Observabilité & Monitoring** :
+   - Mettez en place une journalisation centralisée (ELK, Splunk, CloudWatch).
+   - Configurez la collecte de métriques (Prometheus, Grafana).
+   - Implémentez le traçage distribué (Jaeger, Zipkin, OpenTelemetry).
+   - Définissez des alertes actionnables pour les incidents critiques.
+
+5. **Sécurité & Conformité (DevSecOps)** :
+   - Intégrez le scan de sécurité dans la CI/CD (SAST, DAST, vérification des dépendances).
+   - Automatisez les contrôles de conformité.
+   - Gérez les contrôles d'accès (IAM, RBAC) avec le principe du moindre privilège.
+   - Patchs et mises à jour régulières.
+
+6. **Gestion des Releases** :
+   - Définissez une stratégie de versioning (Semantic Versioning).
+   - Implémentez des stratégies de déploiement (Blue/Green, Canary, Rolling).
+   - Automatisez les procédures de rollback.
+   - Maintenez des notes de version et des changelogs.
+
+7. **Reprise après Sinistre (DRP) & Sauvegarde** :
+   - Implémentez des stratégies de sauvegarde automatisées pour les bases de données et l'état.
+   - Testez régulièrement les procédures de restauration.
+   - Définissez des configurations de haute disponibilité et de basculement.
+
+<%- folderStructure %>
+
+## Checklist DevOps
+- [ ] Le code d'infrastructure est versionné
+- [ ] Le pipeline CI/CD est actif et vert
+- [ ] Les secrets sont gérés de manière sécurisée hors du repo
+- [ ] Les tableaux de bord de monitoring sont accessibles
+- [ ] Les sauvegardes sont configurées et testées
+- [ ] L'immuabilité des déploiements est appliquée

package/dist/src/templates/fr/fragments/arch/feature-sliced.md.ejs

@@ -0,0 +1,12 @@
+### Structure de Dossiers Proposée (Feature-Sliced Design)
+
+```
+src/
+├── app/                   # Paramètres globaux, styles, providers
+├── processes/             # Scénarios complexes inter-pages (Auth, Paiement)
+├── pages/                 # Pages complètes (Routage)
+├── widgets/               # Composition de features/entités
+├── features/              # Interactions utilisateur (Ajout Panier, Connexion)
+├── entities/              # Entités métier (User, Produit)
+└── shared/                # Code réutilisable (UI Kit, libs)
+```

package/dist/src/templates/fr/fragments/arch/hexagonal.md.ejs

@@ -0,0 +1,14 @@
+### Structure de Dossiers Proposée (Architecture Hexagonale / Clean)
+
+```
+src/
+├── core/                  # Couche Domaine & Application (Pure TS/JS, Pas de dépendances externes)
+│   ├── entities/          # Logique Métier & Types
+│   ├── interfaces/        # Ports (Interfaces pour Repositories, Services)
+│   └── use-cases/         # Règles de Gestion Applicatives
+├── adapters/              # Couche Infrastructure
+│   ├── persistence/       # Implémentations Base de Données (TypeORM, Prisma...)
+│   ├── api/               # APIs Externes (Stripe, formatting...)
+│   └── ui/                # Présentateurs / Adaptateurs CLI
+└── infrastructure/        # Configuration Framework (Modules NestJS, Setup Express)
+```

package/dist/src/templates/fr/fragments/arch/mvc.md.ejs

@@ -0,0 +1,11 @@
+### Structure de Dossiers Proposée (MVC / En Couches)
+
+```
+src/
+├── controllers/           # Gestion des requêtes entrantes (Routage)
+├── models/                # Modèles de Données & Schémas
+├── services/              # Logique Métier
+├── views/                 # Templates UI (si applicable)
+├── utils/                 # Fonctions utilitaires
+└── config/                # Configuration & Variables d'environnement
+```

package/dist/src/templates/fr/fragments/aspnet-core.md.ejs

@@ -0,0 +1,11 @@
+### Standards ASP.NET Core
+
+- **Injection de Dépendances**: Utiliser le conteneur DI intégré pour les services et repositories.
+- **Async/Await**: Utiliser le modèle de programmation asynchrone pour toutes les opérations E/S.
+- **Types Nullables**: Activer et respecter `<Nullable>enable</Nullable>`.
+- **Structure de Dossiers**:
+    - `Controllers/`: Points de terminaison API.
+    - `Services/`: Logique métier.
+    - `Repositories/`: Accès aux données.
+    - `Models/`: Entités du domaine et DTOs.
+    - `Program.cs`: Configuration et démarrage.

package/dist/src/templates/fr/fragments/flutter.md.ejs

@@ -0,0 +1,11 @@
+### Standards Flutter
+
+- **Gestion d'État**: Définir clairement la solution de gestion d'état (Provider, Riverpod, BLoC).
+- **Widgets**: Découper l'UI en widgets petits et réutilisables.
+- **Null Safety**: Respect strict des règles de null safety.
+- **Structure de Dossiers**:
+    - `lib/main.dart`: Point d'entrée.
+    - `lib/src/`: Code d'implémentation privé.
+    - `lib/widgets/`: Composants réutilisables.
+    - `lib/screens/` ou `lib/pages/`: Vues de l'application.
+    - `lib/models/`: Modèles de données.

package/dist/src/templates/fr/fragments/rigor/legacy.md.ejs

@@ -0,0 +1,6 @@
+### 🛡️ Règles de Refactoring Legacy
+- **Tests de Caractérisation**: Avant de modifier le code, écrivez des tests qui capturent le comportement actuel (y compris les bugs).
+- **Stratégie**: Utilisez le modèle "Etranglement" (Strangler Fig) pour les réécritures majeures. Appliquez la règle du "Boy Scout" (nettoyez ce que vous touchez).
+- **Couverture de Code**: Ne visez pas 100% sur l'ancien code. Concentrez-vous sur le *nouveau* code et le code *modifié*.
+- **Dette Technique**: Marquez les problèmes connus avec `// TODO: [Legacy]`. Ne corrigez pas tout d'un coup.
+- **Types**: Utilisez `any` si nécessaire, mais créez des interfaces pour les frontières du système.

package/dist/src/templates/fr/fragments/rigor/prototype.md.ejs

@@ -0,0 +1,6 @@
+### 🚀 Mode Rigueur Prototype
+
+- **Vitesse d'abord**: Focus sur la livraison de fonctionnalités et la validation d'hypothèses.
+- **Tests**: Tests du chemin critique uniquement. TDD optionnel.
+- **Dette Technique**: Autorisée, mais doit être marquée `// TODO: [Refactor]`.
+- **Typage**: `any` toléré pour le prototypage rapide.

package/dist/src/templates/fr/fragments/rigor/strict.md.ejs

@@ -0,0 +1,7 @@
+### 🛡️ Mode Rigueur Strict
+
+- **Test Driven Development (TDD)**: Obligatoire. Écrire le test avant le code.
+- **Couverture**: Maintenir 100% de couverture de code.
+- **Typage**: Pas de `any`. Configuration TypeScript stricte activée.
+- **Revue de Code**: 2 approbations requises. Pas d'auto-merge.
+- **Documentation**: Toutes les APIs publiques doivent avoir une JSDoc/TSDoc.

package/dist/src/templates/fr/fragments/rust.md.ejs

@@ -0,0 +1,10 @@
+### Standards de Développement Rust
+
+- **Chaîne d'outils**: Utilisez `cargo` pour la gestion des dépendances, la compilation et les tests.
+- **Formatage**: Appliquez `cargo fmt` (rustfmt) pour un style de code cohérent.
+- **Linting**: Utilisez `cargo clippy` et corrigez tous les avertissements.
+- **Gestion des Erreurs**: Utilisez explicitement les types `Result` et `Option`. Évitez `unwrap()` et `expect()` en production ; préférez la propagation `?` ou le pattern matching.
+- **Documentation**: Écrivez des commentaires de documentation `///` pour toutes les API publiques.
+- **Tests**:
+    - Tests unitaires dans le même fichier module `#[cfg(test)] mod tests { ... }`.
+    - Tests d'intégration dans le dossier `tests/`.

package/dist/src/templates/fr/fragments/scrypto.md.ejs

@@ -0,0 +1,8 @@
+### 🧩 Guidelines Scrypto (RadixDLT)
+- **Orienté Actifs (Asset-Oriented)**: Traitez les ressources (Tokens, NFTs) comme des citoyens de première classe via `Buckets` et `Vaults`. Évitez les simples mappings de balances.
+- **Blueprints & Components**: Gardez les blueprints modulaires. Utilisez des `functions` pour l'instanciation et des `methods` pour la mutation d'état.
+- **Tests**:
+    - Utilisez `TestEnvironment` pour les tests unitaires (rapide, isolé).
+    - Utilisez `LedgerSimulator` pour les tests d'intégration (basés sur les manifestes).
+    - Exécutez via `cargo test`.
+- **Sécurité**: Utilisez des `Badges` pour l'autorisation (Pattern Actor-Virtual-Badge). Validez tous les mouvements de ressources (retraits/dépôts).

package/dist/src/templates/fr/guide.txt

@@ -0,0 +1,47 @@
+
+  ___       _   _                           _ _               
+ / _ \     | | (_)                         (_) |              
+/ /_\ \_ __| |_ _  __ _ _ __ __ ___   _____| |_ _   _         
+|  _  | '_ \ __| |/ _` | '__/ _` \ \ / / | | __| | | |        
+| | | | | | | |_| | (_| | | | (_| |\ V /| | | | |_| |        
+\_| |_/_| |_|\__|_|\__, |_|  \__,_| \_/ |_|_|  \__, |        
+                   |___/                       |___/         
+
+Bienvenue dans le CLI Antigravity Workflow !
+
+Utilisation :
+  ag-flow [commande]
+
+Commandes :
+  init      Initialise le workflow agentique dans le répertoire actuel.
+            - Détecte automatiquement votre Tech Stack (Node, Rust, Python, ...)
+            - Génère des Règles Agent spécifiques (.agent/rules/coding-standards.md)
+            - Crée des Pipelines CI/CD (.github/workflows/)
+            - Configure des Prompts par Rôle (.agent/workflows/)
+            - Génère .gitignore et Dockerfile optimisés pour votre stack
+
+            Options :
+            --config <path>   Lance l'initialisation depuis un fichier de config (sans prompt)
+
+  guide     Affiche ce message d'aide.
+
+Workflows Générés :
+  Après avoir exécuté 'init', vous trouverez des fichiers markdown dans '.agent/workflows/'.
+  Copiez le contenu de ces fichiers (ex: 'dev.md') dans votre Agent IA (Cursor, Windsurf)
+  pour l'initialiser avec le contexte et les règles de votre projet.
+
+Stacks Supportées :
+  - Frontend : React, Vue, Angular, Flutter
+  - Backend : NestJS, ASP.NET Core, Python, Node.js, Rust
+  - Smart Contracts : Scrypto
+
+Modes de Rigueur :
+  - Strict : Impose le TDD, couverture de tests à 100%, typage strict.
+  - Prototype : Focalisé sur la vitesse et la validation MVP.
+
+Configuration :
+  Vos réglages sont sauvegardés dans '.agent/antigravity.json'.
+  Vous pouvez éditer ce fichier pour ajuster manuellement le contexte.
+
+Besoin d'aide ?
+  Visitez : https://github.com/antigravity/flow