@re-shell/cli/README.md

Full-stack development platform uniting microservices and microfrontends. Build complete applications with .NET (ASP.NET Core Web API, Minimal API), Java (Spring Boot, Quarkus, Micronaut, Vert.x), Rust (Actix-Web, Warp, Rocket, Axum), Python (FastAPI, Dja

# 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.

[![Version](https://img.shields.io/npm/v/@re-shell/cli.svg)](https://www.npmjs.com/package/@re-shell/cli)
[![License](https://img.shields.io/npm/l/@re-shell/cli.svg)](https://github.com/re-shell/cli/blob/main/LICENSE)
[![Build Status](https://img.shields.io/github/workflow/status/re-shell/cli/CI)](https://github.com/re-shell/cli/actions)
[![Coverage](https://img.shields.io/codecov/c/github/re-shell/cli)](https://codecov.io/gh/re-shell/cli)
[![Downloads](https://img.shields.io/npm/dm/@re-shell/cli.svg)](https://www.npmjs.com/package/@re-shell/cli)

## 🚀 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.

### Key Capabilities

- **🎯 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

### 🆕 What's New in v0.27.0

- **🌍 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

### Previous Releases

#### 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

### Previous Releases

#### 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](#-quick-start)
- [Architecture](#-architecture)
- [Microservices Templates](#-microservices-templates)
- [Microfrontend Templates](#-microfrontend-templates)
- [Core Features](#-core-features)
- [Advanced Features](#-advanced-features)
- [DevOps & Deployment](#-devops--deployment)
- [Enterprise Features](#-enterprise-features)
- [CLI Commands Reference](#-cli-commands-reference)
- [Configuration](#-configuration)
- [Examples](#-examples)
- [Best Practices](#-best-practices)
- [Contributing](#-contributing)
- [Support](#-support)

## 🚀 Quick Start

### Installation

```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
```

### Create Your First Full-Stack Application

```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
```

### How Re-Shell Works

#### 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

### Launch Development Environment

```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     │                │
│  └─────────────┘ └─────────────┘ └─────────────┘                │
└─────────────────────────────────────────────────────────────────┘
```

### Architecture Principles

- **🔌 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

### Node.js Ecosystem ✅ **Complete**

#### 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

### Python Ecosystem ✅ **Complete**

#### 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

### 🧪 Python Testing Excellence

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

### 🎯 Modern Python Type System

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

### 🔷 .NET Ecosystem ✅ **Complete**

#### 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

### 🔷 .NET Universal Features

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

### 🐹 Go Ecosystem ✅ **Complete**

#### 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

### 🐹 Go Universal Features

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

### 💎 Ruby Ecosystem ✅ **Complete**

#### 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

### 💎 Ruby Universal Features

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

### 🐘 PHP Ecosystem ✅ **Complete**

#### 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

### 🐘 PHP Universal Features

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

### Additional Languages *(Roadmap)*

- **💎 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.

### 🏗️ **Module Federation Architecture**

```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
```

### ⚛️ **React Microfrontend**

```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

### 🟢 **Vue.js Microfrontend**

```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

### 🔥 **Svelte Microfrontend**

```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

### 🅰️ **Angular Microfrontend** *(Enterprise Ready)*

```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

### 🏠 **Shell Application (Host)**

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

### 🔧 **Development Experience**

```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

### 📊 **Best Practices Implementation**

- **🔒 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

### 🏗️ **Project Generation**

```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
```

### 📊 **Health Diagnostics & Monitoring**

```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
```

### 🔄 **Development Workflow**

```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
```

### 🚀 **Build & Deployment**

```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

### 🔌 **Plugin Ecosystem**

```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
```

### 📈 **Bundle Analysis & Optimization**

```bash
# Analyze bundle sizes
re-shell analyze bundle --interactive

# Performance insights
re-shell analyze performance --report

# Dependency analysis
re-shell analyze deps --security-scan
```

### 🔄 **Workspace Management**

```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
```

### 🛠️ **Code Generation**

```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

### 🐳 **Container Orchestration**

```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
```

### 🔄 **CI/CD Pipeline Generation**

```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
```

### 📊 **Monitoring & Observability**

```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

### 🛡️ **Security & Compliance**

- **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

### 📊 **Analytics & Reporting**

- **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

### 🔧 **Enterprise Integration**

- **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

### Core Commands

| 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` |

### Advanced Commands

| 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` |

### DevOps Commands

| 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

### Global Configuration

```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"
```

### Project Configuration

```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

### E-Commerce Platform

```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
```

### Financial Services Platform

```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

### 🏗️ **Architecture Guidelines**

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

### 🔄 **Development Workflow**

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

### 📊 **Performance Optimization**

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](CONTRIBUTING.md) for details.

### Development Setup

```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
```

### Contribution Areas

- 🔧 **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

### Community Support

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

### Documentation

- **Official Documentation**: [https://docs.re-shell.dev](https://docs.re-shell.dev)
- **API Reference**: [https://api.re-shell.dev](https://api.re-shell.dev)
- **Video Tutorials**: [https://learn.re-shell.dev](https://learn.re-shell.dev)

### Enterprise Support

For enterprise support, consulting, and custom development:
- **Email**: enterprise@re-shell.dev
- **Website**: [https://enterprise.re-shell.dev](https://enterprise.re-shell.dev)

## 📄 License

MIT License - see the [LICENSE](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](./LICENSE) file for the full license text.

---

<div align="center">

**[Website](https://re-shell.dev)** •
**[Documentation](https://docs.re-shell.dev)** •
**[Examples](https://examples.re-shell.dev)** •
**[Community](https://community.re-shell.dev)**

Made with ❤️ by the Re-Shell Team | Open Source MIT License

</div>