antigravity-flow 1.0.2 → 1.0.3

package/dist/src/templates/en/fragments/anchor.md.ejs

@@ -0,0 +1,4 @@
+## Anchor Standards
+
+- Test with `anchor test`.
+- Use correct seeds for PDA derivation.

package/dist/src/templates/en/fragments/angular.md.ejs

@@ -0,0 +1,5 @@
+## Angular Standards
+
+- Follow the official Angular Style Guide.
+- Use strict mode.
+- Prefer Signals for reactivity (if on recent version).

package/dist/src/templates/en/fragments/astro.md.ejs

@@ -0,0 +1,4 @@
+## Astro Standards
+
+- Use Islands Architecture.
+- Minimize client-side JS.

package/dist/src/templates/en/fragments/elixir.md.ejs

@@ -0,0 +1,4 @@
+## Elixir Standards
+
+- Follow the Elixir Style Guide.
+- Use Pattern Matching and Pipe Operator `|>`.

package/dist/src/templates/en/fragments/express.md.ejs

@@ -0,0 +1,5 @@
+## Express.js Standards
+
+- Separate routes, controllers, and services.
+- Use middleware for cross-cutting concerns (auth, logging).
+- Always return a response (or call next with error).

package/dist/src/templates/en/fragments/fastify.md.ejs

@@ -0,0 +1,4 @@
+## Fastify Standards
+
+- Use schema-based validation.
+- Register plugins asynchronously.

package/dist/src/templates/en/fragments/flask.md.ejs

@@ -0,0 +1,4 @@
+## Flask Standards
+
+- Use Blueprints for modularity.
+- Use Flask-SQLAlchemy for ORM if needed.

package/dist/src/templates/en/fragments/gin.md.ejs

@@ -0,0 +1,4 @@
+## Gin Standards
+
+- Group routes by functionality.
+- Use middleware for common request processing.

package/dist/src/templates/en/fragments/go.md.ejs

@@ -0,0 +1,5 @@
+## Go Standards
+
+- Follow Go Code Review Comments style.
+- Handle all errors explicitly.
+- Use `go fmt` and `go vet`.

package/dist/src/templates/en/fragments/ink.md.ejs

@@ -0,0 +1,4 @@
+## Ink! Standards
+
+- Optimize storage usage.
+- Write comprehensive unit and integration tests.

package/dist/src/templates/en/fragments/move.md.ejs

@@ -0,0 +1,4 @@
+## Move Standards
+
+- Use strict typing and resource handling.
+- Verify ownership and capabilities explicitly.

package/dist/src/templates/en/fragments/node.md.ejs

@@ -0,0 +1,5 @@
+## Node.js Standards
+
+- Use Async/Await for all asynchronous operations.
+- Handle errors gracefully with try/catch.
+- Validate inputs early.

package/dist/src/templates/en/fragments/nuxtjs.md.ejs

@@ -0,0 +1,4 @@
+## Nuxt.js Standards
+
+- Use standard Nuxt directory structure.
+- Leverage auto-imports where appropriate.

package/dist/src/templates/en/fragments/python.md.ejs

@@ -0,0 +1,5 @@
+## Python Standards
+
+- Follow PEP 8 style guide.
+- Use type hints for all function signatures.
+- Use virtual environments for dependency management.

package/dist/src/templates/en/fragments/remix.md.ejs

@@ -0,0 +1,4 @@
+## Remix Standards
+
+- Use Loaders and Actions for data.
+- Progressive enhancement is key.

package/dist/src/templates/en/fragments/rigor/standard.md.ejs

@@ -0,0 +1,5 @@
+## Standard Rigor
+
+- **Testing**: Maintain good test coverage (e.g., 60-80%). Unit tests for logic, integration tests for API.
+- **Linting**: Use standard linting rules (e.g., ESLint recommended).
+- **Code Review**: Required for all PRs.

package/dist/src/templates/en/fragments/svelte.md.ejs

@@ -0,0 +1,4 @@
+## Svelte Standards
+
+- Keep stores simple.
+- Use reactive statements `$:` wisely.

package/dist/src/templates/en/fragments/sveltekit.md.ejs

@@ -0,0 +1,4 @@
+## SvelteKit Standards
+
+- Use standard routing conventions.
+- Use SSR capabilities effectively.

package/dist/src/templates/en/fragments/vue.md.ejs

@@ -0,0 +1,5 @@
+## Vue.js Standards
+
+- Use Composition API with `<script setup>`.
+- Keep components small and focused.
+- Use Pinia for state management.

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

@@ -0,0 +1,2 @@
+## Standards Anchor
+- Tests avec `anchor test`.

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

@@ -0,0 +1,4 @@
+## Angular Standards
+
+- Suivre le Style Guide officiel.
+- Mode Strict activé.

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

@@ -0,0 +1,2 @@
+## Standards Astro
+- Islands Architecture.

package/dist/src/templates/fr/fragments/base-rules.md.ejs

@@ -0,0 +1,5 @@
+## Standards de Code Principaux
+
+1.  **Principes SOLID**: Adhérez à la Responsabilité Unique, Ouvert/Fermé, Substitution de Liskov, Ségrégation des Interfaces et Inversion de Dépendance.
+2.  **Clean Code**: Écrivez du code facile à lire, comprendre et maintenir. Utilisez des noms significatifs.
+3.  **DRY (Don't Repeat Yourself)**: Évitez la duplication. Extrayez la logique commune dans des fonctions ou composants réutilisables.

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

@@ -0,0 +1,12 @@
+## Règles Spécifiques Django
+
+1.  **Structure du Projet**: Organisez les apps par domaine/fonctionnalité, pas par type.
+2.  **Modèles (Models)**: Gardez les modèles légers, utilisez des managers pour les requêtes complexes.
+3.  **Vues (Views)**: Préférez les vues basées sur des classes (CBV) pour la réutilisabilité.
+4.  **Formulaires**: Utilisez les formulaires Django pour la validation, ModelForms pour le CRUD.
+5.  **Migrations**: Révisez toujours les migrations générées avant de les appliquer.
+6.  **Signaux**: Évitez les signaux pour la logique métier, utilisez des appels de service explicites.
+7.  **Templates**: Minimisez la logique dans les templates, utilisez des template tags.
+8.  **Configuration**: Utilisez django-environ ou similaire pour la configuration de l'environnement.
+9.  **Sécurité**: Activez CSRF, utilisez le middleware de sécurité de Django.
+10. **Tests**: Utilisez pytest-django pour les tests, factory_boy pour les fixtures.

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

@@ -0,0 +1,2 @@
+## Standards Elixir
+- Opérateur Pipe `|>`.

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

@@ -0,0 +1,4 @@
+## Express.js Standards
+
+- Séparer routes, controllers, services.
+- Middleware pour auth/logs.

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

@@ -0,0 +1,11 @@
+## Règles Spécifiques FastAPI
+
+1.  **Modèles Pydantic**: Utilisez Pydantic pour la validation et sérialisation requête/réponse.
+2.  **Injection de Dépendance**: Utilisez `Depends()` pour l'injection de dépendances.
+3.  **Async**: Utilisez `async def` pour les opérations liées aux E/S.
+4.  **Type Hints**: Utilisez toujours les indications de type pour les paramètres et retours.
+5.  **Routeurs**: Organisez les endpoints dans des modules APIRouter par domaine.
+6.  **Tâches de Fond**: Utilisez BackgroundTasks pour les opérations asynchrones.
+7.  **Gestion d'Erreurs**: Utilisez HTTPException pour les erreurs API avec codes statut appropriés.
+8.  **Configuration**: Utilisez pydantic-settings pour la gestion de la configuration.
+9.  **Middleware**: Utilisez des middlewares pour CORS, logging, et traçage de requêtes.

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

@@ -0,0 +1,2 @@
+## Standards Fastify
+- Validation schema-based.

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

@@ -0,0 +1,2 @@
+## Standards Flask
+- Blueprints pour la modularité.

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

@@ -0,0 +1,2 @@
+## Standards Gin
+- Groupement des routes.

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

@@ -0,0 +1,4 @@
+## Go Standards
+
+- Suivre le style Go Code Review.
+- Gérer les erreurs explicitement.

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

@@ -0,0 +1,2 @@
+## Standards Ink!
+- Optimisation stockage.

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

@@ -0,0 +1,3 @@
+## Standards Move
+
+- Typage strict et gestion des ressources.

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

@@ -0,0 +1,5 @@
+## Règles Spécifiques NestJS
+
+1.  **Injection de Dépendance**: Utilisez toujours l'ID pour les dépendances de service.
+2.  **Modules**: Organisez le code en modules par fonctionnalité (ex: `AuthModule`, `UserModule`).
+3.  **DTOs**: Utilisez des DTOs pour la validation des données avec `class-validator`.

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

@@ -0,0 +1,10 @@
+## Règles Spécifiques Next.js
+
+1.  **App Router**: Utilisez le App Router (app/) pour les nouveaux projets.
+2.  **Server Components**: Utilisez les Server Components par défaut. Ajoutez `'use client'` seulement si nécessaire.
+3.  **Récupération de Données**: Utilisez `fetch()` avec stratégies de cache, pas `getServerSideProps`.
+4.  **Routes API**: Utilisez les Route Handlers (app/api/) pour la logique côté serveur.
+5.  **Métadonnées**: Utilisez l'API Metadata pour le SEO.
+6.  **Optimisation Image**: Utilisez toujours `next/image` pour les images.
+7.  **Variables d'Environnement**: Utilisez le préfixe `NEXT_PUBLIC_` uniquement pour les variables exposées au client.
+8.  **Middleware**: Utilisez middleware.ts pour l'authentification et les redirections.

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

@@ -0,0 +1,4 @@
+## Node.js Standards
+
+- Async/Await pour l'asynchrone.
+- Gestion d'erreurs try/catch.

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

@@ -0,0 +1,2 @@
+## Standards Nuxt.js
+- Structure standard Nuxt.

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

@@ -0,0 +1,4 @@
+## Python Standards
+
+- Suivre PEP 8.
+- Type hints obligatoires.

package/dist/src/templates/fr/fragments/react-native.md.ejs

@@ -0,0 +1,12 @@
+## Règles Spécifiques React Native
+
+1.  **Navigation**: Utilisez React Navigation pour le routage.
+2.  **Gestion d'État**: Utilisez React Query pour l'état serveur, Zustand/Redux pour l'état client.
+3.  **Style**: Utilisez StyleSheet.create() pour la performance, envisagez NativeWind.
+4.  **Modules Natifs**: Minimisez le code natif, utilisez les modules Expo quand c'est possible.
+5.  **Performance**: Utilisez FlatList pour les longues listes, évitez les fonctions anonymes dans le render.
+6.  **Spécifique Plateforme**: Utilisez Platform.select() pour le code spécifique à la plateforme.
+7.  **Assets**: Optimisez les images pour mobile, utilisez les résolutions appropriées.
+8.  **Tests**: Utilisez React Native Testing Library, Detox pour l'E2E.
+9.  **Mises à jour OTA**: Utilisez EAS Update pour les mises à jour "Over-The-Air".
+10. **Deep Linking**: Configurez le deep linking pour la navigation depuis des sources externes.

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

@@ -0,0 +1,5 @@
+## Règles Spécifiques React
+
+1.  **Composants Fonctionnels**: Utilisez des composants fonctionnels avec Hooks. Évitez les composants de classe.
+2.  **Hooks Personnalisés**: Extrayez la logique complexe dans des hooks personnalisés (ex: `useAuth`).
+3.  **Structure Composant**: Gardez les composants petits et ciblés. Un composant par fichier.

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

@@ -0,0 +1,2 @@
+## Standards Remix
+- Loaders et Actions.

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

@@ -1,6 +1,2 @@
-### 🛡️ 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.
+## Mode Legacy
+- Maintenir le code existant.

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

@@ -1,6 +1,2 @@
-### 🚀 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.
+## Mode Prototype
+- Vitesse > Perfection.

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

@@ -0,0 +1,5 @@
+## Rigueur Standard
+
+- **Tests**: Maintenez une bonne couverture (60-80%). Tests unitaires et intégration.
+- **Linting**: Utilisez les règles standards (ex: ESLint recommandé).
+- **Code Review**: Requis pour toute PR.

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

@@ -1,7 +1 @@
-### 🛡️ 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.
+## Mode Strict- 100% Coverage.

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

@@ -0,0 +1,20 @@
+## Règles Spécifiques Solidity
+
+1.  **Pragma Version**: Spécifiez toujours une version ou plage Solidity spécifique.
+2.  **Visibilité**: Déclarez explicitement la visibilité des fonctions (public, external, internal, private).
+3.  **Réentrance**: Suivez le modèle CEI (Checks-Effects-Interactions) pour prévenir la réentrance.
+4.  **Optimisation Gas**: Minimisez les écritures en stockage, utilisez `memory` pour les données temporaires.
+5.  **Événements**: Émettez des événements pour tous les changements d'état (pour indexing off-chain).
+6.  **Contrôle d'Accès**: Utilisez Ownable ou AccessControl d'OpenZeppelin.
+7.  **Gestion d'Erreurs**: Utilisez des erreurs personnalisées au lieu de chaînes require pour l'efficacité gas.
+8.  **Tests**: Utilisez Foundry ou Hardhat pour des tests complets.
+9.  **Mise à niveau**: Utilisez des patterns proxy (UUPS, Transparent) si mise à niveau prévue.
+10. **Audit**: Tous les contrats doivent être audités avant déploiement mainnet.
+
+### Checklist Sécurité
+- [ ] Gardes anti-réentrance implémentés
+- [ ] Overflow/underflow entiers gérés (Solidity 0.8+)
+- [ ] Contrôle d'accès vérifié
+- [ ] Risques d'appels externes évalués
+- [ ] Vecteurs d'attaque Flash loan considérés
+- [ ] Mitigations Front-running en place

package/dist/src/templates/fr/fragments/spring-boot.md.ejs

@@ -0,0 +1,13 @@
+## Règles Spécifiques Spring Boot
+
+1.  **Structure du Projet**: Organisez par fonctionnalité/domaine, pas par couche technique.
+2.  **Injection de Dépendance**: Utilisez l'injection par constructeur, évitez l'injection par champ.
+3.  **Configuration**: Utilisez application.yml avec des profils pour les environnements.
+4.  **Contrôleurs REST**: Utilisez @RestController avec méthodes HTTP et codes statut appropriés.
+5.  **Couche Service**: Gardez la logique métier dans les classes @Service.
+6.  **Repository**: Utilisez les repositories Spring Data JPA, requêtes personnalisées dans @Query.
+7.  **Validation**: Utilisez @Valid et les annotations Bean Validation.
+8.  **Gestion d'Exception**: Utilisez @ControllerAdvice pour la gestion globale des exceptions.
+9.  **Sécurité**: Utilisez Spring Security pour l'authentification et l'autorisation.
+10. **Tests**: Utilisez @SpringBootTest pour l'intégration, @WebMvcTest pour les contrôleurs.
+11. **Actuator**: Activez les endpoints health et metrics pour l'observabilité.

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

@@ -0,0 +1,2 @@
+## Standards Svelte
+- Stores simples.

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

@@ -0,0 +1,2 @@
+## Standards SvelteKit
+- Routing standard.

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

@@ -0,0 +1,5 @@
+## Vue.js Standards
+
+- Utilize Composition API et `<script setup>`.
+- Composants petits et ciblés.
+- Pinia pour le state management.

package/dist/tests/core/Debug.spec.js

@@ -0,0 +1,6 @@
+"use strict";
+describe('Debug Test', () => {
+    it('should run this test', () => {
+        expect(true).toBe(true);
+    });
+});

package/dist/tests/core/TemplateIntegrity.spec.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const types_1 = require("../../src/core/types");
+describe('Template Integrity', () => {
+    const srcTemplatesDir = path.resolve(__dirname, '../../src/templates');
+    console.log('Templates Directory:', srcTemplatesDir);
+    const languages = ['en', 'fr'];
+    const checkFileExists = (lang, relativePath) => {
+        const fullPath = path.join(srcTemplatesDir, lang, relativePath);
+        if (!fs.existsSync(fullPath)) {
+            throw new Error(`Missing template file: ${lang}/${relativePath}`);
+        }
+    };
+    languages.forEach((lang) => {
+        describe(`Language: ${lang}`, () => {
+            it('should have base rules fragment', () => {
+                checkFileExists(lang, 'fragments/base-rules.md.ejs');
+            });
+            it('should have all rigor mode fragments', () => {
+                Object.values(types_1.RigorMode).forEach((mode) => {
+                    // RigorMode doesn't have NONE
+                    checkFileExists(lang, `fragments/rigor/${mode}.md.ejs`);
+                });
+            });
+            it('should have all frontend framework fragments', () => {
+                Object.values(types_1.FrontendFramework).forEach((fw) => {
+                    if (fw !== types_1.FrontendFramework.NONE) {
+                        checkFileExists(lang, `fragments/${fw}.md.ejs`);
+                    }
+                });
+            });
+            it('should have all backend framework fragments', () => {
+                Object.values(types_1.BackendFramework).forEach((fw) => {
+                    if (fw !== types_1.BackendFramework.NONE) {
+                        checkFileExists(lang, `fragments/${fw}.md.ejs`);
+                    }
+                });
+            });
+            it('should have all smart contract framework fragments', () => {
+                Object.values(types_1.SmartContractFramework).forEach((fw) => {
+                    if (fw !== types_1.SmartContractFramework.NONE) {
+                        checkFileExists(lang, `fragments/${fw}.md.ejs`);
+                    }
+                });
+            });
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antigravity-flow",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Universal AI Context Generator & Workflow CLI for Cursor, Windsurf, and Antigravity.",
   "main": "dist/src/core/index.js",
   "bin": {