Update website documentation to reflect current Echo v4 state

- Updated Go version requirement from 1.13 to 1.20 in quick-start guide
- Enhanced Hello World example with proper middleware setup
- Improved introduction to focus on examples repository purpose
- Added comprehensive example categorization and better resource links
- Enhanced graceful shutdown documentation with implementation details
- Improved JWT authentication cookbook with clearer feature descriptions
- Added CLAUDE.md file for future development guidance

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: vishr

CLAUDE.md

@@ -0,0 +1,83 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Echo Extra (echox) is a collection of examples and recipes for the Echo web framework in Go. This repository contains:
+
+- **cookbook/**: Complete example applications demonstrating various Echo features (22 examples including JWT, CORS, WebSocket, file upload/download, graceful shutdown, etc.)
+- **website/**: Docusaurus-based documentation website
+
+## Development Commands
+
+### Go Development
+```bash
+# Run tests with race detection
+go test -race ./...
+
+# Or use the Makefile
+make test
+
+# Run individual cookbook examples
+cd cookbook/<example-name>
+go run server.go
+```
+
+### Website Development
+```bash
+# Navigate to website directory first
+cd website
+
+# Install dependencies
+npm install
+
+# Start development server (http://localhost:3000)
+npm start
+
+# Build for production
+npm run build
+
+# Serve built site
+npm run serve
+
+# Alternative: run website in Docker
+make serve
+# or
+docker run --rm -it --name echo-docs -v ${PWD}/website:/home/app -w /home/app -p 3000:3000 -u node node:lts /bin/bash -c "npm install && npm start -- --host=0.0.0.0"
+```
+
+## Architecture
+
+### Cookbook Structure
+Each cookbook example is a standalone Go application in its own directory under `cookbook/`. Examples follow a consistent pattern:
+- `server.go` - Main application entry point using Echo v4
+- Additional files for complex examples (handlers, models, etc.)
+- Standard Echo patterns: middleware setup, route definitions, handler functions
+
+### Key Dependencies
+- **Echo v4** (`github.com/labstack/echo/v4`) - Core web framework
+- **JWT libraries** - Multiple JWT implementations for authentication examples
+- **WebSocket** (`github.com/gorilla/websocket`) - Real-time communication
+- **Go 1.20+** - Minimum Go version requirement
+
+### Website Architecture
+- **Docusaurus 3.1.0** - Static site generator
+- **React 18.2.0** - UI framework
+- **MDX** - Markdown with JSX support
+- Custom GitHub codeblock theme for syntax highlighting
+
+## Development Workflow
+
+1. **For cookbook examples**: Navigate to specific example directory and run `go run server.go`
+2. **For website changes**: Work in `website/` directory using npm commands
+3. **Testing**: Use `make test` or `go test -race ./...` to run all Go tests
+4. **Local preview**: Use `npm start` in website directory or `make serve` for Docker-based development
+
+## Project Context
+
+This is an examples/recipes repository rather than a library. Focus on:
+- Complete, runnable examples in cookbook/
+- Clear documentation and code comments
+- Following Echo v4 best practices and patterns
+- Maintaining consistency across examples

website/docs/cookbook/graceful-shutdown.md

@@ -4,14 +4,23 @@ description: Graceful shutdown recipe
 
 # Graceful Shutdown
 
-## Using [http.Server#Shutdown()](https://golang.org/pkg/net/http/#Server.Shutdown)
+This example demonstrates how to implement graceful shutdown using Go's `signal.NotifyContext` and Echo's `Shutdown` method to handle interrupt signals properly.
+
+## Using [signal.NotifyContext](https://pkg.go.dev/os/signal#NotifyContext) and [Echo.Shutdown](https://pkg.go.dev/github.com/labstack/echo/v4#Echo.Shutdown)
 
 ```go reference
 https://github.com/labstack/echox/blob/master/cookbook/graceful-shutdown/server.go
 ```
 
+### Key Features
+
+- Uses `signal.NotifyContext` to listen for OS interrupt signals (Ctrl+C)
+- Starts the server in a goroutine to allow non-blocking execution
+- Implements a 10-second timeout for graceful shutdown
+- Properly handles server shutdown errors
+
 :::note
 
-Requires go1.16+
+Requires Go 1.16+ for `signal.NotifyContext`. For earlier versions, use `signal.Notify` with a channel.
 
 :::

website/docs/cookbook/jwt.md

@@ -1,14 +1,18 @@
 ---
-description: JWT recipe
+description: JWT authentication examples
 ---
 
-# JWT
+# JWT Authentication
 
-[JWT middleware](../middleware/jwt.md) configuration can be found [here](../middleware/jwt.md#configuration).
+This cookbook demonstrates JWT (JSON Web Token) authentication patterns using Echo's JWT middleware. Examples include both basic authentication flows and advanced usage with custom claims and key functions.
+
+**Key Features:**
+- JWT authentication using HS256 algorithm
+- Token retrieval from `Authorization` request header
+- Custom claims handling
+- User-defined key functions for advanced scenarios
 
-This is cookbook for:
-- JWT authentication using HS256 algorithm.
-- JWT is retrieved from `Authorization` request header.
+[JWT middleware](../middleware/jwt.md) configuration can be found [here](../middleware/jwt.md#configuration).
 
 ## Server
 

website/docs/guide/quick-start.md

@@ -10,20 +10,14 @@ sidebar_position: 1
 
 ### Requirements
 
-To install Echo [Go](https://go.dev/doc/install) 1.13 or higher is required. Go 1.12 has limited support and some middlewares will not be available. Make sure your project folder is outside your $GOPATH.
+To install Echo [Go](https://go.dev/doc/install) 1.20 or higher is required. Make sure your project folder is outside your $GOPATH and uses Go modules.
 
 ```sh
 $ mkdir myapp && cd myapp
 $ go mod init myapp
 $ go get github.com/labstack/echo/v4
 ```
 
-If you are working with Go v1.14 or earlier use:
-
-```sh
-$ GO111MODULE=on go get github.com/labstack/echo/v4
-```
-
 ## Hello, World!
 
 Create `server.go`
@@ -33,15 +27,25 @@ package main
 
 import (
 	"net/http"
-	
+
 	"github.com/labstack/echo/v4"
+	"github.com/labstack/echo/v4/middleware"
 )
 
 func main() {
+	// Echo instance
 	e := echo.New()
+
+	// Middleware
+	e.Use(middleware.Logger())
+	e.Use(middleware.Recover())
+
+	// Routes
 	e.GET("/", func(c echo.Context) error {
 		return c.String(http.StatusOK, "Hello, World!")
 	})
+
+	// Start server
 	e.Logger.Fatal(e.Start(":1323"))
 }
 ```

website/docs/introduction.md

@@ -5,30 +5,38 @@ slug: /
 
 # Introduction
 
-## ![LabStack](../static/img/labstack-icon.png) Echo Project
+## ![LabStack](../static/img/labstack-icon.png) Echo Examples
 
-The Echo project is a powerful and versatile web framework for building scalable and high-performance web applications in the Go programming language. It follows the principles of simplicity, flexibility, and performance to provide developers with an efficient toolkit for building robust web applications.
+Echo Examples (echox) provides a comprehensive collection of practical examples and recipes for the Echo web framework. This repository demonstrates real-world usage patterns and best practices for building high-performance web applications with Echo v4.
 
-## Key Features
+## What You'll Find Here
 
-- **Fast and Lightweight**: Echo is designed for speed and efficiency, ensuring minimal overhead and high performance for handling HTTP requests and responses.
-- **Routing**: The framework offers a flexible and intuitive routing system that allows developers to define routes with parameters, query strings, and custom handlers.
-- **Middleware Support**: Echo provides extensive middleware support, enabling developers to easily implement cross-cutting concerns such as logging, authentication, error handling, and more.
-- **Context-based Request Handling**: With its context-based request handling, Echo offers easy access to request-specific data and parameters, simplifying the development of web applications.
-- **Powerful Template Rendering**: Echo includes a powerful template rendering engine that supports various template languages, allowing developers to generate dynamic HTML content effortlessly.
-- **Validation and Binding**: The framework provides robust validation and data binding capabilities, making it straightforward to validate incoming request data and bind it to Go structs.
-- **Extensibility**: Echo is highly extensible, with support for custom middleware, template engines, and other components, enabling developers to tailor the framework to their specific needs.
-- **Community and Ecosystem**: The Echo project benefits from a vibrant and active community that contributes libraries, plugins, and extensions, fostering an ecosystem of reusable components.
+- **22 Complete Examples**: From basic "Hello World" to advanced features like JWT authentication, WebSocket connections, and graceful shutdown
+- **Real-World Patterns**: Practical implementations of common web development scenarios
+- **Best Practices**: Production-ready code following Echo v4 conventions
+- **Modern Go**: Examples using Go 1.20+ features and current idiomatic patterns
 
-## Resources and Documentation
+## Example Categories
+
+- **Authentication & Security**: JWT, CORS, basic auth implementations
+- **File Operations**: Upload, download, and static file serving
+- **Real-time Communication**: WebSocket examples
+- **Advanced Routing**: Subdomain routing, reverse proxy, load balancing
+- **Deployment**: Auto TLS, Google App Engine, graceful shutdown
+- **Data Handling**: CRUD operations, form processing, JSON/XML binding
 
-To learn more about the Echo project, you can refer to the following resources:
+## Getting Started
 
-- Official Website: [https://echo.labstack.com](https://echo.labstack.com)
-- GitHub Repository: [https://github.com/labstack/echo](https://github.com/labstack/echo)
-- Documentation: [https://echo.labstack.com/docs](https://echo.labstack.com/guide)
-- Community Forum: [https://github.com/labstack/echo/discussions](https://github.com/labstack/echo/discussions)
+1. **Browse Examples**: Explore the cookbook section to find examples relevant to your use case
+2. **Run Locally**: Each example can be run independently with `go run server.go`
+3. **Learn Patterns**: Study the implementation patterns and adapt them to your projects
+
+## Resources and Documentation
 
-The Echo project offers an array of features that empower developers to build robust web applications. Its fast and lightweight nature ensures optimal performance, while the flexible routing system and middleware support streamline development processes. Developers can leverage the context-based request handling, powerful template rendering, and validation capabilities to create dynamic and secure web applications. Additionally, the extensibility of Echo allows developers to customize and enhance the framework to suit their specific needs.
+- **Echo Framework**: [https://echo.labstack.com](https://echo.labstack.com)
+- **Echo GitHub**: [https://github.com/labstack/echo](https://github.com/labstack/echo)
+- **Examples Repository**: [https://github.com/labstack/echox](https://github.com/labstack/echox)
+- **Community Discussions**: [https://github.com/labstack/echo/discussions](https://github.com/labstack/echo/discussions)
+- **API Documentation**: [https://pkg.go.dev/github.com/labstack/echo/v4](https://pkg.go.dev/github.com/labstack/echo/v4)
 
-Join the vibrant community of Echo developers, explore the vast ecosystem of plugins and extensions, and unleash the power of Echo for your web development needs.
+Each example in this collection demonstrates production-ready code that you can use as a foundation for your own applications. The examples cover common web development scenarios and showcase Echo's capabilities in real-world contexts.