antigravity-flow 1.0.0

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

@@ -0,0 +1,77 @@
+---
+description: Standard Development Workflow
+---
+
+1. **Understanding**:
+   - Analyze the user request and relevant files.
+   - Identify impacted modules and dependencies.
+   - Review existing tests and documentation.
+   - Check for related issues or technical debt.
+
+2. **Planning**:
+   - Break down the task into smaller, testable increments.
+   - Propose an implementation plan before coding.
+   - Identify potential risks and edge cases.
+   - Estimate effort and communicate blockers early.
+
+3. **Implementation**:
+   - Create or modify source code following project conventions.
+   - Use TDD (write tests before code) if applicable.
+   - Follow the architecture guidelines (see `.agent/rules/coding-standards.md`).
+   - Keep commits small and focused (one logical change per commit).
+
+4. **Database & Migrations**:
+   - Create migrations for schema changes: `<%= buildCommand.includes('nest') ? 'npm run migration:generate' : 'npx prisma migrate dev' %>`.
+   - Never modify production data directly.
+   - Test migrations on a fresh database.
+
+5. **Environment & Configuration**:
+   - Use environment variables for secrets and config.
+   - Document new environment variables in `.env.example`.
+   - Never commit secrets to version control.
+
+6. **Verification**:
+   - Run `<%= buildCommand %>` to check compilation.
+   - Run `<%= testCommand %>` for unit tests.
+   - Run `npm run lint` or equivalent for style checks.
+   - Verify no regressions in affected areas.
+
+7. **Logging & Observability**:
+   - Add appropriate log statements (info, warn, error).
+   - Include correlation IDs for traceability.
+   - Avoid logging sensitive data (PII, credentials).
+
+8. **Feature Flags** (if applicable):
+   - Wrap new features in feature flags for safe rollout.
+   - Document flag purpose and cleanup timeline.
+
+9. **Commit & PR**:
+   - Propose a commit following the convention: `feat(scope): description`.
+   - Write a clear PR description with context and testing notes.
+   - Link related issues or tickets.
+   - Request appropriate reviewers.
+
+10. **Rollback Planning**:
+    - Document rollback procedure for complex changes.
+    - Ensure migrations are reversible when possible.
+    - Test rollback in staging environment.
+
+11. **Loop**:
+    - Ask the user if there are other tasks or if the feature is complete.
+    - If complete, propose creating a Pull Request.
+    - Update task tracking and documentation.
+
+## Quick Reference Commands
+```bash
+# Build
+<%= buildCommand %>
+
+# Test
+<%= testCommand %>
+
+# Lint
+npm run lint
+
+# Format
+npm run format
+```

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

@@ -0,0 +1,54 @@
+---
+description: DevOps & Infrastructure Workflow
+---
+
+1. **Infrastructure as Code (IaC)**:
+   - Define all infrastructure using code (Terraform, Pulumi, CloudFormation).
+   - Version control your infrastructure configurations.
+   - Maintain state files securely (remote state with locking).
+   - Use modular and reusable infrastructure components.
+
+2. **CI/CD Pipelines**:
+   - Ensure fast and reliable build pipelines (<%= buildCommand %>).
+   - Implement automated testing (unit, integration, e2e) in CI (<%= testCommand %>).
+   - Use artifact management for build outputs (Docker images, packages).
+   - Implement staged deployments (Dev -> Staging -> Prod).
+
+3. **Containerization & Orchestration**:
+   - Create optimized and secure Dockerfiles (multi-stage builds).
+   - Manage container orchestration (Kubernetes, Docker Swarm).
+   - Define resource limits and requests.
+   - Ensure proper secrets management (Vault, K8s Secrets).
+
+4. **Observability & Monitoring**:
+   - Set up centralized logging (ELK, Splunk, CloudWatch).
+   - Configure metrics collection (Prometheus, Grafana).
+   - Implement distributed tracing (Jaeger, Zipkin, OpenTelemetry).
+   - Define actionable alerts for critical incidents.
+
+5. **Security & Compliance (DevSecOps)**:
+   - Integrate security scanning in CI/CD (SAST, DAST, dependency check).
+   - Automate compliance checks.
+   - Manage access controls (IAM, RBAC) with least privilege.
+   - Regular patching and updates.
+
+6. **Release Management**:
+   - Define versioning strategy (Semantic Versioning).
+   - Implement deployment strategies (Blue/Green, Canary, Rolling).
+   - Automate rollback procedures.
+   - Maintain release notes and changelogs.
+
+7. **Disaster Recovery & Backup**:
+   - Implement automated backup strategies for databases and state.
+   - Regular testing of restore procedures.
+   - Define high availability and failover configurations.
+
+<%- folderStructure %>
+
+## DevOps Checklist
+- [ ] Infrastructure code is versioned
+- [ ] CI/CD pipeline is active and green
+- [ ] Secrets are managed securely outside of repo
+- [ ] Monitoring dashboards are accessible
+- [ ] Backups are configured and tested
+- [ ] Immutability of deployments is enforced

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

@@ -0,0 +1,12 @@
+### Proposed Folder Structure (Feature-Sliced Design)
+
+```
+src/
+├── app/                   # App-wide settings, styles, providers
+├── processes/             # Complex inter-page scenarios (Auth, Payment)
+├── pages/                 # Full pages (Routing)
+├── widgets/               # Composition of features/entities
+├── features/              # User interactions (Add to Cart, Login)
+├── entities/              # Business entities (User, Product)
+└── shared/                # Reusable code (UI Kit, libs)
+```

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

@@ -0,0 +1,14 @@
+### Proposed Folder Structure (Hexagonal / Clean Architecture)
+
+```
+src/
+├── core/                  # Domain & Application Layer (Pure TS/JS, No external deps)
+│   ├── entities/          # Domain Logic & Types
+│   ├── interfaces/        # Ports (Interfaces for Repositories, Services)
+│   └── use-cases/         # Application Business Rules
+├── adapters/              # Infrastructure Layer
+│   ├── persistence/       # Database implementations (TypeORM, Prisma...)
+│   ├── api/               # External APIs (Stripe, formatting...)
+│   └── ui/                # Presenters / CLI Adapters
+└── infrastructure/        # Framework configuration (NestJS Modules, Express setup)
+```

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

@@ -0,0 +1,11 @@
+### Proposed Folder Structure (MVC / Layered)
+
+```
+src/
+├── controllers/           # Handle incoming requests (Routing)
+├── models/                # Data Models & Schemas
+├── services/              # Business Logic
+├── views/                 # UI Templates (if applicable)
+├── utils/                 # Helper functions
+└── config/                # Configuration & Env variables
+```

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

@@ -0,0 +1,11 @@
+### ASP.NET Core Standards
+
+- **Dependency Injection**: Use built-in DI container for services and repositories.
+- **Async/Await**: Use asynchronous programming pattern for all I/O bound operations.
+- **Nullable Reference Types**: Enable and respect `<Nullable>enable</Nullable>`.
+- **Folder Structure**:
+    - `Controllers/`: API endpoints.
+    - `Services/`: Business logic.
+    - `Repositories/`: Data access.
+    - `Models/`: Domain entities and DTOs.
+    - `Program.cs`: configuration and startup.

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

@@ -0,0 +1,5 @@
+## Base Coding Standards
+
+1.  **SOLID Principles**: Adhere to Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion.
+2.  **Clean Code**: Write code that is easy to read, understand, and maintain. Use meaningful names.
+3.  **DRY (Don't Repeat Yourself)**: Avoid duplication. Extract common logic into reusable functions or components.

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

@@ -0,0 +1,12 @@
+## Django Specific Rules
+
+1.  **Project Structure**: Organize apps by domain/feature, not by type.
+2.  **Models**: Keep models thin, use managers for complex queries.
+3.  **Views**: Prefer class-based views for reusability.
+4.  **Forms**: Use Django forms for validation, ModelForms for CRUD.
+5.  **Migrations**: Always review generated migrations before applying.
+6.  **Signals**: Avoid signals for business logic, use explicit service calls.
+7.  **Templates**: Minimize logic in templates, use template tags.
+8.  **Settings**: Use django-environ or similar for environment configuration.
+9.  **Security**: Enable CSRF, use Django's security middleware.
+10. **Testing**: Use pytest-django for testing, factory_boy for fixtures.

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

@@ -0,0 +1,11 @@
+## FastAPI Specific Rules
+
+1.  **Pydantic Models**: Use Pydantic for request/response validation and serialization.
+2.  **Dependency Injection**: Use `Depends()` for dependency injection.
+3.  **Async**: Use `async def` for I/O-bound operations.
+4.  **Type Hints**: Always use type hints for parameters and return types.
+5.  **Routers**: Organize endpoints in APIRouter modules by domain.
+6.  **Background Tasks**: Use BackgroundTasks for async operations.
+7.  **Error Handling**: Use HTTPException for API errors with proper status codes.
+8.  **Settings**: Use pydantic-settings for configuration management.
+9.  **Middleware**: Use middleware for CORS, logging, and request tracing.

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

@@ -0,0 +1,11 @@
+### Flutter Standards
+
+- **State Management**: Clearly define the state management solution (Provider, Riverpod, BLoC).
+- **Widgets**: Split UI into small, reusable widgets.
+- **Null Safety**: Strict adherence to null safety rules.
+- **Folder Structure**:
+    - `lib/main.dart`: Entry point.
+    - `lib/src/`: Private implementation code.
+    - `lib/widgets/`: Reusable components.
+    - `lib/screens/` or `lib/pages/`: Application views.
+    - `lib/models/`: Data models.

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

@@ -0,0 +1,5 @@
+## NestJS Specific Rules
+
+1.  **Dependency Injection**: Always use DI for service dependencies.
+2.  **Modules**: Organize code into modules by feature (e.g., `AuthModule`, `UserModule`).
+3.  **DTOs**: Use DTOs for data validation with `class-validator`.

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

@@ -0,0 +1,10 @@
+## Next.js Specific Rules
+
+1.  **App Router**: Use the App Router (app/) for new projects. Only use Pages Router for legacy compatibility.
+2.  **Server Components**: Use Server Components by default. Add `'use client'` only when needed.
+3.  **Data Fetching**: Use `fetch()` with caching strategies, not `getServerSideProps`/`getStaticProps`.
+4.  **API Routes**: Use Route Handlers (app/api/) for server-side logic.
+5.  **Metadata**: Use the Metadata API for SEO, not manual `<head>` manipulation.
+6.  **Image Optimization**: Always use `next/image` for images.
+7.  **Environment Variables**: Use `NEXT_PUBLIC_` prefix for client-exposed variables only.
+8.  **Middleware**: Use middleware.ts for authentication and redirects.

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

@@ -0,0 +1,12 @@
+## React Native Specific Rules
+
+1.  **Navigation**: Use React Navigation for routing.
+2.  **State Management**: Use React Query for server state, Zustand/Redux for client state.
+3.  **Styling**: Use StyleSheet.create() for performance, consider NativeWind.
+4.  **Native Modules**: Minimize native code, use Expo modules when possible.
+5.  **Performance**: Use FlatList for long lists, avoid anonymous functions in render.
+6.  **Platform-Specific**: Use Platform.select() for platform-specific code.
+7.  **Assets**: Optimize images for mobile, use appropriate resolutions.
+8.  **Testing**: Use React Native Testing Library, Detox for E2E.
+9.  **OTA Updates**: Use EAS Update for over-the-air updates.
+10. **Deep Linking**: Configure deep links for navigation from external sources.

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

@@ -0,0 +1,5 @@
+## React Specific Rules
+
+1.  **Functional Components**: Use functional components with Hooks. Avoid class components.
+2.  **Custom Hooks**: Extract complex logic into custom hooks (e.g., `useAuth`, `useFetch`).
+3.  **Component Structure**: Keep components small and focused. One component per file.

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

@@ -0,0 +1,6 @@
+### 🛡️ Legacy Refactoring Rules
+- **Characterization Tests First**: Before changing any code, write tests that capture the current behavior (bugs and all).
+- **Refactoring Strategy**: Use the "Strangler Fig" pattern for major rewrites. refactor only the code you touch ("Boy Scout Rule").
+- **Code Coverage**: Do not enforce 100% on old code. Focus on coverage for *new* code and *changed* legacy code.
+- **Technical Debt**: Mark known issues with `// TODO: [Legacy]`. Don't try to fix everything at once.
+- **Types**: Use `any` effectively if types are missing, but aim to introduce interfaces for boundary layers.

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

@@ -0,0 +1,6 @@
+### 🚀 Prototype Rigor Mode
+
+- **Speed First**: Focus on delivering features and validating hypotheses.
+- **Testing**: Critical path tests only. TDD is optional.
+- **Technical Debt**: Allowed, but must be marked with `// TODO: [Refactor]`.
+- **Typing**: `any` allowed for rapid prototyping, refine later.

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

@@ -0,0 +1,7 @@
+### 🛡️ Strict Rigor Mode
+
+- **Test Driven Development (TDD)**: Mandatory. Write failing tests before writing code.
+- **Coverage**: Maintain 100% code coverage.
+- **Typing**: No `any`. Strict TypeScript configuration enabled.
+- **Code Reviews**: 2 approvals required. No self-merging.
+- **Documentation**: All public APIs must be documented with JSDoc/TSDoc.

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

@@ -0,0 +1,11 @@
+### Rust Development Standards
+
+- **Toolchain**: Use `cargo` for dependency management, build, and test.
+- **Formatting**: Enforce `cargo fmt` (rustfmt) for consistent code style.
+- **Linting**: Use `cargo clippy` and address all warnings.
+- **Error Handling**: Use `Result` and `Option` types explicitly. Avoid `unwrap()` and `expect()` in production code; prefer `?` propagation or pattern matching.
+- **Concurrency**: Use `tokio` or `std::thread` appropriately. Ensure thread safety with `Arc`, `Mutex`, `RwLock`.
+- **Testing**:
+    - Unit tests in the same file module `#[cfg(test)] mod tests { ... }`.
+    - Integration tests in `tests/` directory.
+- **Documentation**: Write documentation comments `///` for all public APIs.

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

@@ -0,0 +1,8 @@
+### 🧩 Scrypto (RadixDLT) Guidelines
+- **Asset-Oriented**: Treat resources (Tokens, NFTs) as first-class citizens using `Buckets` and `Vaults`. Avoid tracking balances in generic maps.
+- **Blueprints & Components**: Keep blueprints modular. Use `functions` for instantiation and `methods` for state mutation.
+- **Testing**:
+    - Use `TestEnvironment` for unit tests (fast, isolated).
+    - Use `LedgerSimulator` for integration tests (manifest-based).
+    - Run tests with `cargo test`.
+- **Security**: Use `Badges` for authorization (Actor-Virtual-Badge pattern). Validate all resource movements (withdrawals/deposits).

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

@@ -0,0 +1,20 @@
+## Solidity Specific Rules
+
+1.  **Version Pragma**: Always specify a specific Solidity version or range.
+2.  **Visibility**: Explicitly declare function visibility (public, external, internal, private).
+3.  **Reentrancy**: Follow CEI pattern (Checks-Effects-Interactions) to prevent reentrancy.
+4.  **Gas Optimization**: Minimize storage writes, use `memory` for temporary data.
+5.  **Events**: Emit events for all state changes for off-chain indexing.
+6.  **Access Control**: Use OpenZeppelin's Ownable or AccessControl.
+7.  **Error Handling**: Use custom errors instead of require strings for gas efficiency.
+8.  **Testing**: Use Foundry or Hardhat for comprehensive testing.
+9.  **Upgradability**: Use proxy patterns (UUPS, Transparent) if upgradeable.
+10. **Audit**: All contracts must be audited before mainnet deployment.
+
+### Security Checklist
+- [ ] Reentrancy guards implemented
+- [ ] Integer overflow/underflow handled (Solidity 0.8+)
+- [ ] Access control verified
+- [ ] External call risks assessed
+- [ ] Flash loan attack vectors considered
+- [ ] Front-running mitigations in place

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

@@ -0,0 +1,13 @@
+## Spring Boot Specific Rules
+
+1.  **Project Structure**: Organize by feature/domain, not by layer.
+2.  **Dependency Injection**: Use constructor injection, avoid field injection.
+3.  **Configuration**: Use application.yml with profiles for environments.
+4.  **REST Controllers**: Use @RestController with proper HTTP methods and status codes.
+5.  **Service Layer**: Keep business logic in @Service classes.
+6.  **Repository**: Use Spring Data JPA repositories, custom queries in @Query.
+7.  **Validation**: Use @Valid and Bean Validation annotations.
+8.  **Exception Handling**: Use @ControllerAdvice for global exception handling.
+9.  **Security**: Use Spring Security for authentication and authorization.
+10. **Testing**: Use @SpringBootTest for integration, @WebMvcTest for controllers.
+11. **Actuator**: Enable health and metrics endpoints for observability.

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

@@ -0,0 +1,48 @@
+
+  ___       _   _                           _ _               
+ / _ \     | | (_)                         (_) |              
+/ /_\ \_ __| |_ _  __ _ _ __ __ ___   _____| |_ _   _         
+|  _  | '_ \ __| |/ _` | '__/ _` \ \ / / | | __| | | |        
+| | | | | | | |_| | (_| | | | (_| |\ V /| | | | |_| |        
+\_| |_/_| |_|\__|_|\__, |_|  \__,_| \_/ |_|_|  \__, |        
+                    __/ |                       __/ |        
+                   |___/                       |___/         
+
+Welcome to the Antigravity Workflow CLI!
+
+Usage:
+  ag-flow [command]
+
+Commands:
+  init      Initialize the agent workflow in your current directory.
+            - Auto-detects your Tech Stack (Node, Rust, Python, etc.)
+            - Generates specific Agent Rules (.agent/rules/coding-standards.md)
+            - Creates CI/CD Pipelines (.github/workflows/)
+            - Sets up Role-Based Prompts (.agent/workflows/)
+            - Generates .gitignore and Dockerfile optimized for your stack
+  
+            Options:
+            --config <path>   Run initialization from a configuration file (skip prompts)
+
+  guide     Show this help message.
+
+Workflows Generated:
+  After running 'init', you will find markdown files in '.agent/workflows/'.
+  Copy the content of these files (e.g., 'dev.md') into your AI Agent (Cursor, Windsurf)
+  to prime it with your project's specific context and rules.
+
+Supported Stacks:
+  - Frontend: React, Vue, Angular, Flutter
+  - Backend: NestJS, ASP.NET Core, Python, Node.js, Rust
+  - Smart Contracts: Scrypto
+
+Rigor Modes:
+  - Strict: Enforces TDD, 100% test coverage, and strict typing.
+  - Prototype: Focuses on speed and MVP validation.
+
+Configuration:
+  Your settings are saved in '.agent/antigravity.json'.
+  You can edit this file to manually adjust your project context.
+
+Need more help?
+  Visit: https://github.com/antigravity/flow

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

@@ -0,0 +1,76 @@
+---
+description: Tech Lead & Standards Workflow
+---
+
+1. **Code Review**:
+   - Review Pull Requests for code quality, security, and best practices.
+   - Ensure adherence to SOLID and Clean Code principles.
+   - Verify tests cover new functionality.
+   - Check for potential performance issues.
+   - Provide constructive, actionable feedback.
+
+2. **Architecture Validation**:
+   - Validate design decisions and patterns.
+   - Ensure separation of concerns.
+   - Verify dependency direction follows architecture rules.
+   - Review for unnecessary complexity.
+
+3. **Technical Debt Management**:
+   - Maintain a technical debt backlog.
+   - Prioritize debt based on impact and effort.
+   - Allocate time each sprint for debt reduction.
+   - Track debt metrics over time.
+   - Tag debt items with severity: `// TODO: [Tech-Debt-High]`.
+
+4. **Sprint Metrics & Velocity**:
+   - Track team velocity and trends.
+   - Monitor code quality metrics (coverage, complexity).
+   - Review cycle time and lead time.
+   - Identify and address bottlenecks.
+
+5. **Mentoring & Growth**:
+   - Provide constructive feedback to team members.
+   - Guide on complex technical issues.
+   - Encourage knowledge sharing and learning.
+   - Conduct pair programming sessions.
+   - Support career development discussions.
+
+6. **Knowledge Sharing**:
+   - Organize tech talks and brown bag sessions.
+   - Document and share learnings from incidents.
+   - Maintain internal wikis and runbooks.
+   - Encourage writing internal blog posts.
+
+7. **Incident Management**:
+   - Define incident severity levels.
+   - Establish on-call rotation and escalation paths.
+   - Lead incident response and coordination.
+   - Conduct blameless post-mortems.
+   - Track incident metrics (MTTR, MTTD).
+
+8. **Tooling & Automation**:
+   - Maintain build pipelines and CI/CD.
+   - Ensure linting rules are enforced.
+   - Automate repetitive tasks.
+   - Evaluate and adopt new tools thoughtfully.
+   - Ensure `<%= buildCommand %>` runs smoothly.
+
+9. **Release Management**:
+   - Coordinate release planning.
+   - Ensure release notes are complete.
+   - Verify rollback procedures exist.
+   - Monitor post-release stability.
+
+10. **Cross-Team Collaboration**:
+    - Align with other teams on shared dependencies.
+    - Participate in architecture forums.
+    - Represent team in technical discussions.
+    - Communicate technical decisions clearly.
+
+## Lead Dev Checklist
+- [ ] All PRs reviewed within SLA
+- [ ] Technical debt is tracked and addressed
+- [ ] Team has clear understanding of architecture
+- [ ] Incidents have post-mortems
+- [ ] Knowledge is documented and shared
+- [ ] Metrics are tracked and improving

package/dist/src/templates/en/pipelines/github-dotnet.yml.ejs

@@ -0,0 +1,24 @@
+name: .NET CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v3
+      with:
+        dotnet-version: 6.0.x
+    - name: Restore dependencies
+      run: dotnet restore
+    - name: Build
+      run: <%= project.buildCommand %>
+    - name: Test
+      run: <%= project.testCommand %>

package/dist/src/templates/en/pipelines/github-flutter.yml.ejs

@@ -0,0 +1,24 @@
+name: Flutter CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - uses: actions/setup-java@v2
+      with:
+        distribution: 'zulu'
+        java-version: '11'
+    - uses: subosito/flutter-action@v2
+      with:
+        flutter-version: '3.x'
+    - run: flutter pub get
+    - run: <%= project.testCommand %>
+    - run: <%= project.buildCommand %>

package/dist/src/templates/en/pipelines/github-nestjs.yml.ejs

@@ -0,0 +1,26 @@
+name: NestJS CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [18.x]
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+    - run: npm ci
+    - run: <%= project.buildCommand %>
+    - run: <%= project.testCommand %>

package/dist/src/templates/en/pipelines/github-react.yml.ejs

@@ -0,0 +1,26 @@
+name: React CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [18.x]
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+    - run: npm ci
+    - run: <%= project.buildCommand %>
+    - run: <%= project.testCommand %>

package/dist/src/templates/en/pipelines/github-rust.yml.ejs

@@ -0,0 +1,38 @@
+name: Rust CI
+
+on:
+  push:
+    branches: [ "main", "develop" ]
+  pull_request:
+    branches: [ "main", "develop" ]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build:
+    name: Build and Test
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Set up Rust
+      uses: actions-rs/toolchain@v1
+      with:
+        profile: minimal
+        toolchain: stable
+        override: true
+        components: rustfmt, clippy
+
+    - name: Check Formatting
+      run: cargo fmt -- --check
+
+    - name: Clippy Linting
+      run: cargo clippy -- -D warnings
+
+    - name: Build
+      run: cargo build --verbose
+
+    - name: Run Tests
+      run: cargo test --verbose

package/dist/src/templates/en/pipelines/github-scrypto.yml.ejs

@@ -0,0 +1,34 @@
+name: Scrypto CI
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build_and_test:
+    name: Build & Test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Rust Toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: wasm32-unknown-unknown
+
+      # Optional: Install Scrypto CLI if needed for specific build steps, 
+      # but standard cargo test usually suffices for logic verification.
+      # - name: Install Scrypto Simulator (optional/expensive)
+      #   run: |
+      #      cargo install --force radix-clis 
+
+      - name: Build
+        run: cargo build --release --target wasm32-unknown-unknown
+
+      - name: Run Tests
+        run: cargo test