test-valkey-glide-rb 0.0.1.pre.rc1

data/DEVELOPER.md

@@ -0,0 +1,390 @@
+# Developer Guide
+
+This document describes how to set up your development environment to build and test the Valkey GLIDE Ruby client (`valkey-rb`).
+
+## Development Overview
+
+The Valkey GLIDE Ruby client consists of **Ruby** application code and a **Rust FFI** native library. Ruby talks to [glide-core](https://github.com/valkey-io/valkey-glide/tree/main/glide-core) through the [`glide-ffi`](https://github.com/valkey-io/valkey-glide/tree/main/ffi) crate, exposed as `libglide_ffi.so` (Linux) or `libglide_ffi.dylib` (macOS) via the [`ffi`](https://github.com/ffi/ffi) gem.
+
+| Layer | Technology | Location |
+|-------|------------|----------|
+| Application API | Ruby | `lib/valkey.rb`, `lib/valkey/commands/` |
+| FFI bindings | Ruby FFI | `lib/valkey/bindings.rb` |
+| Native bridge | Rust `cdylib` | `lib/valkey/libglide_ffi.{so,dylib}` |
+| Core driver | Rust `glide-core` | Built from [valkey-glide](https://github.com/valkey-io/valkey-glide) |
+
+This architecture matches the **Go** and **Python sync** clients (C FFI), not the Java (JNI) or Python async (PyO3 + UDS) stacks.
+
+## Project Structure
+
+```text
+valkey-glide-ruby/
+├── lib/
+│   ├── valkey.rb                 # Client, pipelining, response conversion
+│   └── valkey/
+│       ├── bindings.rb           # FFI definitions
+│       ├── native/               # Platform-specific native libraries (in gem)
+│       │   ├── x86_64-unknown-linux-gnu/
+│       │   └── aarch64-unknown-linux-gnu/
+│       ├── commands/             # Command modules per data type
+│       ├── opentelemetry.rb      # OTel init and sampling
+│       ├── pipeline.rb           # Pipeline helper
+│       ├── request_type.rb       # Command enum (maps to glide-core)
+│       ├── response_type.rb      # Response enum
+│       └── errors.rb             # Ruby exception types
+├── valkey-glide/                 # Git submodule (valkey-io/valkey-glide)
+│   └── ffi/                      # Rust FFI crate (build target)
+├── test/
+│   ├── valkey/                   # Standalone server tests
+│   ├── cluster/                  # Cluster tests
+│   ├── lint/                     # Shared lint suites
+│   └── support/helper/           # Test helpers (client, cluster, SSL)
+├── bin/
+│   ├── setup                     # bundle install
+│   └── console                   # IRB with gem loaded
+├── .github/workflows/
+│   ├── CI.yml                    # RuboCop + test matrix
+│   └── cd.yml                    # Build and publish gem
+├── valkey.gemspec
+├── Gemfile
+└── Rakefile                      # test:valkey, test:cluster, native:build
+```
+
+## Prerequisites
+
+### Software Dependencies
+
+- **Ruby** 2.6+ (3.x recommended for development)
+- **Bundler**
+- **git**
+- **Valkey** or Redis OSS (for integration tests)
+- **Docker** (optional; matches CI setup)
+
+To **rebuild** the native FFI library from source:
+
+- **Rust** (`rustup`)
+- **GCC** / Xcode command-line tools
+- **cmake**, **pkg-config**, **openssl** / **libssl-dev**
+- Clone of [valkey-glide](https://github.com/valkey-io/valkey-glide) at a compatible release tag
+
+### Valkey Installation
+
+See the [Valkey installation guide](https://valkey.io/topics/installation/) to install `valkey-server` and `valkey-cli`.
+
+**Ubuntu / Debian (standalone testing):**
+
+```bash
+sudo apt update -y
+sudo apt install -y ruby-full build-essential
+```
+
+**macOS:**
+
+```bash
+brew install ruby
+```
+
+## Clone and Local Setup
+
+```bash
+git clone --recurse-submodules https://github.com/valkey-io/valkey-glide-ruby.git
+cd valkey-glide-ruby
+bin/setup   # runs bundle install
+```
+
+If you've already cloned without submodules:
+
+```bash
+git submodule update --init --recursive
+```
+
+Load the gem from the checkout without installing:
+
+```bash
+export RUBYOPT="-I$(pwd)/lib"
+bundle exec ruby -r valkey -e 'puts Valkey::VERSION'
+```
+
+Interactive console:
+
+```bash
+bundle exec bin/console
+```
+
+## Build Native FFI from Source
+
+This repository includes [valkey-glide](https://github.com/valkey-io/valkey-glide) as a Git submodule. Rake tasks are provided to build the native FFI library.
+
+### Prerequisites for Building
+
+- **Rust toolchain**: Install via [rustup](https://rustup.rs/)
+- **Protobuf compiler**: `protoc` (required for glide-core)
+
+### Build with Rake
+
+```bash
+# Build the native FFI library (release mode)
+rake native:build
+
+# This will:
+# 1. Initialize the valkey-glide submodule if needed
+# 2. Build the Rust FFI library in release mode
+# 3. Output: valkey-glide/ffi/target/release/libglide_ffi.{so,dylib}
+```
+
+### Available Rake Tasks
+
+| Task | Description |
+|------|-------------|
+| `rake native:build` | Build the native FFI library (release mode) |
+| `rake native:build_debug` | Build the native FFI library (debug mode) |
+| `rake native:clean` | Clean native build artifacts |
+| `rake native:submodule` | Initialize/update the valkey-glide submodule |
+| `rake native:package` | Copy built library to `lib/valkey/` for gem packaging |
+
+### Verify the Build
+
+```bash
+bundle exec ruby -e 'require "valkey"; c = Valkey.new; puts c.ping; c.close'
+```
+
+### Updating the Submodule
+
+To update to a newer version of valkey-glide:
+
+```bash
+cd valkey-glide
+git fetch origin
+git checkout v2.4.0  # or desired tag/branch
+cd ..
+git add valkey-glide
+git commit -m "Update valkey-glide submodule to v2.4.0"
+
+# Rebuild the native library
+rake native:build
+```
+
+### Rust Linters (when changing FFI)
+
+From `valkey-glide/ffi/`:
+
+```bash
+rustup component add clippy rustfmt
+cargo clippy --all-features --all-targets -- -D warnings
+cargo fmt --manifest-path ./Cargo.toml --all
+```
+
+See [ffi/README.md](https://github.com/valkey-io/valkey-glide/blob/main/ffi/README.md) in valkey-glide for C header generation (`cbindgen`) if needed.
+
+## Running Tests
+
+Tests use **Minitest**. The suite is split into standalone (`test/valkey/`) and cluster (`test/cluster/`) groups.
+
+### Start Valkey (standalone)
+
+Default test configuration (see `test/test_helper.rb`):
+
+| Variable | Default | Purpose |
+|----------|---------|---------|
+| `VALKEY_PORT` | `6379` | Plain TCP |
+| `VALKEY_SSL_PORT` | `6380` | TLS (optional) |
+| `TIMEOUT` | `5.0` | Client timeout |
+| DB | `15` | Test database |
+
+```bash
+# Example: Docker standalone (matches CI)
+docker run -d --name valkey-test -p 6379:6379 valkey/valkey:8 \
+  valkey-server --enable-module-command yes
+```
+
+### Start Valkey Cluster
+
+Cluster tests expect six nodes on `127.0.0.1:7000`–`7005`. CI uses `grokzen/redis-cluster:7.0.15`.
+
+```bash
+docker run -d --name redis-cluster -p 7000-7005:7000-7005 grokzen/redis-cluster:7.0.15
+```
+
+### Run Tests
+
+```bash
+# All default (standalone) tests
+bundle exec rake test
+# or
+bundle exec rake test:valkey
+
+# Cluster tests only
+bundle exec rake test:cluster
+
+# Verbose output (also enabled when CI=1)
+CI=1 bundle exec rake test:valkey
+```
+
+### SSL Tests
+
+Generate test certificates:
+
+```bash
+ruby test/fixtures/ssl/generate_certs.rb
+```
+
+Start TLS Valkey on port 6380 (see `.github/workflows/CI.yml` for a full Docker example).
+
+### Module Tests (JSON, Bloom, Search)
+
+CI copies prebuilt modules into `test/fixtures/`:
+
+- `redisjson.so` — JSON commands
+- `redisbloom.so` — Bloom filters
+- `redisearch.so` — Vector / FT commands
+
+Load modules when starting Valkey if you run module-specific tests locally.
+
+### Environment Overrides
+
+```bash
+VALKEY_PORT=6379 TIMEOUT=10 bundle exec rake test:valkey
+```
+
+## Linters
+
+### RuboCop
+
+```bash
+bundle exec rubocop
+```
+
+CI runs RuboCop on every push and pull request (see `.github/workflows/CI.yml`).
+
+Auto-correct safe offenses:
+
+```bash
+bundle exec rubocop -A
+```
+
+Configuration: `.rubocop.yml`, `.rubocop_todo.yml`.
+
+## Contributing New Valkey Commands
+
+When adding a command, check whether it already exists in [glide-core](https://github.com/valkey-io/valkey-glide/blob/main/glide-core/src/request_type.rs) and [command_request.proto](https://github.com/valkey-io/valkey-glide/blob/main/glide-core/src/protobuf/command_request.proto). Other language clients (Python, Java, Go) are the reference for semantics and routing.
+
+### Steps
+
+1. **Add `RequestType` constant** in `lib/valkey/request_type.rb` if not present (must match glide-core enum).
+2. **Implement the command** in the appropriate file under `lib/valkey/commands/` (e.g. `string_commands.rb`, `hash_commands.rb`).
+3. **Use `send_command`** with the correct `RequestType` and argument list (all arguments converted to strings for FFI).
+4. **Add standalone tests** in `test/valkey/<group>_commands_test.rb`.
+5. **Add lint tests** in `test/lint/<group>_commands.rb` when the command should match redis-rb behavior.
+6. **Update the wiki** [command implementation status](https://github.com/valkey-io/valkey-glide-ruby/wiki/The-implementation-status-of-the-Valkey-commands).
+
+### Command module layout
+
+| Module file | Valkey command families |
+|-------------|-------------------------|
+| `string_commands.rb` | Strings, counters |
+| `hash_commands.rb` | Hashes |
+| `list_commands.rb` | Lists |
+| `set_commands.rb` | Sets |
+| `sorted_set_commands.rb` | Sorted sets |
+| `stream_commands.rb` | Streams |
+| `bitmap_commands.rb` | Bitmaps |
+| `hyper_log_log_commands.rb` | HyperLogLog |
+| `geo_commands.rb` | Geo |
+| `generic_commands.rb` | Keys, scan, type, … |
+| `connection_commands.rb` | Connection, auth, select |
+| `server_commands.rb` | Server, config, ACL |
+| `scripting_commands.rb` | Lua scripting |
+| `function_commands.rb` | Functions |
+| `transaction_commands.rb` | MULTI, WATCH, … |
+| `pubsub_commands.rb` | Pub/Sub |
+| `cluster_commands.rb` | Cluster administration |
+| `json_commands.rb` | RedisJSON / Valkey JSON |
+| `vector_search_commands.rb` | RediSearch / FT |
+| `module_commands.rb` | MODULE |
+
+### Tests
+
+- **Unit-style command tests**: `test/valkey/*_test.rb` — require a running server.
+- **Lint suites**: `test/lint/*.rb` — included from valkey and cluster tests for API parity checks.
+- **OpenTelemetry**: `test/valkey/test_opentelemetry.rb` — uses file exporter endpoints.
+- **Statistics**: `test/valkey/test_statistics.rb`.
+
+### Documentation in code
+
+Follow existing YARD-style comments in command modules: link to [valkey.io/commands](https://valkey.io/commands/), document parameters and return types, note cluster vs standalone behavior.
+
+## OpenTelemetry Development
+
+OpenTelemetry is configured via `Valkey::OpenTelemetry.init` before client creation. Sampling is applied in Ruby (`should_sample?`); spans are created in FFI (`create_otel_span`, `create_batch_otel_span`).
+
+File exporter example for local debugging:
+
+```ruby
+Valkey::OpenTelemetry.init(
+  traces: { endpoint: "file:///tmp/valkey_traces.json", sample_percentage: 100 },
+  metrics: { endpoint: "file:///tmp/valkey_metrics.json" }
+)
+```
+
+Run OTel tests:
+
+```bash
+bundle exec ruby test/valkey/test_opentelemetry.rb
+```
+
+## CI Overview
+
+GitHub Actions (`.github/workflows/CI.yml`):
+
+| Job | Matrix |
+|-----|--------|
+| `lint` | Ruby 3.3, RuboCop |
+| `standalone` | Ruby 2.6–3.4 + JRuby; Valkey 7.2, 8, 8.1 |
+| `cluster` | Ruby 2.6–3.4; grokzen/redis-cluster |
+
+## Packaging
+
+Release artifacts are built via `valkey.gemspec`:
+
+- Native libraries under `lib/valkey/` are included in the gem.
+- Test files, `bin/`, and `.github/` are excluded from the release.
+
+Build locally:
+
+```bash
+gem build valkey.gemspec
+gem install ./valkey-rb-*.gem
+```
+
+## Troubleshooting
+
+| Problem | Suggestion |
+|---------|------------|
+| `CannotConnectError` | Ensure Valkey is running on the configured host/port; cluster requires all seed nodes. |
+| `LoadError` / FFI library not found | Confirm `lib/valkey/libglide_ffi.{so,dylib}` exists and matches your OS/arch. |
+| Wrong architecture after FFI rebuild | Rebuild `glide-ffi` on the target platform; do not copy Linux `.so` to macOS. |
+| Cluster tests flaky | Wait for `cluster_state:ok`; increase `TIMEOUT` env var. |
+| SSL test failures | Regenerate certs: `ruby test/fixtures/ssl/generate_certs.rb`. |
+| Pipeline / MULTI crashes | Transaction commands in `pipelined` use sequential fallback by design. |
+
+## Recommended Editor Extensions
+
+- [Ruby LSP](https://marketplace.visualstudio.com/items?itemName=Shopify.ruby-lsp) or [Solargraph](https://marketplace.visualstudio.com/items?itemName=castwide.solargraph)
+- [RuboCop](https://marketplace.visualstudio.com/items?itemName=rubocop.vscode-rubocop)
+- [rust-analyzer](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer) — when editing valkey-glide FFI
+
+## Examples
+
+Sample scripts live in [examples/](./examples/). Run from the repo root:
+
+```bash
+bundle exec ruby examples/standalone.rb
+```
+
+See [examples/README.md](./examples/README.md) for Docker setup and environment variables.
+
+## Community and Feedback
+
+Join Valkey Slack: [Join Valkey Slack](https://join.slack.com/t/valkey-oss-developer/shared_invite/zt-2nxs51chx-EB9hu9Qdch3GMfRcztTSkQ).
+
+Contribution guidelines: [CONTRIBUTING.md](./CONTRIBUTING.md). Broader GLIDE process: [valkey-glide CONTRIBUTING.md](https://github.com/valkey-io/valkey-glide/blob/main/CONTRIBUTING.md).

data/README.md

@@ -0,0 +1,268 @@
+# Valkey GLIDE for Ruby
+
+Valkey General Language Independent Driver for the Enterprise (GLIDE) is the official open-source Valkey client library, proudly part of the [Valkey](https://valkey.io) organization. The Ruby gem (`valkey-rb`) wraps [Valkey GLIDE Core](https://github.com/valkey-io/valkey-glide) (Rust) and aims to be a **drop-in replacement for [redis-rb](https://github.com/redis/redis-rb)** while delivering GLIDE performance, reliability, and enterprise features.
+
+## Why Choose Valkey GLIDE?
+
+- **Community and Open Source**: Join our vibrant community and contribute to the project.
+- **Reliability**: Built with best practices learned from over a decade of operating Redis OSS-compatible services.
+- **Performance**: Optimized for high performance and low latency via the Rust-based GLIDE core.
+- **High Availability**: Cluster-aware routing, reconnection, and fault tolerance.
+- **Cross-Language Consistency**: Same core driver as Python, Java, Node.js, and Go clients.
+- **Drop-in Replacement**: Familiar redis-rb-style API (`Valkey.new`, command methods, `pipelined`, URL parsing).
+- **Observability**: Native OpenTelemetry tracing and client statistics.
+
+## Documentation
+
+- **Command coverage**: [Implementation status wiki](https://github.com/valkey-io/valkey-glide-ruby/wiki/The-implementation-status-of-the-Valkey-commands)
+- **Valkey GLIDE overview**: [glide.valkey.io](https://glide.valkey.io/)
+- **Supported engine versions**: [valkey-glide README — Supported Engine Versions](https://github.com/valkey-io/valkey-glide/blob/main/README.md#supported-engine-versions)
+- **Local development**: [DEVELOPER.md](./DEVELOPER.md)
+
+## Supported Engine Versions
+
+| Engine Type | 6.2 | 7.0 | 7.1 | 7.2 | 8.0 | 8.1 | 9.0 |
+|-------------|-----|-----|-----|-----|-----|-----|-----|
+| Valkey      | -   | -   | -   | ✓   | ✓   | ✓   | ✓   |
+| Redis OSS   | ✓   | ✓   | ✓   | ✓   | -   | -   | -   |
+
+## Getting Started — Ruby Wrapper
+
+### System Requirements
+
+The release of Valkey GLIDE Ruby was tested on the following platforms:
+
+**Linux:**
+
+- Ubuntu 20+ (x86_64/amd64 and arm64/aarch64)
+- Amazon Linux 2 (AL2) and 2023 (AL2023) (x86_64)
+
+**Note:** Alpine Linux / MUSL is **not** currently supported.
+
+**macOS:**
+
+- macOS 14.7+ (Apple silicon / aarch64)
+- macOS 13.7+ (x86_64 / amd64)
+
+### Ruby Supported Versions
+
+| Ruby Version | MRI | JRuby |
+|--------------|-----|-------|
+| 2.6          | ✓   | -     |
+| 2.7          | ✓   | -     |
+| 3.0 – 3.4    | ✓   | ✓     |
+
+Minimum Ruby version: **2.6.0** (see `valkey.gemspec`).
+
+### Installation and Setup
+
+Install from RubyGems:
+
+```bash
+gem install valkey-rb
+```
+
+Or add to your `Gemfile`:
+
+```ruby
+gem "valkey-rb"
+```
+
+Verify installation:
+
+```bash
+ruby -e 'require "valkey"; puts Valkey::VERSION'
+```
+
+The gem ships prebuilt native libraries (`libglide_ffi.so` on Linux, `libglide_ffi.dylib` on macOS) and depends on the [`ffi`](https://github.com/ffi/ffi) gem.
+
+## Basic Examples
+
+### Standalone Mode
+
+```ruby
+require "valkey"
+
+client = Valkey.new(host: "localhost", port: 6379)
+
+client.set("mykey", "hello world")
+# => "OK"
+
+client.get("mykey")
+# => "hello world"
+
+client.close
+```
+
+### Standalone with URL (redis-rb compatible)
+
+```ruby
+client = Valkey.new(url: "redis://localhost:6379/0")
+# TLS: rediss://user:password@localhost:6380/0
+
+client.ping
+# => "PONG"
+```
+
+### Cluster Mode
+
+```ruby
+nodes = [
+  { host: "127.0.0.1", port: 7000 },
+  { host: "127.0.0.1", port: 7001 },
+  { host: "127.0.0.1", port: 7002 },
+  { host: "127.0.0.1", port: 7003 },
+  { host: "127.0.0.1", port: 7004 },
+  { host: "127.0.0.1", port: 7005 }
+]
+
+client = Valkey.new(nodes: nodes, cluster_mode: true)
+client.set("foo", "bar")
+client.get("foo")
+# => "bar"
+```
+
+### Pipelining
+
+Batch multiple commands in a single network round trip (non-atomic pipeline):
+
+```ruby
+results = client.pipelined do |pipe|
+  pipe.set("key1", "value1")
+  pipe.get("key1")
+  pipe.incr("counter")
+end
+# => ["OK", "value1", 1]
+```
+
+> **Note:** Transactional commands (`MULTI` / `EXEC` / `DISCARD`) in a pipeline are executed sequentially as a workaround for FFI batch stability. Prefer `multi` / `exec` on the main client for transactions.
+
+### Connection Options (redis-rb compatible)
+
+| Option | Description |
+|--------|-------------|
+| `host`, `port` | Server address (default `127.0.0.1:6379`) |
+| `url` | `redis://` or `rediss://` URI (merged with explicit options) |
+| `db` | Database index (standalone only) |
+| `password`, `username` | Authentication |
+| `timeout` | Request timeout in seconds (default `5.0`) |
+| `connect_timeout` | Connection timeout in seconds |
+| `ssl`, `ssl_params` | TLS (`ca_file`, `cert`, `key`, `ca_path`, `root_certs`) |
+| `cluster_mode` | Enable cluster client |
+| `nodes` | Array of `{ host:, port: }` hashes |
+| `protocol` | `:resp2` (default) or `:resp3` |
+| `client_name` | `CLIENT SETNAME` value |
+| `reconnect_attempts`, `reconnect_delay`, `reconnect_delay_max` | Connection retry strategy |
+
+```ruby
+client = Valkey.new(
+  host: "localhost",
+  port: 6379,
+  timeout: 2.0,
+  connect_timeout: 1.0,
+  client_name: "my-app",
+  protocol: :resp3
+)
+```
+
+## OpenTelemetry
+
+Valkey GLIDE Ruby configures OpenTelemetry in the **native Rust core** (not via the Ruby `opentelemetry-sdk` gem). Initialize once per process before creating clients:
+
+```ruby
+require "valkey"
+
+Valkey::OpenTelemetry.init(
+  traces: {
+    endpoint: "http://localhost:4318/v1/traces",
+    sample_percentage: 10
+  },
+  metrics: {
+    endpoint: "http://localhost:4318/v1/metrics"
+  },
+  flush_interval_ms: 5000
+)
+
+client = Valkey.new(host: "localhost", port: 6379)
+client.set("key", "value")  # traced when sampling applies
+```
+
+**Supported endpoint formats:**
+
+- HTTP/HTTPS: `http://localhost:4318/v1/traces`
+- gRPC: `grpc://localhost:4317`
+- File (testing): `file:///tmp/valkey_traces.json`
+
+OpenTelemetry can only be initialized **once per process**. Spans are created in the FFI layer when sampling is enabled.
+
+## Examples
+
+Runnable examples are in [examples/](./examples/):
+
+```bash
+bundle exec ruby examples/standalone.rb
+bundle exec ruby examples/pipelining.rb
+bundle exec ruby examples/opentelemetry.rb
+```
+
+See [examples/README.md](./examples/README.md) for cluster setup and environment variables.
+
+## Client Statistics
+
+Monitor global client metrics (shared across all clients in the process):
+
+```ruby
+stats = client.get_statistics
+# alias: client.statistics
+
+puts "Connections: #{stats[:total_connections]}"
+puts "Clients: #{stats[:total_clients]}"
+puts "Compressed values: #{stats[:total_values_compressed]}"
+```
+
+Available keys: `:total_connections`, `:total_clients`, `:total_values_compressed`, `:total_values_decompressed`, `:total_original_bytes`, `:total_bytes_compressed`, `:total_bytes_decompressed`, `:compression_skipped_count`.
+
+## Pub/Sub
+
+Pub/Sub uses a native callback registered at connection time. Configure subscriptions via command modules (`subscribe`, `psubscribe`, etc.). See [DEVELOPER.md](./DEVELOPER.md) and integration tests in `test/valkey/pubsub_commands_test.rb` for details.
+
+## Layout of Ruby Code
+
+| Path | Purpose |
+|------|---------|
+| `lib/valkey.rb` | Main client: connection, pipelining, response conversion |
+| `lib/valkey/bindings.rb` | FFI bindings to `libglide_ffi` |
+| `lib/valkey/commands/` | Command modules (strings, hashes, streams, cluster, JSON, vector search, …) |
+| `lib/valkey/opentelemetry.rb` | OpenTelemetry configuration |
+| `lib/valkey/pipeline.rb` | Pipeline command batching |
+| `test/valkey/` | Standalone integration tests |
+| `test/cluster/` | Cluster integration tests |
+| `test/lint/` | Shared lint tests (redis-rb compatibility patterns) |
+
+## redis-rb Compatibility
+
+This client mirrors redis-rb conventions where possible:
+
+- `Valkey.new` with `url`, `host`, `port`, `db`, `ssl_params`
+- Command method names and argument ordering aligned with redis-rb
+- `pipelined`, `multi` / `exec`, `disconnect!` (alias of `close`)
+
+Not every redis-rb API is implemented yet. See the [command implementation wiki](https://github.com/valkey-io/valkey-glide-ruby/wiki/The-implementation-status-of-the-Valkey-commands) for coverage.
+
+## Building and Testing
+
+Instructions for building from source, updating the FFI library, running tests, and contributing are in [DEVELOPER.md](./DEVELOPER.md).
+
+For AI-assisted development, see [AGENTS.md](./AGENTS.md) and [CLAUDE.md](./CLAUDE.md).
+
+Contributing: [CONTRIBUTING.md](./CONTRIBUTING.md).
+
+## Community and Feedback
+
+We encourage you to join our community to support, share feedback, and ask questions on Valkey Slack: [Join Valkey Slack](https://join.slack.com/t/valkey-oss-developer/shared_invite/zt-2nxs51chx-EB9hu9Qdch3GMfRcztTSkQ).
+
+Report issues: [valkey-glide-ruby issues](https://github.com/valkey-io/valkey-glide-ruby/issues).
+
+## License
+
+Apache-2.0 — see [LICENSE](https://github.com/valkey-io/valkey-glide-ruby/blob/main/LICENSE) in the repository.