Re-Shell CLI v0.27.0

Full-Stack Development Platform - Microservices & Microfrontends United

The most comprehensive and powerful command-line interface for building complete full-stack applications with distributed microservices and microfrontend architectures. Re-Shell unites backend and frontend development under a single CLI, providing enterprise-grade reliability, seamless integration, and exceptional developer experience.


🚀 Platform Overview

Re-Shell CLI is a comprehensive full-stack development platform that revolutionizes how teams build modern distributed applications. By uniting microservices and microfrontends under a single powerful CLI, it enables developers to create, integrate, and deploy complete applications with unprecedented ease.

$3

- 🎯 Full-Stack Unity: Seamless integration between frontend microfrontends and backend microservices
- 🏗️ Microservices Excellence: 85+ production-ready templates across 14 languages - Node.js, Python, .NET, Java, Rust, Go, PHP, Ruby, Clojure, Perl, Crystal, Nim, V, Gleam, Zig, Dart, Haskell, Deno, Bun, OCaml, Elixir, ReScript, Swift, and more
- 🎨 Microfrontend Architecture: Module Federation with React, Vue, Svelte, and Angular support
- 🔄 Smart Code Generation: API-first development with automatic type generation and SDK creation
- 📊 Complete Observability: Built-in monitoring, tracing, and logging across the entire stack
- 🛡️ Enterprise Security: JWT authentication, OAuth2, API gateways, and compliance features
- ☁️ Production Ready: Docker orchestration, Kubernetes manifests, and cloud provider configs

$3

- 🌍 Massive Expansion: 85+ backend framework templates across 14 programming languages
- 💎 Crystal Ecosystem: Kemal, Lucky, and Amber frameworks with type safety and performance
- 👑 Nim Frameworks: Jester, Prologue, and Karax for efficient system programming
- ✨ Gleam & V: Functional programming with Wisp/Mist and systems programming with vweb/Vex
- ⚡ Zig Performance: Ultra-fast web servers with zap, http.zig, and zhp frameworks
- 🎯 Dart Full-Stack: Shelf, Angel3, and Conduit for server-side Dart development
- 🐘 Complete PHP: Laravel, Symfony, Slim, CodeIgniter, Lumen, and Laminas
- 🐪 OCaml Web: Dream, Opium, and Cohttp for functional web development
- 🧪 Elixir Phoenix: Phoenix and Plug for fault-tolerant applications
- 📜 ReScript: Type-safe Express and Fastify bindings
- 🍎 Swift Server: Perfect, Kitura, and Hummingbird for server-side Swift

$3

#### v0.25.0
- 💎 Complete Haskell Ecosystem: Servant, Yesod, Scotty, and Spock frameworks
- 🔧 Type-Safe Development: Haskell's strong type system with GHC optimization
- 🛡️ Functional Security: Type-safe authentication and validation patterns
- 📊 Advanced Testing: HSpec and QuickCheck property-based testing
- 🐳 Haskell DevOps: Stack and Cabal build systems with Docker integration

#### v0.24.0
- 🚀 Backend Framework Templates: 26 new production-ready backend templates transforming Re-Shell into a full-stack platform
- ⚡ Node.js Frameworks: Express, Fastify, NestJS, Koa, Feathers.js, AdonisJS, Moleculer, Strapi, and more
- 🐍 Python Frameworks: FastAPI, Django, Flask, Starlette with async support and type hints
- 🏎️ Performance Leaders: Hyper-Express (100k+ req/sec), Fastify (35k req/sec), Polka (5x faster than Express)
- 🔄 Real-time Support: Feathers.js with Socket.io, Meteor.js with DDP, GraphQL subscriptions
- 🏗️ Microservices: Moleculer with service discovery, NestJS with CQRS, event-driven architectures
- 📊 GraphQL: Apollo Server and GraphQL Yoga with subscriptions and DataLoader
- 🛡️ Enterprise Features: JWT auth, rate limiting, API versioning, health checks across all templates
- 🐳 Docker Ready: All templates include multi-stage Docker builds and docker-compose configs

$3

#### v0.23.0
- 💎 Complete Ruby Ecosystem: Rails API, Sinatra, and Grape frameworks
- 🔧 Ruby Infrastructure: ActiveRecord ORM, Sidekiq jobs, RSpec testing
- 🛡️ Ruby Security: JWT auth, Rack::Attack rate limiting, parameter validation
- 📊 Ruby Documentation: Swagger with grape-swagger and rswag
- 🐳 Ruby DevOps: Docker support, Guard integration, RuboCop code quality

#### v0.22.1
- 🔧 Documentation Updates: Enhanced README and EXAMPLES with complete Go ecosystem coverage
- 📝 Commit History Cleanup: Removed task completion artifacts for cleaner git history
- 🏷️ Version Management: Improved release workflow and tagging process
- 📚 Examples Enhancement: Added comprehensive Go framework examples and use cases

#### v0.22.0
- 🚀 Complete Go Ecosystem: 6 production-ready Go templates for high-performance development
- 💎 Complete Ruby Ecosystem: 3 production-ready Ruby templates for rapid API development
- ⚡ Go Frameworks: Gin, Echo, Fiber, Chi, gRPC with Protocol Buffers, and sqlx for raw SQL
- 🔧 Go Infrastructure: GORM ORM, database migrations, hot reload with Air, Docker support
- 🛡️ Go Security: JWT authentication, bcrypt hashing, rate limiting, secure middleware
- 📊 Go Monitoring: Structured logging (Zap/Zerolog), Prometheus metrics, health checks
- 🧪 Go Testing: Testify framework, mocking, coverage reports, benchmark support
- 🏗️ Go Architecture: Clean architecture, dependency injection, context handling
- 🐳 Go DevOps: Multi-stage builds, minimal Alpine images, docker-compose orchestration

#### v0.21.0
- 🐘 Complete PHP Ecosystem: 6 enterprise-grade PHP templates for modern web development
- 🚀 PHP Frameworks: Symfony, Laravel, Slim, and CodeIgniter 4 with full feature sets
- 🔧 PHP Infrastructure: PHP-FPM configuration, Composer integration, Docker support
- 🛡️ PHP Security: CSRF protection, XSS filtering, SQL injection prevention
- ⚡ PHP Performance: OPcache with JIT, connection pooling, Redis caching
- 🧪 PHP Testing: PHPUnit integration, code coverage, fixture management
- 📊 PHP Monitoring: Health endpoints, error logging, performance metrics
- 🐳 PHP DevOps: Alpine containers, Nginx integration, Xdebug support

#### v0.20.0

- 🔷 Complete .NET Ecosystem: 12 enterprise-grade .NET templates covering every development scenario
- 🔐 Advanced Authentication: JWT with 2FA, external OAuth (Google, Facebook, Microsoft), rate limiting
- 📊 Comprehensive Monitoring: Serilog with multiple sinks, performance tracking, audit logging
- 📚 Enterprise Documentation: Swagger/OpenAPI with code generation, XML documentation, examples
- 🧪 Advanced Testing: xUnit with FluentAssertions, Moq, integration tests, test containers
- ⚡ Development Experience: Hot reload with dotnet watch, file monitoring, development utilities
- 🏗️ Specialized Templates: Entity Framework Core, Dapper, AutoMapper, Blazor Server, gRPC
- 🛡️ Production Security: Identity framework, authorization policies, security headers, CORS
- 📈 Performance Optimization: Output caching, rate limiting, Redis integration, AOT compilation
- 🐳 Infrastructure Ready: Docker support, health checks, configuration management

📋 Table of Contents

- Quick Start
- Architecture
- Microservices Templates
- Microfrontend Templates
- Core Features
- Advanced Features
- DevOps & Deployment
- Enterprise Features
- CLI Commands Reference
- Configuration
- Examples
- Best Practices
- Contributing
- Support

🚀 Quick Start

$3

``bash


Install globally using npm

npm install -g @re-shell/cli

Using yarn

yarn global add @re-shell/cli

Using pnpm

pnpm add -g @re-shell/cli

Verify installation

re-shell --version
`

$3

`bash


Initialize a new full-stack project

re-shell create my-app --type full-stack
cd my-app

Frontend: Add microfrontends

re-shell add dashboard --framework react-ts --port 5173
re-shell add admin-panel --framework vue-ts --port 5174

Backend: Add microservices

re-shell generate backend api-service --language python --framework fastapi --port 8001
re-shell generate backend auth-service --framework express --port 8002

Start everything with Docker orchestration

docker-compose up

Or start individually for development

re-shell dev --all
`

$3

#### 1. Project Structure
Re-Shell creates a monorepo structure optimized for full-stack development:

`
my-app/
├── apps/ # Microfrontend applications
│ ├── dashboard/ # React dashboard
│ └── admin-panel/ # Vue.js admin panel
├── services/ # Backend microservices
│ ├── api-service/ # Python FastAPI service
│ └── auth-service/ # Node.js Express service
├── packages/ # Shared libraries
│ ├── ui/ # Shared UI components
│ ├── types/ # Shared TypeScript types
│ └── sdk/ # Auto-generated API SDKs
├── docker-compose.yml # Local development orchestration
└── re-shell.config.yaml # Project configuration
`

#### 2. Microfrontend Generation
When you run re-shell add dashboard --framework react-ts, the CLI:

- Creates a complete React application with TypeScript
- Configures Module Federation for runtime integration
- Sets up a development server with hot reload
- Implements microfrontend patterns (mount/unmount, event bus)
- Generates production-ready build configurations
- Includes Docker support for containerization

#### 3. Microservice Generation
When you run re-shell generate backend api-service --language python --framework fastapi, the CLI:

- Creates a complete FastAPI project structure
- Includes database models and migrations
- Sets up API documentation (OpenAPI/Swagger)
- Configures testing with pytest
- Implements authentication and middleware
- Generates Docker configuration
- Includes hot-reload for development

$3

`bash


Start all services in development mode

re-shell dev --all

Start specific services

re-shell dev user-service payment-service

View service health dashboard

re-shell doctor --interactive
`

🏗️ Architecture

Re-Shell CLI implements a modern distributed architecture pattern that combines microservices backends with microfrontend presentation layers, providing maximum flexibility and scalability.

`
┌─────────────────────────────────────────────────────────────────┐
│ Re-Shell Platform │
├─────────────────────────────────────────────────────────────────┤
│ 🎯 Microfrontend Layer │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ React │ │ Vue.js │ │ Svelte │ │
│ │ Dashboard │ │ Catalog │ │ Analytics │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ │ │ │ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ Shell Application │ │
│ │ (Module Federation) │ │
│ └─────────────────────────────────────────────────────────┘ │
├─────────────────────────────────────────────────────────────────┤
│ 🔗 API Gateway & Service Mesh │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ Load Balancer │ Auth │ Rate Limit │ Circuit Breaker │ │
│ └─────────────────────────────────────────────────────────┘ │
├─────────────────────────────────────────────────────────────────┤
│ 🏗️ Microservices Layer │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Node.js │ │ Python │ │ Rust │ │
│ │ User Service│ │Payment API │ │Notification │ │
│ │ (Express) │ │ (FastAPI) │ │ (Actix) │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
├─────────────────────────────────────────────────────────────────┤
│ 💾 Data Layer │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ PostgreSQL │ │ MongoDB │ │ Redis │ │
│ │ Users │ │ Analytics │ │ Cache │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
└─────────────────────────────────────────────────────────────────┘
`

$3

- 🔌 Polyglot Persistence: Choose the right database for each service
- 🌐 Language Agnostic: Use the best language for each domain
- 📦 Container First: Docker and Kubernetes native
- 🔄 Event Driven: Asynchronous communication patterns
- 🛡️ Security by Design: Zero-trust architecture implementation
- 📊 Observability: Comprehensive monitoring and tracing

🔧 Microservices Templates

$3

#### Express.js Template
`bash
re-shell create api-service --template express
`
Features: TypeScript, JWT auth, Prisma ORM, rate limiting, middleware composition
Use Cases: REST APIs, traditional web services, rapid prototyping

#### Fastify Template
`bash
re-shell create high-perf-api --template fastify
`
Features: 35,000 req/sec performance, schema validation, plugin architecture, WebSocket support
Use Cases: High-throughput APIs, real-time services, performance-critical applications

#### NestJS Template
`bash
re-shell create enterprise-api --template nestjs
`
Features: Dependency injection, GraphQL, CQRS, microservices support, OpenAPI
Use Cases: Enterprise applications, complex business logic, microservices architecture

#### Koa.js Template
`bash
re-shell create modern-api --template koa
`
Features: Async/await composition, TypeScript, lightweight middleware system
Use Cases: Modern APIs, middleware-heavy applications, clean architecture

#### Feathers.js Template
`bash
re-shell create realtime-api --template feathersjs
`
Features: Real-time Socket.io, service-oriented, hook system, multi-database
Use Cases: Real-time applications, chat systems, collaborative tools

#### AdonisJS Template
`bash
re-shell create full-stack-api --template adonisjs
`
Features: MVC architecture, Lucid ORM, Edge templating, Laravel-inspired
Use Cases: Full-stack applications, rapid development, enterprise apps

#### Moleculer Template
`bash
re-shell create microservices --template moleculer
`
Features: Service discovery, fault tolerance, caching, distributed tracing
Use Cases: Microservices architecture, distributed systems, scalable services

#### Strapi Template
`bash
re-shell create headless-cms --template strapi
`
Features: Admin panel, content types, media library, role-based permissions
Use Cases: Headless CMS, content management, API-first development

#### Apollo Server Template
`bash
re-shell create graphql-api --template apollo-server
`
Features: GraphQL subscriptions, DataLoader, schema stitching, federation
Use Cases: GraphQL APIs, real-time subscriptions, federated graphs

#### Additional Node.js Templates
- GraphQL Yoga: Modern GraphQL server with envelop plugins
- LoopBack: API framework with ORM and OpenAPI support
- Sails.js: MVC framework for data-driven APIs
- Foal TS: TypeScript framework with CLI tools
- Marble.js: Reactive framework using RxJS
- tinyhttp: Modern Express alternative (2x faster)
- Polka: Ultra-performant (5x faster than Express)
- Restify: Optimized for RESTful services
- Total.js: Full-stack framework with NoSQL
- ActionHero: Multi-transport (HTTP, WebSocket, TCP)
- Middy: Serverless middleware for AWS Lambda
- Egg.js: Enterprise framework by Alibaba
- Hyper-Express: 100,000+ req/sec performance
- Ts.ED: Decorators and classes for Express/Koa

$3

#### FastAPI Template
`bash
re-shell create python-api --template fastapi
`
Features: Automatic OpenAPI, type hints, async support, dependency injection, WebSocket support, comprehensive testing
Use Cases: ML APIs, data processing, high-performance APIs, real-time services
Testing: pytest-asyncio, TestClient, AsyncClient, dependency overrides, WebSocket testing

#### Django Template
`bash
re-shell create web-service --template django
`
Features: Django REST Framework, admin interface, ORM, custom management commands, comprehensive testing
Use Cases: Enterprise web applications, content management, admin dashboards
Testing: Django test framework, DRF testing, model testing, management command testing

#### Flask Template
`bash
re-shell create lightweight-api --template flask
`
Features: Blueprint architecture, SQLAlchemy integration, CLI commands, comprehensive testing
Use Cases: Lightweight APIs, microservices, rapid prototyping
Testing: Flask testing client, app contexts, blueprint testing, CLI testing

#### Tornado Template
`bash
re-shell create async-service --template tornado
`
Features: High-performance async, WebSocket support, non-blocking I/O, comprehensive testing
Use Cases: Real-time applications, WebSocket services, high-concurrency systems
Testing: AsyncHTTPTestCase, WebSocket testing, performance testing

#### Sanic Template
`bash
re-shell create ultra-fast-api --template sanic
`
Features: Ultra-fast async framework, blueprint architecture, middleware system, comprehensive testing
Use Cases: High-performance APIs, async microservices, speed-critical applications
Testing: Sanic TestClient, async testing, middleware testing, rate limiting tests

$3

All Python templates include enterprise-grade testing infrastructure:

#### Comprehensive pytest Configuration
- pytest-asyncio: Full async testing support with event loop management
- pytest-cov: 85% coverage threshold with HTML, XML, JSON reports
- pytest-xdist: Parallel test execution with worksteal distribution
- pytest-benchmark: Performance regression testing and monitoring

#### Framework-Specific Testing
- FastAPI: TestClient, AsyncClient, dependency injection testing, WebSocket testing
- Django: Model testing, DRF testing, admin testing, management command testing
- Flask: Blueprint testing, app context testing, CLI testing, template testing
- Tornado: AsyncHTTPTestCase, WebSocket testing, IOLoop testing, performance testing
- Sanic: Async testing, middleware testing, rate limiting testing, security testing

#### Test Utilities & Fixtures
- Authentication: JWT token generation, user fixtures, permission testing
- Database: Transaction rollback, data seeding, cleanup utilities
- HTTP: Status assertion, JSON validation, header checking, content validation
- Files: Upload testing, download testing, temporary file management
- Performance: Memory monitoring, execution time tracking, benchmark utilities

#### Advanced Testing Features
- Test Markers: unit, integration, e2e, performance, security categorization
- Mock Services: Redis, database, external API mocking with realistic behavior
- Data Generation: Factory patterns, fake data generation, random test data
- Error Scenarios: Exception testing, validation error testing, edge case coverage
- Async Testing: Wait conditions, eventual assertions, retry mechanisms

$3

All templates include comprehensive type hints with Python 3.11+ features:

#### Advanced Typing Features
- Self: Self-referential type annotations for method chaining
- Literal: Exact value type specifications for enhanced safety
- Protocol: Duck typing with structural subtyping
- TypeGuard: Runtime type checking with static analysis support
- Generic: Type variable support for reusable components

#### Framework-Specific Types
- FastAPI: Pydantic models, dependency injection types, route handler types
- Django: Model types, QuerySet types, admin types, form types
- Flask: Blueprint types, request/response types, view function types
- Tornado: Handler types, WebSocket types, async types
- Sanic: Request/response types, middleware types, blueprint types

#### Tool Configuration
- MyPy: Strict type checking with framework-specific overrides
- Pyright: Advanced type analysis with error reporting
- Ruff: Fast linting with type-aware rules and automatic fixes

$3

#### ASP.NET Core Web API Template
`bash
re-shell create enterprise-api --template aspnet-core-webapi
`
Features: Full MVC architecture, Identity framework, JWT authentication, Entity Framework Core, comprehensive middleware
Use Cases: Enterprise applications, complex business logic, team collaboration, comprehensive API development

#### ASP.NET Core Minimal API Template
`bash
re-shell create lightweight-api --template aspnet-core-minimal
`
Features: Functional endpoints, AOT compilation, output caching, rate limiting, high performance
Use Cases: High-throughput APIs, cloud-native services, performance-critical applications

#### Blazor Server Template
`bash
re-shell create full-stack-app --template blazor-server
`
Features: Full-stack .NET development, real-time UI updates, SignalR integration, server-side rendering
Use Cases: Interactive web applications, real-time dashboards, enterprise portals

#### gRPC Service Template
`bash
re-shell create grpc-service --template grpc-service
`
Features: Protocol Buffers, streaming support, performance optimization, cross-platform communication
Use Cases: Microservice communication, high-performance APIs, real-time data streaming

#### Entity Framework Core Template
`bash
re-shell create data-service --template aspnet-efcore
`
Features: Code-first migrations, entity configurations, audit logging, soft delete, advanced relationships
Use Cases: Data-intensive applications, complex domain models, enterprise data management

#### Dapper Template
`bash
re-shell create high-perf-data --template aspnet-dapper
`
Features: High-performance data access, repository pattern, transaction management, SQL optimization
Use Cases: Performance-critical data operations, complex queries, high-throughput systems

#### AutoMapper Template
`bash
re-shell create mapping-service --template aspnet-automapper
`
Features: Object-to-object mapping, custom profiles, validation integration, performance optimization
Use Cases: Complex data transformations, API integration, clean architecture implementations

#### xUnit Testing Template
`bash
re-shell create tested-api --template aspnet-xunit
`
Features: Unit tests, integration tests, test fixtures, FluentAssertions, Moq, test containers
Use Cases: Test-driven development, quality assurance, continuous integration

#### Hot Reload Template
`bash
re-shell create dev-optimized --template aspnet-hotreload
`
Features: dotnet watch integration, development utilities, file monitoring, instant feedback
Use Cases: Rapid development, prototyping, developer productivity optimization

#### Serilog Template
`bash
re-shell create monitored-api --template aspnet-serilog
`
Features: Structured logging, multiple sinks, performance monitoring, audit trails, correlation tracking
Use Cases: Production monitoring, debugging, compliance, performance analysis

#### Swagger/OpenAPI Template
`bash
re-shell create documented-api --template aspnet-swagger
`
Features: Interactive documentation, code generation, XML comments, versioning, authentication schemas
Use Cases: API documentation, client generation, developer portals, integration testing

#### JWT Authentication Template
`bash
re-shell create secure-api --template aspnet-jwt
`
Features: Complete auth system, 2FA, external OAuth, rate limiting, authorization policies
Use Cases: Secure applications, user management, enterprise authentication, compliance

$3

All .NET templates include enterprise-grade capabilities:
- 🔐 Advanced Authentication: JWT with 2FA, external OAuth (Google, Facebook, Microsoft), Identity framework
- 📊 Comprehensive Monitoring: Serilog with multiple sinks (Console, File, Database, Elasticsearch, Seq)
- 🗄️ Database Integration: Entity Framework Core with migrations, Dapper for performance, repository patterns
- 📚 Documentation: Swagger/OpenAPI with code generation, XML documentation, interactive examples
- 🧪 Testing Excellence: xUnit with FluentAssertions, Moq, integration tests, test containers
- ⚡ Development Experience: Hot reload with dotnet watch, file monitoring, development utilities
- 🏗️ Architecture Patterns: Clean architecture, CQRS, repository pattern, dependency injection
- 🛡️ Security: Authorization policies, rate limiting, security headers, CORS configuration
- 📈 Performance: Output caching, Redis integration, AOT compilation, performance monitoring
- 🐳 Infrastructure: Docker support, health checks, configuration management, logging

$3

#### Gin Template
`bash
re-shell create api-service --template go-gin
`
Features: Middleware chain, JWT auth with custom claims, graceful shutdown, structured logging with Zap
Use Cases: REST APIs, microservices, high-performance web services

#### Echo Template
`bash
re-shell create modern-api --template go-echo
`
Features: Minimalist design, powerful routing, built-in middleware, OpenAPI integration
Use Cases: Modern APIs, lightweight services, rapid development

#### Fiber Template
`bash
re-shell create fast-api --template go-fiber
`
Features: Express-inspired API, extreme performance, WebSocket support, built-in monitoring
Use Cases: High-throughput APIs, real-time services, Express developers transitioning to Go

#### Chi Template
`bash
re-shell create composable-api --template go-chi
`
Features: Composable routing, stdlib compatible, lightweight middleware, RESTful design
Use Cases: Clean architecture, composable APIs, standard library focused projects

#### gRPC Template
`bash
re-shell create grpc-service --template go-grpc
`
Features: Protocol Buffers, streaming support, interceptors, service discovery ready
Use Cases: Microservice communication, high-performance RPC, polyglot services

#### Go with sqlx Template
`bash
re-shell create data-service --template go-sqlx
`
Features: Type-safe SQL, prepared statements, transaction support, migration system
Use Cases: Database-centric services, complex queries, performance-critical data operations

$3

All Go templates include enterprise-grade capabilities:
- 🗄️ Database Integration: GORM ORM with migrations, sqlx for raw SQL, connection pooling
- 🔐 Security: JWT authentication, bcrypt password hashing, rate limiting, CORS
- 📊 Monitoring: Structured logging (Zap/Zerolog), Prometheus metrics, health endpoints
- 🧪 Testing: Testify framework, mocking support, coverage reports, benchmarks
- ⚡ Performance: Connection pooling, graceful shutdown, context propagation
- 🛠️ Development: Hot reload with Air, environment config, Docker support
- 🏗️ Architecture: Clean architecture, dependency injection, middleware patterns
- 📚 Documentation: OpenAPI/Swagger integration, inline documentation
- 🐳 DevOps: Multi-stage Docker builds, Alpine Linux, minimal images

$3

#### Ruby on Rails API Template
`bash
re-shell create rest-api --template ruby-rails-api
`
Features: Active Record ORM, JWT authentication, background jobs with Sidekiq, comprehensive testing with RSpec
Use Cases: Full-featured REST APIs, enterprise applications, rapid API development

#### Sinatra Template
`bash
re-shell create lightweight-api --template ruby-sinatra
`
Features: Minimal overhead, modular architecture, ActiveRecord integration, Swagger documentation
Use Cases: Microservices, lightweight APIs, simple web services, prototyping

#### Grape Template
`bash
re-shell create grape-api --template ruby-grape
`
Features: RESTful API framework, parameter validation, entity serialization, automatic documentation
Use Cases: API-only applications, microservices, versioned APIs, high-performance services

$3

All Ruby templates include production-ready capabilities:
- 🗄️ Database Integration: ActiveRecord ORM with migrations, PostgreSQL support, connection pooling
- 🔐 Security: JWT authentication, bcrypt password hashing, Rack::Attack rate limiting
- 📊 Monitoring: Structured logging, health check endpoints, performance monitoring
- 🧪 Testing: RSpec framework, FactoryBot fixtures, database cleaner, coverage reports
- ⚡ Performance: Redis caching, Sidekiq background jobs, connection pooling
- 🛠️ Development: Hot reload with Rerun/Guard, environment management with Dotenv
- 🏗️ Architecture: MVC/REST patterns, modular design, middleware composition
- 📚 Documentation: Swagger/OpenAPI integration, YARD documentation
- 🐳 DevOps: Docker support, multi-stage builds, production configurations

$3

#### Symfony Template
`bash
re-shell create enterprise-api --template php-symfony
`
Features: Full MVC framework, Doctrine ORM, dependency injection, event system, comprehensive testing
Use Cases: Enterprise applications, complex business logic, large teams

#### Laravel Template
`bash
re-shell create rapid-api --template php-laravel
`
Features: Eloquent ORM, artisan CLI, queue system, broadcasting, comprehensive ecosystem
Use Cases: Rapid development, full-featured applications, SaaS platforms

#### Slim Template
`bash
re-shell create micro-api --template php-slim
`
Features: PSR-7/PSR-15 compliant, middleware pipeline, dependency container, minimal footprint
Use Cases: Microservices, APIs, lightweight applications

#### CodeIgniter 4 Template
`bash
re-shell create simple-api --template php-codeigniter
`
Features: MVC pattern, built-in security, database abstraction, RESTful routing
Use Cases: Small to medium projects, learning PHP, rapid prototyping

$3

All PHP templates include modern PHP development features:
- 🏗️ Modern PHP: PHP 8.2+ with typed properties, attributes, enums
- 📦 Composer: Dependency management with autoloading
- 🗄️ Database: Migrations, query builders, ORM integration
- 🧪 Testing: PHPUnit integration, fixtures, code coverage
- 🔐 Security: CSRF protection, XSS filtering, SQL injection prevention
- ⚡ Performance: OPcache, connection pooling, Redis caching
- 🐳 Docker: PHP-FPM, Nginx/Apache, multi-stage builds
- 📊 Monitoring: Error logging, health checks, metrics endpoints

$3

- 💎 Ruby: Rails API, Sinatra, Hanami
- 🔷 Java: Spring Boot (already mentioned above), Quarkus, Micronaut, Vert.x
- ⚡ Elixir: Phoenix, Plug
- 🦀 More Rust frameworks: Tide, Poem

🎯 Microfrontend Templates

Re-Shell CLI provides enterprise-grade microfrontend architecture using Webpack Module Federation, enabling true microfrontend patterns with dynamic loading, independent deployment, and runtime integration.

$3

`bash


Create complete microfrontend platform

re-shell create my-platform --type microfrontend --architecture module-federation

Generate shell application (host)

re-shell create shell-app --template federation-shell --port 3100

Generate microfrontend applications (remotes)

re-shell create react-dashboard --template react-mf --port 3000
re-shell create vue-catalog --template vue-mf --port 3001
re-shell create svelte-analytics --template svelte-mf --port 3002
`

$3

`bash
re-shell create user-dashboard --template react-mf --port 3000
`
Features:
- React 18 with Hooks and Suspense
- Module Federation with dynamic imports
- Error boundaries for isolated failures
- Hot module replacement
- TypeScript support
- Real-time backend integration

Architecture:
- Exposes: ./App component for shell consumption
- Shared: React runtime with singleton pattern
- Independent: Can run standalone or federated

$3

`bash
re-shell create product-catalog --template vue-mf --port 3001
`
Features:
- Vue 3 Composition API
- Reactive state management
- Module Federation integration
- Component-based architecture
- TypeScript support
- Live data binding

Architecture:
- Exposes: ./App Vue component
- Shared: Vue runtime optimization
- Independent: Standalone development capability

$3

`bash
re-shell create analytics-widget --template svelte-mf --port 3002
`
Features:
- Compile-time optimization
- Minimal runtime overhead
- Reactive programming model
- Module Federation support
- Performance-critical rendering

Architecture:
- Exposes: Compiled Svelte components
- Shared: Minimal shared dependencies
- Independent: Ultra-fast standalone execution

$3

`bash
re-shell create enterprise-app --template angular-mf --port 3003
`
Features:
- Angular 17+ with standalone components
- Dependency injection at microfrontend level
- Module Federation with Angular Elements
- Enterprise-grade architecture
- Comprehensive testing framework

Architecture:
- Exposes: Angular Elements for federation
- Shared: Angular runtime with zone isolation
- Independent: Full Angular CLI compatibility

$3

The shell application orchestrates all microfrontends:

`bash
re-shell create platform-shell --template federation-shell
`

Features:
- Dynamic Loading: Load microfrontends on-demand
- Error Boundaries: Isolated failure handling per microfrontend
- Unified Routing: Seamless navigation between microfrontends
- Service Health: Real-time monitoring of all services
- Loading States: Smooth UX during microfrontend loading
- Fallback UI: Graceful degradation when microfrontends fail

$3

`bash


Start complete microfrontend platform

re-shell dev --microfrontends --all

Development with hot reload

re-shell dev --mf-mode development --watch

Production build with optimization

re-shell build --microfrontends --federation --optimize
`

Development Features:
- Independent Development: Teams work on separate microfrontends
- Hot Module Replacement: Live updates without page refresh
- Cross-Framework: Mix React, Vue, Svelte, Angular seamlessly
- Shared Dependencies: Optimized bundle sizes
- Runtime Integration: No build-time coupling

$3

- 🔒 Isolation: Each microfrontend is completely independent
- 📦 Shared Dependencies: Optimized bundle management
- 🔄 Communication: Event-driven inter-app communication
- 🛡️ Error Handling: Graceful degradation and fallbacks
- 🎯 Performance: Lazy loading and code splitting
- 🧪 Testing: Independent testing strategies per microfrontend

🎛️ Core Features

$3

`bash


Create workspace

re-shell init my-platform --type hybrid

Generate microservice

re-shell create user-service --template nestjs-ts --database postgresql

Generate microfrontend

re-shell create user-ui --template react-ts --route /users --port 4001

Generate full-stack feature

re-shell generate feature user-management --include backend,frontend,database
`

$3

`bash


Comprehensive health check

re-shell doctor

Interactive dashboard

re-shell doctor --interactive

Service-specific diagnostics

re-shell doctor user-service --detailed

Performance analysis

re-shell analyze --performance --services all
`

$3

`bash


Start development environment

re-shell dev --all --watch

Hot reload with dependency tracking

re-shell dev --hot-reload --cascade-restart

Debug mode with detailed logging

re-shell dev --debug --log-level verbose

Test all services

re-shell test --all --coverage
`

$3

`bash


Build all services

re-shell build --all --optimize

Docker containerization

re-shell build --docker --multi-stage

Kubernetes deployment

re-shell deploy --target k8s --namespace production

CI/CD pipeline generation

re-shell cicd generate --provider github-actions
`

🎨 Advanced Features

$3

`bash


Install plugins

re-shell plugin install @re-shell/monitoring
re-shell plugin install @re-shell/security-scanner

List available plugins

re-shell plugin marketplace

Create custom plugin

re-shell plugin create my-custom-plugin
`

$3

`bash


Analyze bundle sizes

re-shell analyze bundle --interactive

Performance insights

re-shell analyze performance --report

Dependency analysis

re-shell analyze deps --security-scan
`

$3

`bash


Workspace health check

re-shell workspace doctor

Dependency graph visualization

re-shell workspace graph --interactive

Workspace migration

re-shell workspace migrate --from 0.8.0 --to 0.9.0
`

$3

`bash


Generate API endpoints

re-shell generate api users --crud --auth

Generate database migrations

re-shell generate migration add-user-roles

Generate test suites

re-shell generate tests --coverage 90
`

☁️ DevOps & Deployment

$3

`bash


Docker Compose generation

re-shell docker compose --services all --networks custom

Kubernetes manifests

re-shell k8s generate --helm-charts --monitoring

Service mesh configuration

re-shell service-mesh setup --provider istio
`

$3

`bash


GitHub Actions

re-shell cicd generate --provider github-actions --deploy-to k8s

GitLab CI

re-shell cicd generate --provider gitlab-ci --include-security-scan

Jenkins Pipeline

re-shell cicd generate --provider jenkins --multi-stage
`

$3

`bash


Prometheus & Grafana setup

re-shell monitoring setup --provider prometheus --dashboards included

Distributed tracing

re-shell tracing setup --provider jaeger

Log aggregation

re-shell logging setup --provider elk-stack
`

🏢 Enterprise Features

$3

- Authentication: OAuth2, SAML, JWT, multi-factor authentication
- Authorization: RBAC, ABAC, fine-grained permissions
- Security Scanning: Dependency vulnerabilities, code analysis
- Compliance: SOC2, GDPR, HIPAA ready templates

$3

- Performance Metrics: Real-time service performance monitoring
- Business Intelligence: Custom dashboards and reporting
- Usage Analytics: User behavior and system usage tracking
- Cost Analysis: Resource utilization and cost optimization

$3

- Service Discovery: Consul, Eureka, Kubernetes native
- API Gateway: Kong, Ambassador, Istio integration
- Message Queues: RabbitMQ, Apache Kafka, Redis Streams
- Databases: PostgreSQL, MongoDB, Cassandra, Redis clusters

📋 CLI Commands Reference

$3

| Command | Description | Example |
|---------|-------------|---------|
| init | Initialize workspace | re-shell init my-platform |
| create | Create service/frontend | re-shell create api --template express-ts |
| dev | Start development | re-shell dev --all |
| build | Build services | re-shell build --optimize |
| test | Run tests | re-shell test --coverage |
| deploy | Deploy to environment | re-shell deploy --target production |

$3

| Command | Description | Example |
|---------|-------------|---------|
| doctor | Health diagnostics | re-shell doctor --interactive |
| analyze | Bundle/performance analysis | re-shell analyze --performance |
| generate | Code generation | re-shell generate api users |
| migrate | Migration tools | re-shell migrate --from 0.8.0 |
| plugin | Plugin management | re-shell plugin install monitoring |
| workspace | Workspace operations | re-shell workspace graph |

$3

| Command | Description | Example |
|---------|-------------|---------|
| cicd | CI/CD generation | re-shell cicd generate --provider github |
| docker | Container operations | re-shell docker compose |
| k8s | Kubernetes operations | re-shell k8s generate --helm |
| monitoring | Setup monitoring | re-shell monitoring setup |
| backup | Backup operations | re-shell backup create --full |

⚙️ Configuration

$3

`yaml


~/.re-shell/config.yaml


version: "1.0"
defaults:
packageManager: "pnpm"
framework: "typescript"
containerRuntime: "docker"
kubernetesProvider: "local"
templates:
backend:
default: "express-ts"
security: "strict"
frontend:
default: "react-ts"
bundler: "vite"
plugins:
autoUpdate: true
marketplace: "https://marketplace.re-shell.dev"
`

$3

`yaml


.re-shell/config.yaml


name: "my-platform"
version: "0.9.0"
type: "hybrid" # microservices | microfrontend | hybrid
architecture:
gateway: "nginx"
serviceMesh: "istio"
monitoring: "prometheus"
services:
- name: "user-service"
type: "backend"
template: "express-ts"
port: 3001
- name: "user-dashboard"
type: "frontend"
template: "react-ts"
port: 4001
route: "/dashboard"
`

🎯 Examples

$3

`bash


Initialize e-commerce platform

re-shell init ecommerce-platform --template ecommerce

Backend services

re-shell create user-service --template nestjs-ts --database postgresql
re-shell create product-service --template fastapi --database mongodb
re-shell create order-service --template express-ts --database postgresql
re-shell create payment-service --template spring-boot --database postgresql

Frontend applications

re-shell create admin-dashboard --template react-ts --route /admin
re-shell create customer-portal --template vue-ts --route /shop
re-shell create mobile-app --template react-native

Infrastructure

re-shell cicd generate --provider github-actions
re-shell k8s generate --include monitoring,logging
`

$3

`bash


Initialize fintech platform

re-shell init fintech-platform --template financial-services

Core services

re-shell create account-service --template spring-boot --security high
re-shell create transaction-service --template rust-actix --performance optimized
re-shell create reporting-service --template django --analytics enabled
re-shell create notification-service --template go-gin --realtime

Compliance and security

re-shell security scan --all-services
re-shell compliance check --standard pci-dss
re-shell audit generate --quarterly-report
`

📊 Best Practices

$3

1. Service Boundaries: Define clear service boundaries based on business domains
2. Data Consistency: Use event sourcing for distributed data consistency
3. API Design: Follow REST and GraphQL best practices
4. Security: Implement zero-trust security model
5. Monitoring: Set up comprehensive observability from day one

$3

1. Feature Development: Use feature branches with automated testing
2. Code Review: Implement mandatory code reviews with automated checks
3. Testing Strategy: Follow testing pyramid (unit → integration → e2e)
4. Deployment: Use blue-green or canary deployment strategies
5. Rollback: Always have automated rollback capabilities

$3

1. Caching Strategy: Implement multi-level caching (CDN → Redis → Application)
2. Database Design: Use appropriate database patterns for each service
3. Load Balancing: Implement intelligent load balancing with health checks
4. Resource Management: Monitor and optimize resource utilization
5. Scaling: Design for horizontal scaling from the beginning

🤝 Contributing

We welcome contributions from the community! Please see our Contributing Guide for details.

$3

`bash


Clone the repository

git clone https://github.com/re-shell/cli.git
cd cli

Install dependencies

pnpm install

Build the project

pnpm build

Run tests

pnpm test

Start development

pnpm dev
`

$3

- 🔧 Template Development: Create new microservice/microfrontend templates
- 🐛 Bug Fixes: Help identify and fix issues
- 📚 Documentation: Improve documentation and examples
- 🎨 Features: Implement new CLI features and capabilities
- 🧪 Testing: Improve test coverage and quality
- 🌐 Internationalization: Add support for multiple languages

💬 Support

$3

- GitHub Discussions: https://github.com/re-shell/cli/discussions
- Discord Community: https://discord.gg/re-shell
- Stack Overflow: Tag questions with re-shell-cli`

$3

- Official Documentation: https://docs.re-shell.dev
- API Reference: https://api.re-shell.dev
- Video Tutorials: https://learn.re-shell.dev

$3

For enterprise support, consulting, and custom development:
- Email: enterprise@re-shell.dev
- Website: https://enterprise.re-shell.dev

📄 License

MIT License - see the LICENSE file for details.

🙏 Acknowledgments

- Open Source Community: For the amazing tools and libraries that make this possible
- Contributors: All the developers who have contributed to this project
- Users: The community of developers using Re-Shell CLI in production

📄 License

Re-Shell CLI is open source software released under the MIT License. This means you can:

- ✅ Use it commercially
- ✅ Modify it for your needs
- ✅ Distribute it freely
- ✅ Use it in private projects
- ✅ Sublicense it

See the LICENSE file for the full license text.

---