opencode-skills-collection 3.1.12 → 3.1.13

package/bundled-skills/redis-cli/references/advanced-features.md

@@ -0,0 +1,338 @@
+# Advanced Features
+
+## Table of Contents
+
+- [Lua Scripting](#lua-scripting)
+- [Pub/Sub Mode](#pubsub-mode)
+- [Pipe Mode](#pipe-mode)
+- [CSV and JSON Output](#csv-and-json-output)
+- [Getting Input from Other Programs](#getting-input-from-other-programs)
+- [Cluster Management](#cluster-management)
+
+## Lua Scripting
+
+Redis supports server-side Lua scripting for atomic multi-command operations.
+
+### Running Scripts
+
+```bash
+# Run script from file with --eval
+redis-cli --eval /tmp/script.lua key1 key2 , arg1 arg2 arg3
+
+# The comma separates KEYS[] from ARGV[]:
+# key1, key2 → KEYS[1], KEYS[2]
+# arg1, arg2, arg3 → ARGV[1], ARGV[2], ARGV[3]
+
+# Inline EVAL
+redis-cli EVAL "return redis.call('SET', KEYS[1], ARGV[1])" 1 mykey myvalue
+
+# EVALSHA (use SHA1 hash of cached script)
+redis-cli EVALSHA <sha1> numkeys key [key ...] arg [arg ...]
+```
+
+### Lua Script Examples
+
+```lua
+-- Conditional SET (only if value matches)
+local current = redis.call('GET', KEYS[1])
+if current == ARGV[1] then
+  return redis.call('SET', KEYS[1], ARGV[2])
+end
+return nil
+
+-- Atomic counter reset
+local old = redis.call('GET', KEYS[1])
+redis.call('SET', KEYS[1], ARGV[1])
+return old
+
+-- Multi-key operation
+local results = {}
+for i = 1, #KEYS do
+  results[i] = redis.call('GET', KEYS[i])
+end
+return results
+```
+
+### Lua Debugger
+
+```bash
+# Enable debugger (--ldb)
+redis-cli --ldb --eval /tmp/script.lua key1 , arg1
+
+# Synchronous mode (blocks server — for debugging only)
+redis-cli --ldb-sync-mode --eval /tmp/script.lua key1 , arg1
+```
+
+**Async mode** (default): server continues serving other clients during debugging. Script changes are rolled back from server memory after debugging.
+
+**Sync mode**: server is blocked. Script changes persist in server memory. Use only in development.
+
+### Script Management
+
+```bash
+redis-cli SCRIPT EXISTS sha1 [sha1 ...]    # Check if scripts are cached
+redis-cli SCRIPT FLUSH [ASYNC|SYNC]        # Clear script cache
+redis-cli SCRIPT LOAD script               # Cache script, return SHA1
+redis-cli SCRIPT KILL                      # Kill running script (only if no write)
+```
+
+### Function API (Redis 7.0+)
+
+Functions are a persistent alternative to scripts:
+
+```bash
+redis-cli FUNCTION LOAD "redis.register_function('myfunc', function(keys, args) ... end)"
+redis-cli FCALL myfunc 0 arg1 arg2
+redis-cli FUNCTION LIST
+redis-cli FUNCTION DELETE myfunc
+redis-cli FUNCTION FLUSH [ASYNC|SYNC]
+redis-cli FUNCTION DUMP                    # Serialize all functions
+redis-cli FUNCTION RESTORE serialized-data # Restore functions
+```
+
+## Pub/Sub Mode
+
+redis-cli can publish and subscribe to Redis Pub/Sub channels.
+
+### Subscribing
+
+```bash
+# Subscribe to specific channels
+redis-cli SUBSCRIBE channel1 channel2
+
+# Pattern subscription
+redis-cli PSUBSCRIBE '*'
+
+# Read published messages (blocks until Ctrl-C)
+# Output format:
+# 1) "pmessage"    — message type
+# 2) "*"           — pattern matched
+# 3) "mychannel"   — channel name
+# 4) "mymessage"   — message content
+```
+
+### Publishing
+
+```bash
+redis-cli PUBLISH mychannel "Hello World"
+```
+
+### Inspecting Pub/Sub
+
+```bash
+redis-cli PUBSUB CHANNELS [pattern]        # List active channels
+redis-cli PUBSUB NUMSUB [channel ...]       # Subscriber count per channel
+redis-cli PUBSUB NUMPAT                     # Pattern subscription count
+redis-cli PUBSUB SHARDCHANNELS [pattern]    # List shard channels
+redis-cli PUBSUB SHARDNUMSUB [channel ...]  # Shard channel subscriber count
+```
+
+### Shard Pub/Sub (Redis 7.0+)
+
+Shard Pub/Sub routes messages to the cluster node that owns the channel's slot, providing better scalability:
+
+```bash
+redis-cli SSUBSCRIBE shardchannel
+redis-cli SUNSUBSCRIBE shardchannel
+redis-cli SPUBLISH shardchannel "message"
+```
+
+## Pipe Mode
+
+Transfer raw Redis protocol from stdin to the server. This is the fastest way to bulk-insert data.
+
+```bash
+# Basic pipe mode
+cat data.protocol | redis-cli --pipe
+
+# Custom timeout (seconds)
+cat data.protocol | redis-cli --pipe --pipe-timeout 60
+
+# Zero timeout (wait forever)
+cat data.protocol | redis-cli --pipe --pipe-timeout 0
+```
+
+### Protocol Format
+
+Each command in the pipe file must use Redis protocol:
+
+```
+*<number-of-arguments>\r\n
+$<length-of-argument>\r\n
+<argument-data>\r\n
+```
+
+Example — `SET mykey myvalue`:
+```
+*3\r\n$3\r\nSET\r\n$5\r\nmykey\r\n$7\r\nmyvalue\r\n
+```
+
+Pipe mode is dramatically faster than individual commands because it batches network round trips. See the [mass insertion guide](https://redis.io/docs/latest/develop/clients/patterns/bulk-loading/) for generating protocol files.
+
+## CSV and JSON Output
+
+### CSV Output
+
+Single-command CSV output for data export:
+
+```bash
+redis-cli --csv LRANGE mylist 0 -1
+# "d","c","b","a"
+
+redis-cli --csv HGETALL user:1
+# "name","Alice","age","30"
+```
+
+**Note:** `--csv` works per command, not for exporting entire databases.
+
+### JSON Output
+
+JSON output using RESP3 protocol:
+
+```bash
+# JSON output (uses RESP3 by default)
+redis-cli --json HGETALL user:1
+# {"name": "Alice", "age": "30"}
+
+# Use with RESP2 if needed
+redis-cli --json -2 HGETALL user:1
+
+# ASCII-safe quoted strings (no Unicode)
+redis-cli --quoted-json GET mykey
+```
+
+### Pipe Commands to Other Tools
+
+```bash
+# Format and filter output
+redis-cli --raw GET mykey | jq .
+
+# Export to file
+redis-cli --csv LRANGE mylist 0 -1 > output.csv
+
+# Use with grep
+redis-cli MONITOR | grep "SET"
+```
+
+## Getting Input from Other Programs
+
+### Read Last Argument from stdin (-x)
+
+```bash
+# Set key to contents of a file
+cat /etc/services | redis-cli -x SET net_services
+
+# Check the stored value
+redis-cli GETRANGE net_services 0 50
+```
+
+### Read Tagged Argument from stdin (-X)
+
+```bash
+# Dump and restore a key atomically
+redis-cli -D "" --raw dump mykey > /tmp/mykey.dump
+redis-cli -X dump_tag restore mykey2 0 dump_tag replace < /tmp/mykey.dump
+```
+
+### Pipe Multiple Commands
+
+```bash
+# Execute commands from a text file
+cat /tmp/commands.txt | redis-cli
+
+# commands.txt format (one command per line):
+# SET item:3374 100
+# INCR item:3374
+# APPEND item:3374 xxx
+# GET item:3374
+```
+
+### Feed Continuous Data
+
+```bash
+# Generate keys continuously
+while true; do
+  echo "SET timestamp:$(date +%s) $(date -Iseconds)"
+done | redis-cli --pipe
+```
+
+## Cluster Management
+
+redis-cli provides built-in cluster management via `--cluster` subcommands, plus direct cluster commands for lower-level control.
+
+### redis-cli Cluster Operations
+
+```bash
+# Create a new cluster (interactive prompts for replication)
+redis-cli --cluster create host1:port1 host2:port2 host3:port3 --cluster-replicas 1
+
+# Check cluster state
+redis-cli --cluster check host1:port1
+
+# Show cluster info
+redis-cli --cluster info host1:port1
+
+# Reshard (move slots between nodes)
+redis-cli --cluster reshard host1:port1 --cluster-from <node-id> --cluster-to <node-id> --cluster-slots <n>
+
+# Rebalance slots across all nodes
+redis-cli --cluster rebalance host1:port1
+
+# Add a node to the cluster
+redis-cli --cluster add-node new-host:new-port existing-host:existing-port
+# As replica:
+redis-cli --cluster add-node new-host:new-port existing-host:existing-port --cluster-slave --cluster-master-id <id>
+
+# Remove a node
+redis-cli --cluster del-node host:port <node-id>
+
+# Fix cluster issues (missing slots, etc.)
+redis-cli --cluster fix host:port
+
+# Execute command on all cluster nodes
+redis-cli --cluster call host:port <command>
+
+# List all --cluster subcommands
+redis-cli --cluster help
+```
+
+Use `-c` flag to enable cluster mode in redis-cli (automatically follows `-ASK` and `-MOVED` redirections):
+
+```bash
+redis-cli -c -h cluster-node -p 6379
+```
+
+### Cluster Commands (Direct)
+
+```bash
+# Cluster state and topology
+redis-cli CLUSTER INFO                        # Cluster state overview (O(1))
+redis-cli CLUSTER NODES                       # Full node topology (O(N))
+redis-cli CLUSTER SHARDS                      # Shard/node mapping (O(N), Redis 7.0+)
+
+# Slot management
+redis-cli CLUSTER KEYSLOT key                 # Hash slot for a key (O(1))
+redis-cli CLUSTER ADDSLOTS slot [slot ...]    # Assign slots to node (O(N))
+redis-cli CLUSTER DELSLOTS slot [slot ...]    # Unbind slots (O(N))
+redis-cli CLUSTER SETSLOT slot IMPORTING|node-id|MIGRATING|STABLE  # Slot migration (O(1))
+
+# Node management
+redis-cli CLUSTER MEET ip port [bus-port]     # Join cluster (O(1))
+redis-cli CLUSTER FORGET node-id              # Remove node (O(1))
+redis-cli CLUSTER REPLICATE node-id           # Become replica of node (O(1))
+redis-cli CLUSTER RESET [HARD|SOFT]           # Reset cluster state (O(N))
+
+# Failover
+redis-cli CLUSTER FAILOVER [FORCE|TAKEOVER]   # Manual failover (O(1))
+redis-cli CLUSTER SAVECONFIG                  # Save config to disk (O(1))
+
+# Node identification
+redis-cli CLUSTER MYID                        # Current node ID (O(1))
+redis-cli CLUSTER MYSHARDID                   # Current shard ID (O(1))
+```
+
+**Behavioral notes:**
+- Redis Cluster has 16384 hash slots distributed across master nodes
+- `CLUSTER SLOTS` is deprecated since Redis 7.0 — use `CLUSTER SHARDS` instead
+- Use `redis-cli -c` for transparent cluster redirections in interactive mode
+- `CLUSTER FORGET` auto-propagates via gossip in Redis 7.2+

package/bundled-skills/redis-cli/references/connection-and-options.md

@@ -0,0 +1,258 @@
+# Connection and CLI Options
+
+## Table of Contents
+
+- [Connection Methods](#connection-methods)
+- [CLI Flags Reference](#cli-flags-reference)
+- [Environment Variables](#environment-variables)
+- [SSL/TLS Configuration](#ssltls-configuration)
+- [Interactive Mode](#interactive-mode)
+- [String Quoting and Escaping](#string-quoting-and-escaping)
+
+## Connection Methods
+
+### Basic Connection
+
+By default, redis-cli connects to `127.0.0.1:6379` with no password.
+
+```bash
+# Default connection
+redis-cli
+
+# Custom host and port
+redis-cli -h redis15.localnet.org -p 6390 PING
+
+# Password authentication
+redis-cli -a myUnguessablePazzzzzword123 PING
+
+# ACL-style authentication (Redis 6+)
+redis-cli --user admin --pass myPassword PING
+
+# Specific database number
+redis-cli -n 2 DBSIZE
+```
+
+### URI Connection
+
+```bash
+# Full URI format
+redis-cli -u redis://user:password@host:port/dbnum PING
+
+# Without username (use "default")
+redis-cli -u redis://default:password@localhost:6379/0 PING
+
+# TLS scheme
+redis-cli -u rediss://default:password@redis.example.com:6380/0 PING
+
+# Minimal URI
+redis-cli -u redis://localhost:6379 PING
+```
+
+User, password, and dbnum are optional in the URI. For TLS, use the `rediss://` scheme.
+
+### IPv4/IPv6 Preference
+
+```bash
+redis-cli -4 PING   # Prefer IPv4
+redis-cli -6 PING   # Prefer IPv6
+```
+
+## CLI Flags Reference
+
+```
+Usage: redis-cli [OPTIONS] [cmd [arg [arg ...]]]
+
+Connection:
+  -h <hostname>      Server hostname (default: 127.0.0.1)
+  -p <port>          Server port (default: 6379)
+  -t <timeout>       Connection timeout in seconds (decimals allowed, default: 0 = no limit)
+  -s <socket>        Unix socket (overrides hostname and port)
+  -a <password>      Password (also via REDISCLI_AUTH env var)
+  --user <username>  ACL username (requires -a)
+  --pass <password>  Alias of -a
+  --askpass          Prompt for password from STDIN (ignores -a and REDISCLI_AUTH)
+  -u <uri>           Connection URI: redis://user:password@host:port/dbnum
+  -n <db>            Database number
+
+Protocol:
+  -2                 Start in RESP2 protocol mode
+  -3                 Start in RESP3 protocol mode
+
+Execution:
+  -r <repeat>        Execute command N times (-1 for infinite)
+  -i <interval>      Seconds between repeated commands (supports decimals like 0.1)
+                     Also used in --scan, --stat, --bigkeys, --memkeys, --keystats
+  -x                 Read last argument from STDIN
+  -X <tag>           Read tagged argument from STDIN
+
+Output:
+  --raw              Raw output (no type prefixes, default when not TTY)
+  --no-raw           Force human-readable output even when piping
+  --csv              CSV output format
+  --json             JSON output (default RESP3, use -2 for RESP2)
+  --quoted-json      JSON with ASCII-safe quoted strings
+  -d <delimiter>     Delimiter between response bulks in raw mode (default: \n)
+  -D <delimiter>     Delimiter between responses in raw mode (default: \n)
+
+Cluster:
+  -c                 Enable cluster mode (follow -ASK and -MOVED redirections)
+
+Behavior:
+  -e                 Return non-zero exit code on command failure
+  --verbose          Verbose output
+  --no-auth-warning  Suppress password-on-CLI warning
+  --quoted-input     Force input handling as quoted strings
+  --show-pushes <yn> Print RESP3 PUSH messages (default: yes in TTY)
+
+Special Modes:
+  --stat             Continuous server stats
+  --latency          Continuous latency sampling
+  --latency-history  Latency tracking over time (15s windows, change with -i)
+  --latency-dist     Latency spectrum visualization (requires xterm 256 colors)
+  --lru-test <keys>  Simulate LRU cache workload
+  --replica          Simulate replica, show commands from master
+  --rdb <filename>   Transfer RDB dump from remote server
+  --functions-rdb <filename>  RDB dump with functions only
+  --pipe             Transfer raw Redis protocol from stdin
+  --pipe-timeout <n> Pipe mode timeout in seconds (default: 30, 0 = forever)
+  --bigkeys          Scan for keys with many elements
+  --memkeys          Scan for keys consuming memory
+  --memkeys-samples <n>  Memory sampling count
+  --keystats         Combined bigkeys + memkeys with distribution
+  --keystats-samples <n> Key stats sampling count
+  --hotkeys          Find hot keys (requires *lfu maxmemory-policy)
+  --scan             List keys using SCAN
+  --pattern <pat>    Pattern for --scan, --bigkeys, --memkeys, --keystats, --hotkeys
+  --quoted-pattern <pat>  Same as --pattern, but accepts quoted binary-safe strings
+  --count <count>    COUNT hint for scan operations
+  --cursor <n>       Start scan at cursor (after Ctrl-C)
+  --top <n>          Display top N key sizes (default: 10, with --keystats)
+  --intrinsic-latency <sec>  Measure system baseline latency
+  --eval <file>      Execute Lua script
+  --ldb              Enable Lua debugger with --eval
+  --ldb-sync-mode    Synchronous Lua debugger (blocks server)
+  --cluster <cmd>    Cluster management command
+
+Examples:
+  redis-cli -u redis://default:PASSWORD@localhost:6379/0
+  cat /etc/passwd | redis-cli -x set mypasswd
+  redis-cli -D "" --raw dump key > key.dump && redis-cli -X dump_tag restore key2 0 dump_tag replace < key.dump
+  redis-cli -r 100 lpush mylist x
+  redis-cli -r 100 -i 1 info | grep used_memory_human:
+  redis-cli --eval myscript.lua key1 key2 , arg1 arg2 arg3
+```
+
+## Environment Variables
+
+| Variable | Purpose |
+|----------|---------|
+| `REDISCLI_AUTH` | Password for authentication (preferred over `-a` flag) |
+| `REDISCLI_HISTFILE` | Custom history file path (default: `~/.rediscli_history`, set to `/dev/null` to disable) |
+| `REDISCLI_RCFILE` | Custom preferences file path (default: `~/.redisclirc`) |
+| `HOME` | Base directory for `.rediscli_history` and `.redisclirc` |
+
+**Security tip**: Always prefer `REDISCLI_AUTH` over `-a <password>`. The `-a` flag exposes the password in shell history and process listings (`ps aux`).
+
+## SSL/TLS Configuration
+
+```bash
+# Enable TLS with trusted CA
+redis-cli --tls --cacert /path/to/ca.crt -h redis.example.com PING
+
+# CA certificate directory
+redis-cli --tls --cacertdir /etc/ssl/certs -h redis.example.com PING
+
+# Client certificate authentication (mutual TLS)
+redis-cli --tls --cacert /path/to/ca.crt \
+  --cert /path/to/client.crt \
+  --key /path/to/client.key \
+  -h redis.example.com PING
+```
+
+## Interactive Mode
+
+### Startup
+
+Run `redis-cli` without arguments to enter interactive mode:
+
+```
+$ redis-cli
+127.0.0.1:6379> PING
+PONG
+```
+
+The prompt shows `host:port[db_number]` and updates when you switch databases or connect to a different server.
+
+### Connection Management
+
+```
+CONNECT <host> <port>    # Connect to different instance
+SELECT <db>              # Switch database (prompt updates to show db number)
+QUIT                     # Exit redis-cli
+```
+
+On disconnection, redis-cli automatically attempts to reconnect. It re-selects the last database but loses other state (e.g., MULTI/EXEC transactions).
+
+### Editing and History
+
+- **Line editing**: Built-in linenoise library — no external dependencies
+- **History**: Arrow keys (up/down) access previous commands. Stored in `~/.rediscli_history`
+- **Tab completion**: Press TAB to complete command names
+- **Syntax hints**: Shown after entering a command name (toggle with `:set hints` / `:set nohints`)
+- **Reverse search**: `Ctrl+R` for history search
+
+### Preferences
+
+Set via `:set` command in interactive mode or in `~/.redisclirc`:
+
+```
+:set hints          # Enable syntax hints
+:set nohints        # Disable syntax hints
+```
+
+### Help System
+
+```
+HELP @<category>     # Show all commands in a category
+HELP <command>       # Show help for a specific command
+
+# Available categories:
+# @generic, @string, @list, @set, @sorted_set, @hash,
+# @pubsub, @transactions, @connection, @server, @scripting,
+# @hyperloglog, @cluster, @geo, @stream
+```
+
+### Screen Control
+
+```
+CLEAR               # Clear terminal screen
+```
+
+### Repeating Commands
+
+Prefix any command with a number to repeat it:
+
+```
+5 INCR mycounter    # Execute INCR mycounter 5 times
+```
+
+## String Quoting and Escaping
+
+When a string value contains whitespace or non-printable characters, use quoting:
+
+**Double-quoted strings** support escape sequences:
+- `\"` `\\` `\n` `\r` `\t` `\b` `\a` `\xhh` (hex)
+
+**Single-quoted strings** are literal, only escaping:
+- `\'` `\\`
+
+```
+SET mykey "Hello\nWorld"           # Two lines: Hello / World
+GET mykey
+# Hello
+# World
+
+AUTH user ">^8T>6Na{u|jp>+v\"55\@_"  # Escaped quotes in password
+```
+
+When the output target is not a terminal, redis-cli automatically uses raw output mode (no type prefixes like `(integer)`). Force with `--raw` or `--no-raw`.