antigravity-flow 1.0.0

package/dist/src/locales/fr.json

@@ -0,0 +1,293 @@
+{
+  "prompts": {
+    "welcome": "Bienvenue dans l'initialisation Antigravity Workflow !",
+    "intro": "Cet outil va vous aider à générer les workflows agents pour votre projet.\n",
+    "language_selection": "Select language / Choisissez votre langue",
+    "project_name": "Nom du projet :",
+    "project_description": "Description du projet :",
+    "build_command": "Quelle est votre commande de build ?",
+    "test_command": "Quelle est votre commande de test ?",
+    "lint_command": "Quelle est votre commande de lint ?",
+    "format_command": "Quelle est votre commande de formatage ?",
+    "workflows_selection": "Quels workflows souhaitez-vous générer ?",
+    "confirm": "Prêt à générer les fichiers ?",
+    "cancelled": "Opération annulée.",
+    "success": "Workflows générés avec succès !",
+    "failed": "Échec de l'initialisation.",
+    "frontend": "Framework Frontend :",
+    "backend": "Framework Backend :",
+    "mobile": "Framework Mobile (si applicable) :",
+    "smart_contract": "Framework Smart Contract :",
+    "architecture": "Pattern d'Architecture :",
+    "rigor": "Niveau de Rigueur :",
+    "rigor_hint": "Strict=TDD+couverture élevée, Standard=équilibré, Prototype=vitesse, Legacy=refactoring prudent",
+    "is_monorepo": "Est-ce un Monorepo ?",
+    "monorepo_apps": "Listez vos applications (séparées par des virgules) :",
+    "monorepo_tool": "Quel outil monorepo utilisez-vous ?",
+    "ide_integration": "Avec quels IDEs IA souhaitez-vous intégrer ?",
+    "version_control": "Plateforme de gestion de version :",
+    "branching_strategy": "Stratégie de branching :",
+    "commit_convention": "Convention de messages de commit :",
+    "package_manager": "Gestionnaire de paquets :",
+    "database": "Technologie de base de données :",
+    "orm": "ORM/ODM :",
+    "testing_framework": "Framework de test :",
+    "coverage_target": "Couverture de test cible :",
+    "deployment_platform": "Plateforme de déploiement :",
+    "containerization": "Conteneurisation :",
+    "environments": "Environnements (séparés par des virgules, ex: dev,staging,prod) :",
+    "security_scanning": "Outils d'analyse de sécurité :",
+    "documentation_style": "Style de documentation :",
+    "linting_tools": "Outils de Linting & Formatage :",
+    "pr_approvals": "Combien d'approbations PR sont requises ?",
+    "pre_commit_hooks": "Activer les pre-commit hooks ?",
+    "block_merge_failing": "Bloquer le merge sur les checks en échec ?",
+    "interface_prefix": "Convention de préfixe d'interface (ex: I pour IUserService) :",
+    "repository_pattern": "Pattern de repository :"
+  },
+  "roles": {
+    "dev": "Développeur (Boucle Standard)",
+    "qa": "QA (Test & Qualité)",
+    "lead": "Lead Développeur (Standards)",
+    "architect": "Architecte (Conception & Décisions)",
+    "po": "Product Owner (Backlog)",
+    "ba": "Business Analyst (Specs)",
+    "devops": "DevOps (CI/CD & Infrastructure)",
+    "security": "Ingénieur Sécurité (Audits & Conformité)",
+    "techwriter": "Rédacteur Technique (Documentation)",
+    "data": "Data Engineer (Pipelines & Analytics)",
+    "rules": "Règles Agent (.agent/rules)"
+  },
+  "frameworks": {
+    "frontend": {
+      "react": "React",
+      "nextjs": "Next.js (React SSR/SSG)",
+      "vue": "Vue.js",
+      "nuxtjs": "Nuxt.js (Vue SSR/SSG)",
+      "angular": "Angular",
+      "svelte": "Svelte",
+      "sveltekit": "SvelteKit",
+      "remix": "Remix",
+      "astro": "Astro",
+      "flutter": "Flutter (Web)",
+      "react-native": "React Native (Web)",
+      "none": "Aucun"
+    },
+    "backend": {
+      "node": "Node.js (Simple)",
+      "nestjs": "NestJS",
+      "express": "Express.js",
+      "fastify": "Fastify",
+      "python": "Python (Simple)",
+      "fastapi": "FastAPI",
+      "django": "Django",
+      "flask": "Flask",
+      "aspnet-core": "ASP.NET Core",
+      "spring-boot": "Spring Boot (Java)",
+      "go": "Go (Simple)",
+      "gin": "Gin (Go)",
+      "rust": "Rust",
+      "elixir": "Elixir/Phoenix",
+      "none": "Aucun"
+    },
+    "mobile": {
+      "flutter": "Flutter",
+      "react-native": "React Native",
+      "swift": "Swift/SwiftUI (iOS)",
+      "kotlin": "Kotlin (Android)",
+      "none": "Aucun"
+    },
+    "smartContract": {
+      "scrypto": "Scrypto (Radix)",
+      "solidity": "Solidity (Ethereum/EVM)",
+      "move": "Move (Sui/Aptos)",
+      "anchor": "Anchor (Solana)",
+      "ink": "ink! (Polkadot)",
+      "none": "Aucun"
+    }
+  },
+  "options": {
+    "architecture": {
+      "hexagonal": "Hexagonal (Ports & Adaptateurs)",
+      "clean": "Clean Architecture",
+      "mvc": "MVC (Modèle-Vue-Contrôleur)",
+      "feature-sliced": "Feature-Sliced Design (FSD)",
+      "vertical-slice": "Vertical Slice",
+      "layered": "En couches (N-Tiers)",
+      "microservices": "Microservices",
+      "none": "Aucun / Personnalisé"
+    },
+    "rigor": {
+      "strict": "Strict (TDD, 100% couverture, pas de any)",
+      "standard": "Standard (Bonnes pratiques, 80% couverture)",
+      "prototype": "Prototype (Vitesse d'abord, tests minimaux)",
+      "legacy": "Legacy (Refactoring prudent)"
+    },
+    "versionControl": {
+      "github": "GitHub",
+      "gitlab": "GitLab",
+      "azure-devops": "Azure DevOps",
+      "bitbucket": "Bitbucket",
+      "none": "Aucun / Auto-hébergé"
+    },
+    "branching": {
+      "gitflow": "GitFlow",
+      "github-flow": "GitHub Flow",
+      "trunk-based": "Trunk-Based Development",
+      "gitlab-flow": "GitLab Flow",
+      "custom": "Personnalisé"
+    },
+    "commit": {
+      "conventional": "Conventional Commits (feat, fix, chore...)",
+      "gitmoji": "Gitmoji (🎉 ✨ 🐛...)",
+      "angular": "Convention Angular",
+      "semantic": "Versioning Sémantique",
+      "custom": "Personnalisé",
+      "none": "Aucun"
+    },
+    "packageManager": {
+      "npm": "npm",
+      "yarn": "Yarn",
+      "pnpm": "pnpm",
+      "bun": "Bun",
+      "pip": "pip",
+      "poetry": "Poetry",
+      "uv": "uv",
+      "cargo": "Cargo",
+      "nuget": "NuGet",
+      "maven": "Maven",
+      "gradle": "Gradle",
+      "go-modules": "Go Modules",
+      "none": "Aucun"
+    },
+    "database": {
+      "postgresql": "PostgreSQL",
+      "mysql": "MySQL",
+      "mariadb": "MariaDB",
+      "sqlserver": "SQL Server",
+      "oracle": "Oracle Database",
+      "mongodb": "MongoDB",
+      "sqlite": "SQLite",
+      "supabase": "Supabase",
+      "firebase": "Firebase/Firestore",
+      "dynamodb": "DynamoDB",
+      "redis": "Redis",
+      "cassandra": "Cassandra",
+      "cockroachdb": "CockroachDB",
+      "planetscale": "PlanetScale",
+      "neon": "Neon",
+      "none": "Aucun"
+    },
+    "orm": {
+      "typeorm": "TypeORM",
+      "prisma": "Prisma",
+      "mikroorm": "MikroORM",
+      "drizzle": "Drizzle",
+      "sequelize": "Sequelize",
+      "knex": "Knex.js",
+      "mongoose": "Mongoose",
+      "sqlalchemy": "SQLAlchemy",
+      "django-orm": "Django ORM",
+      "entity-framework": "Entity Framework",
+      "dapper": "Dapper",
+      "gorm": "GORM (Go)",
+      "diesel": "Diesel (Rust)",
+      "ecto": "Ecto (Elixir)",
+      "none": "Aucun"
+    },
+    "testing": {
+      "jest": "Jest",
+      "vitest": "Vitest",
+      "mocha": "Mocha",
+      "playwright": "Playwright",
+      "cypress": "Cypress",
+      "testing-library": "Testing Library",
+      "pytest": "pytest",
+      "unittest": "unittest",
+      "xunit": "xUnit",
+      "nunit": "NUnit",
+      "junit": "JUnit",
+      "go-test": "Go Test",
+      "rust-test": "Rust cargo test",
+      "exunit": "ExUnit (Elixir)",
+      "none": "Aucun"
+    },
+    "coverage": {
+      "100": "100% (Couverture complète)",
+      "80": "80% (Élevée)",
+      "60": "60% (Standard)",
+      "40": "40% (Minimale)",
+      "none": "Pas d'objectif"
+    },
+    "deployment": {
+      "vercel": "Vercel",
+      "netlify": "Netlify",
+      "aws": "AWS",
+      "azure": "Azure",
+      "gcp": "Google Cloud Platform",
+      "railway": "Railway",
+      "render": "Render",
+      "fly-io": "Fly.io",
+      "heroku": "Heroku",
+      "cloudflare": "Cloudflare Pages/Workers",
+      "docker": "Docker (Auto-géré)",
+      "kubernetes": "Kubernetes",
+      "vps": "VPS (Manuel)",
+      "self-hosted": "Auto-hébergé",
+      "none": "Aucun"
+    },
+    "containerization": {
+      "docker": "Docker",
+      "docker-compose": "Docker Compose",
+      "kubernetes": "Kubernetes",
+      "podman": "Podman",
+      "none": "Aucun"
+    },
+    "security": {
+      "snyk": "Snyk",
+      "dependabot": "Dependabot",
+      "renovate": "Renovate",
+      "npm-audit": "npm audit",
+      "trivy": "Trivy",
+      "sonarqube": "SonarQube",
+      "codeql": "CodeQL",
+      "none": "Aucun"
+    },
+    "monorepoTool": {
+      "turborepo": "Turborepo",
+      "nx": "Nx",
+      "lerna": "Lerna",
+      "rush": "Rush",
+      "pnpm-workspaces": "pnpm Workspaces",
+      "yarn-workspaces": "Yarn Workspaces",
+      "none": "Aucun"
+    },
+    "documentation": {
+      "jsdoc": "JSDoc",
+      "tsdoc": "TSDoc",
+      "openapi": "OpenAPI/Swagger",
+      "adr": "ADR (Architecture Decision Records)",
+      "markdown": "READMEs Markdown",
+      "none": "Aucun"
+    },
+    "linting": {
+      "eslint": "ESLint",
+      "biome": "Biome",
+      "prettier": "Prettier",
+      "oxlint": "Oxlint",
+      "ruff": "Ruff (Python)",
+      "black": "Black (Python)",
+      "rustfmt": "rustfmt",
+      "gofmt": "gofmt",
+      "credo": "Credo (Elixir)",
+      "none": "Aucun"
+    },
+    "ide": {
+      "cursor": "Cursor (.cursor/rules)",
+      "windsurf": "Windsurf (.windsurfrules)",
+      "gemini": "Gemini Code Assist (.gemini)",
+      "copilot": "GitHub Copilot (.github/copilot)",
+      "cody": "Sourcegraph Cody"
+    }
+  }
+}

package/dist/src/templates/docker/django.Dockerfile.ejs

@@ -0,0 +1,21 @@
+# Build stage
+FROM python:3.9-slim
+
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy project
+COPY . .
+
+# Environment variables
+ENV PYTHONUNBUFFERED=1
+ENV PORT=<%= port %>
+
+# Expose port
+EXPOSE <%= port %>
+
+# Run command
+CMD <%= startCommand %>

package/dist/src/templates/docker/dockerignore.ejs

@@ -0,0 +1,12 @@
+node_modules
+dist
+build
+target
+out
+.git
+.env
+Dockerfile
+.dockerignore
+.idea
+.vscode
+coverage

package/dist/src/templates/docker/go.Dockerfile.ejs

@@ -0,0 +1,20 @@
+# Build stage
+FROM golang:1.21-alpine AS builder
+
+WORKDIR /app
+
+COPY go.mod go.sum ./
+RUN go mod download
+
+COPY . .
+RUN CGO_ENABLED=0 GOOS=linux go build -o main .
+
+# Run stage
+FROM alpine:latest
+
+WORKDIR /app
+COPY --from=builder /app/main .
+
+EXPOSE <%= port %>
+
+CMD ["./main"]

package/dist/src/templates/docker/nestjs.Dockerfile.ejs

@@ -0,0 +1,25 @@
+# Build stage
+FROM node:18-alpine AS builder
+
+WORKDIR /app
+
+COPY package.json <%= packageManager === 'npm' ? 'package-lock.json' : (packageManager === 'yarn' ? 'yarn.lock' : 'pnpm-lock.yaml') %> ./
+
+RUN <%= installCommand %>
+
+COPY . .
+
+RUN <%= buildCommand %>
+
+# Production stage
+FROM node:18-alpine
+
+WORKDIR /app
+
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/node_modules ./node_modules
+COPY --from=builder /app/package.json ./package.json
+
+EXPOSE <%= port %>
+
+CMD [ "<%= startCommand.split(' ')[0] %>", "<%= startCommand.split(' ').slice(1).join('", "') %>" ]

package/dist/src/templates/docker/node.Dockerfile.ejs

@@ -0,0 +1,13 @@
+FROM node:18-alpine
+
+WORKDIR /app
+
+COPY package.json <%= packageManager === 'npm' ? 'package-lock.json' : (packageManager === 'yarn' ? 'yarn.lock' : 'pnpm-lock.yaml') %> ./
+
+RUN <%= installCommand %>
+
+COPY . .
+
+EXPOSE <%= port %>
+
+CMD [ "<%= startCommand.split(' ')[0] %>", "<%= startCommand.split(' ').slice(1).join('", "') %>" ]

package/dist/src/templates/docker/python.Dockerfile.ejs

@@ -0,0 +1,13 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+
+RUN <%= installCommand %>
+
+COPY . .
+
+EXPOSE <%= port %>
+
+CMD <%= startCommand %>

package/dist/src/templates/docker/springboot.Dockerfile.ejs

@@ -0,0 +1,25 @@
+# Build stage
+FROM eclipse-temurin:17-jdk-jammy AS builder
+
+WORKDIR /app
+COPY . .
+
+<% if (packageManager === 'gradle') { %>
+RUN ./gradlew build -x test
+<% } else { %>
+RUN mvn package -DskipTests
+<% } %>
+
+# Run stage
+FROM eclipse-temurin:17-jre-jammy
+
+WORKDIR /app
+<% if (packageManager === 'gradle') { %>
+COPY --from=builder /app/build/libs/*.jar app.jar
+<% } else { %>
+COPY --from=builder /app/target/*.jar app.jar
+<% } %>
+
+EXPOSE <%= port %>
+
+CMD ["java", "-jar", "app.jar"]

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

@@ -0,0 +1,85 @@
+---
+description: Architecture & Design Workflow
+---
+
+1. **System Design**:
+   - Define high-level architecture (Components, Interactions).
+   - Select appropriate technologies and patterns.
+   - Consider scalability, maintainability, and security.
+   - Create C4 diagrams (Context, Container, Component, Code).
+
+2. **Architecture Decision Records (ADRs)**:
+   - Document significant technical decisions.
+   - Include context, options considered, and rationale.
+   - Keep ADRs versioned with the codebase.
+   - Template: `docs/adr/NNNN-title.md`.
+
+3. **API Design**:
+   - Define API versioning strategy (URL, header, content-type).
+   - Design RESTful or GraphQL endpoints consistently.
+   - Document with OpenAPI/Swagger specifications.
+   - Consider backwards compatibility and deprecation policies.
+
+4. **Event-Driven Architecture** (if applicable):
+   - Define event schemas and contracts.
+   - Use event sourcing for audit trails.
+   - Implement idempotent consumers.
+   - Document event flows and subscriptions.
+
+5. **Microservices vs Monolith**:
+   - Evaluate service boundaries based on domain.
+   - Consider team structure and deployment needs.
+   - Start monolithic, extract services when needed.
+   - Document inter-service communication patterns.
+
+6. **Infrastructure as Code (IaC)**:
+   - Review infrastructure architecture decisions.
+   - Ensure IaC modules are reusable and documented.
+   - Define environment-specific configurations.
+   - Plan for disaster recovery and failover.
+
+7. **Observability Stack**:
+   - **Logs**: Structured logging, centralized aggregation.
+   - **Metrics**: Key performance indicators, business metrics.
+   - **Traces**: Distributed tracing for request flows.
+   - **Alerts**: Define SLOs, SLIs, and alerting thresholds.
+
+8. **Performance Architecture**:
+   - Identify potential bottlenecks early.
+   - Design caching strategies (Redis, CDN, in-memory).
+   - Plan for horizontal scaling.
+   - Consider async processing for heavy workloads.
+
+9. **Security Architecture**:
+   - Define authentication and authorization strategy.
+   - Design data encryption at rest and in transit.
+   - Plan network segmentation and access controls.
+   - Include threat modeling in design reviews.
+
+10. **Disaster Recovery**:
+    - Define RPO (Recovery Point Objective) and RTO (Recovery Time Objective).
+    - Document backup and restore procedures.
+    - Plan for multi-region deployment if needed.
+    - Schedule regular DR drills.
+
+11. **Standards & Governance**:
+    - Define overarching technical standards.
+    - Establish code review guidelines.
+    - Create architecture review checkpoints.
+    - Maintain technology radar.
+
+12. **Feasibility & Prototyping**:
+    - Prototype risky components (PoC).
+    - Verify non-functional requirements (Performance, Security).
+    - Document learnings and recommendations.
+
+<%- folderStructure %>
+
+## Architecture Checklist
+- [ ] ADR exists for significant decisions
+- [ ] C4 diagrams are up to date
+- [ ] API contracts are documented
+- [ ] Observability is planned
+- [ ] Security considerations addressed
+- [ ] Scalability strategy defined
+- [ ] DR plan documented

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

@@ -0,0 +1,88 @@
+---
+description: Business Analyst Workflow
+---
+
+1. **Requirements Analysis**:
+   - Gather requirements from stakeholders.
+   - Analyze business processes and data flows.
+   - Identify gaps between current and desired state.
+   - Document assumptions and constraints.
+
+2. **Domain-Driven Design (DDD)**:
+   - Define the ubiquitous language with stakeholders.
+   - Identify bounded contexts and their boundaries.
+   - Create domain models and entity relationships.
+   - Document aggregates and invariants.
+
+3. **Event Storming**:
+   - Facilitate event storming workshops.
+   - Identify domain events (orange stickies).
+   - Map commands (blue) and actors (yellow).
+   - Define read models and policies.
+   - Document the resulting event flow.
+
+4. **BPMN Diagrams**:
+   - Create business process diagrams.
+   - Document workflows and decision points.
+   - Identify automation opportunities.
+   - Validate with stakeholders.
+
+5. **Functional Specifications**:
+   - Write detailed functional specifications.
+   - Include business rules and validations.
+   - Document data requirements.
+   - Create scenarios and use cases.
+
+6. **Data Dictionary**:
+   - Maintain a glossary of business terms.
+   - Define data entities and attributes.
+   - Document data sources and flows.
+   - Specify data validation rules.
+
+7. **Mockups & Wireframes**:
+   - Create mockups or wireframes if needed.
+   - Validate UI flows with stakeholders.
+   - Document interaction patterns.
+   - Collaborate with UX designers.
+
+8. **API Contract Documentation**:
+   - Define API endpoints and payloads.
+   - Specify request/response formats.
+   - Document error codes and meanings.
+   - Coordinate with developers on contracts.
+
+9. **Collaboration**:
+   - Bridge the gap between business and technical teams.
+   - Clarify edge cases and business rules.
+   - Translate technical constraints to business impact.
+   - Facilitate communication and alignment.
+
+10. **Validation**:
+    - Verify implemented features match business needs.
+    - Conduct UAT (User Acceptance Testing).
+    - Collect feedback and document adjustments.
+    - Sign off on delivered functionality.
+
+11. **Change Management**:
+    - Document change requests.
+    - Assess impact of proposed changes.
+    - Communicate changes to stakeholders.
+    - Update specifications accordingly.
+
+## DDD Artifacts Checklist
+- [ ] Ubiquitous language documented
+- [ ] Bounded contexts identified
+- [ ] Domain events mapped
+- [ ] Aggregates defined
+- [ ] Entity relationships documented
+- [ ] Business rules captured
+
+## Event Storming Legend
+| Color | Meaning |
+|-------|---------|
+| 🟠 Orange | Domain Event |
+| 🔵 Blue | Command |
+| 🟡 Yellow | Actor/User |
+| 🟣 Purple | Policy/Process |
+| 🟢 Green | Read Model |
+| 🔴 Red | Hot Spot/Problem |

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

@@ -0,0 +1,47 @@
+---
+description: Data Engineering & Analytics Workflow
+---
+
+1. **Data Modeling**:
+   - Design efficient schemas for data warehouses (Star/Snowflake schema).
+   - Define data types and constraints rigorously.
+   - Document entity relationships and lineage.
+   - Optimize for query performance (partitioning, indexing).
+
+2. **ETL/ELT Pipelines**:
+   - Build robust data ingestion pipelines (Airflow, Dagster, Prefect).
+   - Ensure idempotency and fault tolerance.
+   - Monitor data freshness and volume.
+   - Handle schema evolution gracefully.
+
+3. **Data Quality & Governance**:
+   - Implement data quality checks (Great Expectations, dbt tests).
+   - Monitor for nulls, duplicates, and anomalies.
+   - Manage PII and sensitive data access (masking, tokenization).
+   - Catalog data assets for discoverability.
+
+4. **Infrastructure & Storage**:
+   - Manage data lake/warehouse infrastructure (Snowflake, BigQuery, S3).
+   - Optimize storage costs and lifecycle policies.
+   - Configure access controls and networking.
+
+5. **Transformation Logic**:
+   - Use dbt for modular SQL transformations.
+   - Version control all transformation logic.
+   - Review complex SQL queries for performance.
+   - Document business logic within the code.
+
+6. **Reporting & Analytics Support**:
+   - Create clean, aggregated views for BI tools (Tableau, Looker, PowerBI).
+   - Collaborate with analysts to define metrics.
+   - Ensure data consistency across reports.
+
+<%- folderStructure %>
+
+## Data Engineer Checklist
+- [ ] Data models are documented
+- [ ] Pipelines are idempotent and monitored
+- [ ] Data quality tests pass
+- [ ] PII is handled correctly
+- [ ] Transformations are tested (dbt test)
+- [ ] Lineage is clear